vinext 0.1.1 → 0.1.3

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

@@ -1,28 +1,31 @@
 import { createRequestContext, runWithRequestContext } from "../shims/unified-request-context.js";
 import { getRequestExecutionContext } from "../shims/request-context.js";
-import { consumeDynamicUsage, consumeInvalidDynamicUsageError, consumeRenderRequestApiUsage, getAndClearPendingCookies, getDraftModeCookieHeader, isDraftModeRequest, markDynamicUsage, peekRenderRequestApiUsage, setHeadersContext } from "../shims/headers.js";
+import { beginPprFallbackShellFinalRender, createPprFallbackShellState, getPprFallbackShellState, runWithPprFallbackShellState } from "../shims/ppr-fallback-shell.js";
+import { consumeDynamicUsage, consumeInvalidDynamicUsageError, getAndClearPendingCookies, getDraftModeCookieHeader, isDraftModeRequest, markDynamicUsage, peekRenderRequestApiUsage, setHeadersContext } from "../shims/headers.js";
 import { _consumeRequestScopedCacheLife, _peekRequestScopedCacheLife } from "../shims/cache.js";
 import { AppElementsWire } from "./app-elements-wire.js";
 import { shouldSuppressLoadingBoundaries } from "./app-rsc-render-mode.js";
 import "./app-elements.js";
-import { consumeDynamicFetchObservations, ensureFetchPatch, getCollectedFetchTags, peekDynamicFetchObservations, runWithFetchDedupe, setCurrentFetchCacheMode, setCurrentFetchSoftTags } from "../shims/fetch-cache.js";
+import { ensureFetchPatch, getCollectedFetchTags, peekDynamicFetchObservations, runWithFetchDedupe, setCurrentFetchCacheMode, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault } from "../shims/fetch-cache.js";
 import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader } from "./app-rsc-cache-busting.js";
-import { readStreamAsText } from "../utils/text-stream.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import "./app-page-response.js";
-import { buildAppPageSpecialErrorResponse, resolveAppPageSpecialError, teeAppPageRscStreamForCapture } from "./app-page-execution.js";
+import { buildAppPageSpecialErrorResponse, probeAppPageThrownError, resolveAppPageSpecialError } from "./app-page-execution.js";
 import { createAppPageTreePath } from "./app-page-route-wiring.js";
-import { createAppPageHtmlOutputScope, createAppPageRenderObservation, createAppPageRscOutputScope } from "./app-page-render-observation.js";
-import { readAppPageCacheResponse } from "./app-page-cache.js";
+import { consumeAppPageRenderObservationState, discardAppPageRenderState } from "./app-page-render-observation.js";
+import { rewriteAppPprFallbackShellHtmlNavigation } from "./app-ppr-fallback-shell.js";
+import { readAppPageCacheResponse, readAppPageFallbackShellCacheResponse } from "./app-page-cache.js";
 import { resolveAppPageParentHttpAccessBoundary, resolveAppPageParentHttpAccessBoundaryModule } from "./app-page-boundary.js";
-import { isAppSsrRenderResult } from "./app-page-stream.js";
 import { createAppLayoutParamAccessTracker, isAppLayoutObservationUnsafeForStaticReuse } from "./app-layout-param-observation.js";
+import { buildAppPageTags } from "./implicit-tags.js";
+import { renderAppPageCacheArtifacts } from "./app-page-cache-render.js";
+import { warmPprFallbackShellCaches } from "./app-ppr-fallback-shell-render.js";
 import { resolveAppPageMethodResponse } from "./app-page-method.js";
+import { shouldServeStreamingMetadata } from "./streaming-metadata.js";
+import { resolveAppPageNavigationParams } from "./app-page-element-builder.js";
 import { buildAppPageElement, resolveAppPageIntercept, resolveAppPageInterceptionRerenderTarget, validateAppPageDynamicParams } from "./app-page-request.js";
 import { renderAppPageLifecycle } from "./app-page-render.js";
-import { shouldServeStreamingMetadata } from "./streaming-metadata.js";
 import { createStaticGenerationHeadersContext } from "./app-static-generation.js";
-import { buildPageCacheTags } from "./implicit-tags.js";
 import React from "react";
 //#region src/server/app-page-dispatch.ts
 function resolveAppPageRouteBoundaryModule(route, statusCode) {
@@ -106,9 +109,6 @@ function shouldReadAppPageCache(options) {
 function hasSearchParams(searchParams) {
 	return searchParams !== null && searchParams !== void 0 && searchParams.size > 0;
 }
-function buildAppPageTags(cleanPathname, extraTags, routeSegments) {
-	return buildPageCacheTags(cleanPathname, extraTags, [...routeSegments], "page");
-}
 async function runAppPageRevalidationContext(options, renderFn) {
 	return runWithRequestContext(createRequestContext({
 		headersContext: createStaticGenerationHeadersContext({
@@ -118,23 +118,20 @@ async function runAppPageRevalidationContext(options, renderFn) {
 			routePattern: options.routePattern
 		}),
 		currentFetchCacheMode: options.currentFetchCacheMode ?? null,
+		currentForceDynamicFetchDefault: options.dynamicConfig === "force-dynamic",
 		executionContext: getRequestExecutionContext(),
 		unstableCacheRevalidation: "foreground"
 	}), async () => {
 		ensureFetchPatch();
 		setCurrentFetchSoftTags(buildAppPageTags(options.cleanPathname, [], options.routeSegments));
 		options.setNavigationContext({
-			pathname: options.cleanPathname,
+			pathname: options.displayPathname ?? options.cleanPathname,
 			searchParams: new URLSearchParams(),
 			params: options.params
 		});
 		return await runWithFetchDedupe(renderFn);
 	});
 }
-function getCapturedRscDataPromise(capturedRscDataPromise) {
-	if (!capturedRscDataPromise) throw new Error("[vinext] Expected captured RSC data while regenerating an app page cache entry");
-	return capturedRscDataPromise;
-}
 function toInterceptOptions(interceptionContext, intercept) {
 	return {
 		interceptionContext,
@@ -143,11 +140,77 @@ function toInterceptOptions(interceptionContext, intercept) {
 		interceptParams: intercept.matchedParams,
 		interceptSlotId: intercept.slotId ?? null,
 		interceptSlotKey: intercept.slotKey,
-		interceptSourceMatchedUrl: interceptionContext
+		interceptSourceMatchedUrl: interceptionContext,
+		interceptSourcePageSegments: intercept.sourcePageSegments ?? null
 	};
 }
+/**
+* Request-phase fallback-shell gate. Callers must run the exact cache read and
+* static-param validation before this classification step.
+*/
+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, route, fallbackShells, currentRevalidateSeconds) {
+	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;
+}
+async function tryServePprFallbackShell(options, route, currentRevalidateSeconds, isDraftMode, isForceStatic, isForceDynamic) {
+	const decision = classifyPprFallbackShellEligibility(options, currentRevalidateSeconds, isDraftMode, isForceStatic, isForceDynamic);
+	switch (decision.kind) {
+		case "skip-known-pregenerated-route":
+		case "skip-no-fallback-shells":
+		case "skip-rsc-request":
+		case "skip-non-get":
+		case "skip-search-params":
+		case "skip-cache-disabled": return null;
+		case "probe-fallback-shells": return await probePprFallbackShellCache(options, route, decision.fallbackShells, currentRevalidateSeconds);
+	}
+}
 async function dispatchAppPage(options) {
-	return await runWithFetchDedupe(() => dispatchAppPageInner(options));
+	const dispatch = () => runWithFetchDedupe(() => dispatchAppPageInner(options));
+	if (!options.pprFallbackShell) return await dispatch();
+	return await runWithPprFallbackShellState(createPprFallbackShellState(options.pprFallbackShell), dispatch);
 }
 async function dispatchAppPageInner(options) {
 	const route = options.route;
@@ -160,6 +223,7 @@ async function dispatchAppPageInner(options) {
 	const layoutParamAccess = createAppLayoutParamAccessTracker();
 	setCurrentFetchSoftTags(buildAppPageTags(options.cleanPathname, [], route.routeSegments));
 	setCurrentFetchCacheMode(options.fetchCache ?? null);
+	setCurrentForceDynamicFetchDefault(isForceDynamic);
 	if (options.hasPageModule && !options.hasPageDefaultExport) {
 		options.clearRequestContext();
 		return new Response("Page has no default export", { status: 500 });
@@ -183,10 +247,11 @@ async function dispatchAppPageInner(options) {
 			routeKind: "page",
 			routePattern: route.pattern
 		}));
+		const staticNavigationParams = resolveAppPageNavigationParams(route, options.params, options.cleanPathname, null);
 		options.setNavigationContext({
-			pathname: options.cleanPathname,
+			pathname: options.displayPathname ?? options.cleanPathname,
 			searchParams: new URLSearchParams(),
-			params: options.params
+			params: staticNavigationParams
 		});
 	}
 	if (shouldReadAppPageCache({
@@ -233,12 +298,14 @@ async function dispatchAppPageInner(options) {
 						return toInterceptOptions(options.interceptionContext, intercept);
 					}
 				});
+				revalidationTarget.navigationParams = resolveAppPageNavigationParams(revalidationTarget.route, revalidationTarget.navigationParams, options.cleanPathname, revalidationTarget.interceptOpts);
 				await options.ensureRouteLoaded?.(revalidationTarget.route);
 				return runAppPageRevalidationContext({
 					cleanPathname: options.cleanPathname,
+					displayPathname: options.displayPathname,
 					currentFetchCacheMode: options.resolveRouteFetchCacheMode?.(revalidationTarget.route) ?? (revalidationTarget.route === route ? options.fetchCache ?? null : null),
 					draftModeSecret: options.draftModeSecret,
-					dynamicConfig,
+					dynamicConfig: options.resolveRouteDynamicConfig?.(revalidationTarget.route) ?? (revalidationTarget.route === route ? dynamicConfig : void 0),
 					params: revalidationTarget.navigationParams,
 					routePattern: revalidationTarget.route.pattern,
 					routeSegments: revalidationTarget.route.routeSegments,
@@ -246,72 +313,34 @@ async function dispatchAppPageInner(options) {
 				}, async () => {
 					const revalidatedElement = await options.buildPageElement(revalidationTarget.route, revalidationTarget.params, revalidationTarget.interceptOpts, new URLSearchParams());
 					const revalidatedOnError = options.createRscOnErrorHandler(options.cleanPathname, revalidationTarget.route.pattern);
-					const revalidatedRscCapture = teeAppPageRscStreamForCapture(options.renderToReadableStream(revalidatedElement, { onError: revalidatedOnError }), true);
-					const revalidatedSsrEntry = await options.loadSsrHandler();
-					const revalidatedCapturedRscRef = { value: null };
-					const revalidatedHtmlResult = await revalidatedSsrEntry.handleSsr(revalidatedRscCapture.ssrStream, options.getNavigationContext(), {
-						links: options.getFontLinks(),
-						styles: options.getFontStyles(),
-						preloads: options.getFontPreloads()
-					}, {
+					const rendered = await renderAppPageCacheArtifacts({
 						basePath: options.basePath,
+						captureRscData: true,
+						cleanPathname: options.cleanPathname,
 						clientTraceMetadata: options.clientTraceMetadata,
+						element: revalidatedElement,
+						getFontLinks: options.getFontLinks,
+						getFontPreloads: options.getFontPreloads,
+						getFontStyles: options.getFontStyles,
+						getNavigationContext: options.getNavigationContext,
+						loadSsrHandler: options.loadSsrHandler,
+						mountedSlotsHeader: options.mountedSlotsHeader,
+						navigationParams: revalidationTarget.navigationParams,
+						onError: revalidatedOnError,
 						reactMaxHeadersLength: options.reactMaxHeadersLength,
+						renderToReadableStream: options.renderToReadableStream,
 						rootParams: options.rootParams,
-						waitForAllReady: true,
-						...revalidatedRscCapture.sideStream ? {
-							sideStream: revalidatedRscCapture.sideStream,
-							capturedRscDataRef: revalidatedCapturedRscRef
-						} : {}
+						route: revalidationTarget.route,
+						waitForAllReady: true
 					});
-					const html = await readStreamAsText(isAppSsrRenderResult(revalidatedHtmlResult) ? revalidatedHtmlResult.htmlStream : revalidatedHtmlResult);
-					const rscData = await getCapturedRscDataPromise(revalidatedCapturedRscRef.value);
-					const cacheLife = _consumeRequestScopedCacheLife();
 					options.clearRequestContext();
-					const tags = buildAppPageTags(options.cleanPathname, getCollectedFetchTags(), revalidationTarget.route.routeSegments);
-					const observationState = {
-						dynamicFetches: consumeDynamicFetchObservations(),
-						requestApis: consumeRenderRequestApiUsage()
-					};
 					return {
-						html,
-						htmlRenderObservation: createAppPageRenderObservation({
-							boundaryOutcome: { kind: "success" },
-							cacheability: "public",
-							cacheTags: tags,
-							cleanPathname: options.cleanPathname,
-							completeness: "complete",
-							output: createAppPageHtmlOutputScope({
-								element: revalidatedElement,
-								renderEpoch: null,
-								rootBoundaryId: null,
-								routePattern: revalidationTarget.route.pattern
-							}),
-							params: revalidationTarget.navigationParams,
-							state: observationState
-						}),
-						rscData,
-						rscRenderObservation: createAppPageRenderObservation({
-							boundaryOutcome: { kind: "success" },
-							cacheability: "public",
-							cacheTags: tags,
-							cleanPathname: options.cleanPathname,
-							completeness: "complete",
-							output: createAppPageRscOutputScope({
-								element: revalidatedElement,
-								mountedSlotsHeader: options.mountedSlotsHeader,
-								renderEpoch: null,
-								rootBoundaryId: null,
-								routePattern: revalidationTarget.route.pattern
-							}),
-							params: revalidationTarget.navigationParams,
-							state: observationState
-						}),
-						tags,
-						cacheControl: typeof cacheLife?.revalidate === "number" ? {
-							revalidate: cacheLife.revalidate,
-							expire: cacheLife.expire
-						} : void 0
+						html: rendered.html,
+						htmlRenderObservation: rendered.htmlRenderObservation,
+						rscData: rendered.rscData,
+						rscRenderObservation: rendered.rscRenderObservation,
+						tags: rendered.tags,
+						cacheControl: rendered.cacheControl
 					};
 				});
 			},
@@ -325,18 +354,23 @@ async function dispatchAppPageInner(options) {
 		});
 		if (cachedPageResponse) return cachedPageResponse;
 	}
-	const dynamicParamsResponse = await validateAppPageDynamicParams({
-		clearRequestContext: options.clearRequestContext,
-		enforceStaticParamsOnly: options.dynamicParamsConfig === false,
-		generateStaticParams: options.generateStaticParams,
-		isDynamicRoute: route.isDynamic,
-		params: options.staticParamsValidationParams ?? options.params
-	});
-	if (dynamicParamsResponse) return dynamicParamsResponse;
+	if (options.skipStaticParamsValidation !== true) {
+		const dynamicParamsResponse = await validateAppPageDynamicParams({
+			clearRequestContext: options.clearRequestContext,
+			enforceStaticParamsOnly: options.dynamicParamsConfig === false,
+			generateStaticParams: options.generateStaticParams,
+			isDynamicRoute: route.isDynamic,
+			params: options.staticParamsValidationParams ?? options.params
+		});
+		if (dynamicParamsResponse) return dynamicParamsResponse;
+	}
+	const fallbackShellResponse = await tryServePprFallbackShell(options, route, currentRevalidateSeconds, isDraftMode, isForceStatic, isForceDynamic);
+	if (fallbackShellResponse) return fallbackShellResponse;
 	const interceptResult = await resolveAppPageIntercept({
 		async buildPageElement(interceptRoute, interceptParams, interceptOpts, interceptSearchParams, interceptLayoutParamAccess) {
 			await options.ensureRouteLoaded?.(interceptRoute);
 			setCurrentFetchCacheMode(options.resolveRouteFetchCacheMode?.(interceptRoute) ?? null);
+			setCurrentForceDynamicFetchDefault(options.resolveRouteDynamicConfig?.(interceptRoute) === "force-dynamic");
 			return options.buildPageElement(interceptRoute, interceptParams, interceptOpts, interceptSearchParams, interceptLayoutParamAccess);
 		},
 		cleanPathname: options.cleanPathname,
@@ -352,6 +386,9 @@ async function dispatchAppPageInner(options) {
 		},
 		isRscRequest: options.isRscRequest,
 		layoutParamAccess,
+		resolveNavigationParams(sourceRoute, navigationParams, pathname, interceptOpts) {
+			return resolveAppPageNavigationParams(sourceRoute, navigationParams, pathname, interceptOpts);
+		},
 		renderInterceptResponse(sourceRoute, interceptElement) {
 			const interceptOnError = options.createRscOnErrorHandler(options.cleanPathname, sourceRoute.pattern);
 			const interceptStream = options.renderToReadableStream(interceptElement, { onError: interceptOnError });
@@ -373,11 +410,20 @@ async function dispatchAppPageInner(options) {
 		}
 	});
 	if (interceptResult.response) return interceptResult.response;
-	const pageBuildResult = await buildAppPageElement({
+	const buildCurrentPageElement = () => buildAppPageElement({
 		buildPageElement() {
 			if (options.actionFailed) throw options.actionError;
 			return options.buildPageElement(route, options.params, interceptResult.interceptOpts, options.searchParams, layoutParamAccess);
 		},
+		async probePageSpecialError() {
+			if (!shouldSuppressLoadingBoundaries(options.renderMode ?? "navigation") && route.loading?.default) return null;
+			return resolveAppPageSpecialError(await probeAppPageThrownError({
+				probePage: options.probePage,
+				runWithSuppressedHookWarning(probe) {
+					return options.runWithSuppressedHookWarning(probe);
+				}
+			}));
+		},
 		renderErrorBoundaryPage(buildError) {
 			return options.renderErrorBoundaryPage(buildError);
 		},
@@ -386,8 +432,30 @@ async function dispatchAppPageInner(options) {
 		},
 		resolveSpecialError: resolveAppPageSpecialError
 	});
+	const fallbackShellState = getPprFallbackShellState();
+	if (fallbackShellState && process.env.VINEXT_PRERENDER === "1" && !options.isRscRequest) {
+		const warmupBuildResult = await buildCurrentPageElement();
+		if (warmupBuildResult.response) return warmupBuildResult.response;
+		await warmPprFallbackShellCaches({
+			element: warmupBuildResult.element,
+			onError: options.createRscOnErrorHandler(options.cleanPathname, route.pattern),
+			renderToReadableStream: options.renderToReadableStream,
+			state: fallbackShellState
+		});
+		discardAppPageRenderState();
+	}
+	const pageBuildResult = await buildCurrentPageElement();
 	if (pageBuildResult.response) return pageBuildResult.response;
+	const navigationParams = resolveAppPageNavigationParams(route, options.params, options.cleanPathname, interceptResult.interceptOpts);
+	options.setNavigationContext({
+		pathname: options.displayPathname ?? options.cleanPathname,
+		searchParams: options.searchParams,
+		params: navigationParams
+	});
 	const layoutClassifications = getEffectiveLayoutClassifications(route, options.debugClassification);
+	const activeFallbackShellState = getPprFallbackShellState();
+	const pprFallbackShellSignal = activeFallbackShellState?.abortController.signal;
+	const pprFallbackShellReactSignal = activeFallbackShellState?.reactAbortController.signal;
 	return renderAppPageLifecycle({
 		basePath: options.basePath,
 		clientTraceMetadata: options.clientTraceMetadata,
@@ -396,12 +464,7 @@ async function dispatchAppPageInner(options) {
 		clearRequestContext: options.clearRequestContext,
 		consumeDynamicUsage,
 		consumeInvalidDynamicUsageError,
-		consumeRenderObservationState() {
-			return {
-				dynamicFetches: consumeDynamicFetchObservations(),
-				requestApis: consumeRenderRequestApiUsage()
-			};
-		},
+		consumeRenderObservationState: consumeAppPageRenderObservationState,
 		createRscOnErrorHandler(pathname, routePath) {
 			return options.createRscOnErrorHandler(pathname, routePath);
 		},
@@ -442,7 +505,13 @@ async function dispatchAppPageInner(options) {
 		layoutCount: route.layouts.length,
 		loadSsrHandler: options.loadSsrHandler,
 		middlewareContext: options.middlewareContext,
+		navigationParams,
 		params: options.params,
+		pprFallbackShellSignal,
+		pprFallbackShellReactSignal,
+		abortPprFallbackShell: activeFallbackShellState ? () => {
+			beginPprFallbackShellFinalRender(activeFallbackShellState);
+		} : void 0,
 		layoutParamAccess,
 		rootParams: options.rootParams,
 		peekRenderObservationState() {
@@ -495,7 +564,8 @@ async function dispatchAppPageInner(options) {
 			return renderPageSpecialError(options, specialError);
 		},
 		renderToReadableStream: options.renderToReadableStream,
-		routeHasLocalBoundary: Boolean(route.error?.default || route.errors?.some((errorModule) => errorModule?.default)),
+		hasCustomGlobalError: options.hasCustomGlobalError,
+		prerenderToReadableStream: options.prerenderToReadableStream,
 		routePattern: route.pattern,
 		runWithSuppressedHookWarning(probe) {
 			return options.runWithSuppressedHookWarning(probe);

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

@@ -24,6 +24,7 @@ type AppPageInterceptOptions<TModule extends AppPageModule = AppPageModule> = {
   interceptSlotId?: string | null;
   interceptSlotKey?: string | null;
   interceptSourceMatchedUrl?: string | null;
+  interceptSourcePageSegments?: readonly string[] | null;
 };
 type AppPagePageRequest<TModule extends AppPageModule = AppPageModule> = {
   /** Interception context from current-route navigation (null for direct visits). */opts?: AppPageInterceptOptions<TModule> | null; /** URL search params from the incoming request (null when unavailable). */
@@ -49,9 +50,28 @@ type BuildPageElementsOptions<TModule extends AppPageModule = AppPageModule, TEr
    * Configured next.config `basePath`. Threaded through `resolveAppPageHead`
    * so file-based metadata route URLs emitted in <head> are prefixed.
    */
-  basePath?: string; /** Serialized next.config `htmlLimitedBots` regexp source. */
+  basePath?: string; /** Configured next.config `trailingSlash`, threaded into canonical URL rendering. */
+  trailingSlash?: boolean; /** Serialized next.config `htmlLimitedBots` regexp source. */
   htmlLimitedBots?: 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.
  *
@@ -69,5 +89,6 @@ type BuildPageElementsOptions<TModule extends AppPageModule = AppPageModule, TEr
  * {@link https://github.com/vercel/next.js/blob/canary/packages/next/src/server/app-render/create-metadata.tsx|create-metadata.tsx}.
  */
 declare function buildPageElements<TModule extends AppPageModule = AppPageModule, TErrorModule extends AppPageErrorModule = AppPageErrorModule>(options: BuildPageElementsOptions<TModule, TErrorModule>): Promise<AppElements>;
+declare function resolveAppPageNavigationParams(route: AppPageNavigationParamRoute, routeParams: AppPageParams, routePath: string, opts?: AppPageNavigationParamInterceptOptions | null): AppPageParams;
 //#endregion
-export { AppPageBuildRoute, type AppPageErrorModule, AppPageInterceptOptions, AppPagePageRequest, type AppPageRouteWiringRoute, BuildPageElementsOptions, buildPageElements };
+export { AppPageBuildRoute, type AppPageErrorModule, AppPageInterceptOptions, AppPagePageRequest, type AppPageRouteWiringRoute, BuildPageElementsOptions, buildPageElements, resolveAppPageNavigationParams };

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

@@ -6,10 +6,10 @@ import { createAppPageRenderIdentity } from "./app-page-render-identity.js";
 import { makeThenableParams } from "../shims/thenable-params.js";
 import { resolveActiveParallelRouteHeadInputs, resolveAppPageHead } from "./app-page-head.js";
 import { makeObservedAppPageSearchParamsThenable } from "./app-page-search-params-observation.js";
-import { buildAppPageElements, createAppPageTreePath } from "./app-page-route-wiring.js";
+import { buildAppPageElements, createAppPageSourcePage, createAppPageTreePath } from "./app-page-route-wiring.js";
 import { DEFAULT_GLOBAL_ERROR_MODULE } from "./default-global-error-module.js";
-import { shouldServeStreamingMetadata } from "./streaming-metadata.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
 /**
@@ -36,6 +36,7 @@ async function buildPageElements(options) {
 	const effectivePageModule = isSiblingIntercept ? opts.interceptPage : pageModule;
 	const EffectivePageComponent = effectivePageModule?.default;
 	const effectiveParams = isSiblingIntercept ? opts.interceptParams ?? params : params;
+	const sourcePageSegments = isSiblingIntercept ? opts?.interceptSourcePageSegments : route.routeSegments;
 	const hasPageModule = !!pageModule;
 	const renderIdentity = createAppPageRenderIdentity({
 		displayPathname,
@@ -56,7 +57,8 @@ async function buildPageElements(options) {
 				interceptionContext: renderIdentity.interceptionContext,
 				layoutIds: noExportLayoutIds,
 				rootLayoutTreePath: noExportRootLayout,
-				routeId: renderIdentity.routeId
+				routeId: renderIdentity.routeId,
+				sourcePage: createAppPageSourcePage(sourcePageSegments)
 			}),
 			[renderIdentity.routeId]: createElement("div", null, "Page has no default export")
 		};
@@ -112,13 +114,15 @@ async function buildPageElements(options) {
 		resolvedViewport,
 		renderIdentity,
 		routePath,
+		sourcePageSegments,
 		rootNotFoundModule: rootNotFoundModule ?? null,
 		rootForbiddenModule: rootForbiddenModule ?? null,
 		rootUnauthorizedModule: rootUnauthorizedModule ?? null,
 		route,
 		searchParams: pageSearchParamsThenable,
 		slotOverrides,
-		renderMode
+		renderMode,
+		trailingSlash: options.trailingSlash
 	});
 }
 /**
@@ -142,6 +146,18 @@ function buildSlotOverrides(route, routeParams, routePath, opts) {
 		pageModule: opts.interceptPage,
 		params: opts.interceptParams || routeParams
 	};
+	const slotParamOverrides = resolveSlotParamOverrides(route, routePath);
+	for (const [slotKey, params] of Object.entries(slotParamOverrides ?? {})) {
+		const existing = overrides[slotKey];
+		overrides[slotKey] = existing ? {
+			...existing,
+			params
+		} : { params };
+	}
+	return Object.keys(overrides).length > 0 ? overrides : null;
+}
+function resolveSlotParamOverrides(route, routePath) {
+	const overrides = {};
 	const slots = route.slots;
 	if (slots) {
 		let urlParts = null;
@@ -154,19 +170,35 @@ function buildSlotOverrides(route, routeParams, routePath, opts) {
 			if (urlParts === null) urlParts = routePath.split("/").filter(Boolean);
 			const matched = matchRoutePattern(urlParts, patternParts);
 			if (!matched) continue;
-			const existing = overrides[slotKey];
-			overrides[slotKey] = existing ? {
-				...existing,
-				params: matched
-			} : { params: matched };
+			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 { buildPageElements };
+export { buildPageElements, resolveAppPageNavigationParams };

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

@@ -103,7 +103,7 @@ type LayoutClassificationOptions = {
    * unsafe even if the older dynamic scope did not report dynamic usage.
    */
   isLayoutObservationDynamic?: (layoutId: string) => boolean; /** Runs a function with isolated dynamic usage tracking per layout. */
-  runWithIsolatedDynamicScope: <T>(fn: () => T) => Promise<{
+  runWithIsolatedDynamicScope: <T>(fn: () => T | Promise<T>) => Promise<{
     result: T;
     dynamicDetected: boolean;
   }>;
@@ -121,13 +121,18 @@ type ProbeAppPageComponentOptions = {
   probePage: () => unknown;
   runWithSuppressedHookWarning<T>(probe: () => Promise<T>): Promise<T>;
 };
+type ProbeAppPageThrownErrorOptions = {
+  probePage: () => unknown;
+  runWithSuppressedHookWarning<T>(probe: () => Promise<T>): Promise<T>;
+};
 declare function resolveAppPageSpecialError(error: unknown): AppPageSpecialError | null;
 declare function buildAppPageSpecialErrorResponse(options: BuildAppPageSpecialErrorResponseOptions): Promise<Response>;
 /** See `LayoutFlags` type docblock in app-elements.ts for lifecycle. */
 declare function probeAppPageLayouts(options: ProbeAppPageLayoutsOptions): Promise<ProbeAppPageLayoutsResult>;
 declare function probeAppPageComponent(options: ProbeAppPageComponentOptions): Promise<Response | null>;
+declare function probeAppPageThrownError(options: ProbeAppPageThrownErrorOptions): Promise<unknown>;
 declare function readAppPageBinaryStream(stream: ReadableStream<Uint8Array>): Promise<ArrayBuffer>;
 declare function teeAppPageRscStreamForCapture(stream: ReadableStream<Uint8Array>, shouldCapture: boolean): AppPageRscStreamCapture;
 declare function buildAppPageFontLinkHeader(preloads: readonly AppPageFontPreload[] | null | undefined): string;
 //#endregion
-export { AppPageFontPreload, AppPageSpecialError, LayoutClassificationOptions, type LayoutFlags, buildAppPageFontLinkHeader, buildAppPageSpecialErrorResponse, probeAppPageComponent, probeAppPageLayouts, readAppPageBinaryStream, resolveAppPageSpecialError, tagAppPageMetadataError, teeAppPageRscStreamForCapture };
+export { AppPageFontPreload, AppPageSpecialError, LayoutClassificationOptions, type LayoutFlags, buildAppPageFontLinkHeader, buildAppPageSpecialErrorResponse, probeAppPageComponent, probeAppPageLayouts, probeAppPageThrownError, readAppPageBinaryStream, resolveAppPageSpecialError, tagAppPageMetadataError, teeAppPageRscStreamForCapture };