vinext 0.1.0 → 0.1.1

package/dist/server/app-browser-state.js

@@ -99,7 +99,8 @@ function createBfcacheSegmentStateKeyMap(options) {
 	return stateKeys;
 }
 function createNextBfcacheIdMap(options) {
-	for (const value of Object.values(options.current)) rememberBfcacheId(value);
+	const current = options.reuseCurrent === false ? {} : options.current;
+	for (const value of Object.values(current)) rememberBfcacheId(value);
 	for (const value of Object.values(options.restored ?? {})) rememberBfcacheId(value);
 	const currentMetadata = readAppElementsMetadata(options.currentElements);
 	const nextMetadata = readAppElementsMetadata(options.elements);
@@ -113,7 +114,7 @@ function createNextBfcacheIdMap(options) {
 		}) === createBfcacheSegmentIdentity(id, {
 			metadata: nextMetadata,
 			pathname: nextPathname
-		}) ? options.current[id] : void 0;
+		}) ? current[id] : void 0;
 		const value = options.restored?.[id] ?? currentValue ?? mintBfcacheId();
 		ids[id] = value;
 		rememberBfcacheId(value);
@@ -396,7 +397,8 @@ async function createPendingNavigationCommit(options) {
 				currentPathname: options.currentState.navigationSnapshot.pathname,
 				elements,
 				nextPathname: options.navigationSnapshot.pathname,
-				restored: options.restoredBfcacheIds
+				restored: options.restoredBfcacheIds,
+				reuseCurrent: options.reuseCurrentBfcacheIds
 			}),
 			...cacheEntryReuseProof ? { cacheEntryReuseProof } : {},
 			elements,
@@ -414,6 +416,7 @@ async function createPendingNavigationCommit(options) {
 			previousNextUrl,
 			renderId: options.renderId,
 			rootLayoutTreePath: metadata.rootLayoutTreePath,
+			reuseCurrentBfcacheIds: options.reuseCurrentBfcacheIds ?? true,
 			routeId: metadata.routeId,
 			skippedLayoutIds: metadata.skippedLayoutIds,
 			type: options.type

package/dist/server/app-browser-visible-commit.js

@@ -56,29 +56,31 @@ function reduceApprovedVisibleCommitState(state, commit) {
 	switch (action.type) {
 		case "traverse":
 		case "navigate": {
+			const preserveElementIds = action.reuseCurrentBfcacheIds ? commit.decision.preserveElementIds : [];
+			const preservePreviousSlotIds = action.reuseCurrentBfcacheIds ? commit.decision.preservePreviousSlotIds : [];
 			const mergedElements = mergeElements(state.elements, action.elements, {
-				clearAbsentSlots: action.type === "traverse",
-				preserveAbsentSlots: commit.decision.preserveAbsentSlots,
-				preserveElementIds: commit.decision.preserveElementIds,
-				preservePreviousSlotIds: commit.decision.preservePreviousSlotIds
+				clearAbsentSlots: action.type === "traverse" || !action.reuseCurrentBfcacheIds,
+				preserveAbsentSlots: action.reuseCurrentBfcacheIds && commit.decision.preserveAbsentSlots,
+				preserveElementIds,
+				preservePreviousSlotIds
 			});
 			return commitVisibleRouterState(state, {
 				bfcacheIds: preserveBfcacheIdsForMergedElements({
 					elements: mergedElements,
 					next: action.bfcacheIds,
-					previous: state.bfcacheIds
+					previous: action.reuseCurrentBfcacheIds ? state.bfcacheIds : {}
 				}),
 				elements: mergedElements,
 				interception: action.interception,
 				interceptionContext: action.interceptionContext,
-				layoutFlags: mergeLayoutFlags(state.layoutFlags, action.layoutFlags, commit.decision.preserveElementIds),
+				layoutFlags: mergeLayoutFlags(state.layoutFlags, action.layoutFlags, preserveElementIds),
 				layoutIds: action.layoutIds,
 				navigationSnapshot: action.navigationSnapshot,
 				previousNextUrl: action.previousNextUrl,
 				renderId: action.renderId,
 				rootLayoutTreePath: action.rootLayoutTreePath,
 				routeId: action.routeId,
-				slotBindings: mergeSlotBindings(state.slotBindings, action.slotBindings, action.layoutIds, commit.decision.preservePreviousSlotIds)
+				slotBindings: mergeSlotBindings(state.slotBindings, action.slotBindings, action.layoutIds, preservePreviousSlotIds)
 			}, action.operation);
 		}
 		case "replace": return commitVisibleRouterState(state, {

package/dist/server/app-history-state.d.ts

@@ -10,6 +10,50 @@ type HistoryTraversalIntent = {
   historyState: unknown;
   targetHistoryIndex: number | null;
 };
+type HistoryStateSnapshotRestoreDecision<TState> = {
+  kind: "restore";
+  state: TState;
+  targetHistoryIndex: number;
+} | {
+  kind: "skip";
+  reason: "guarded" | "missing-history-index" | "missing-snapshot" | "stale-bfcache-version";
+  targetHistoryIndex: number | null;
+};
+declare class HistoryStateSnapshotCache<TState> {
+  #private;
+  constructor(options: {
+    maxEntries: number;
+  });
+  clear(): void;
+  remember(options: {
+    bfcacheVersion: number;
+    historyIndex: number | null;
+    state: TState;
+  }): void;
+  resolveRestore(options: {
+    currentBfcacheVersion: number;
+    guarded: boolean;
+    historyState: unknown;
+  }): HistoryStateSnapshotRestoreDecision<TState>;
+}
+declare class RestorableClientStateController<TState> {
+  #private;
+  constructor(options: {
+    initialHistoryState: unknown;
+    maxHistoryStateSnapshots: number;
+  });
+  get currentBfcacheVersion(): number;
+  beginCacheInvalidationGuard(): () => void;
+  isCacheInvalidationGuarded(): boolean;
+  isCurrentBfcacheVersion(historyState: unknown): boolean;
+  readCurrentBfcacheVersionHistoryIds(historyState: unknown): BfcacheIdMap | null;
+  invalidateClientState(): void;
+  rememberHistoryStateSnapshot(options: {
+    historyIndex: number | null;
+    state: TState;
+  }): void;
+  resolveHistoryStateSnapshotRestore(historyState: unknown): HistoryStateSnapshotRestoreDecision<TState>;
+}
 declare function createHistoryStateWithPreviousNextUrl(state: unknown, previousNextUrl: string | null): HistoryStateRecord | null;
 declare function createHistoryStateWithNavigationMetadata(state: unknown, metadata: {
   bfcacheIds?: BfcacheIdMap | null;
@@ -39,4 +83,4 @@ declare function resolveHistoryTraversalIntent(options: {
   historyState: unknown;
 }): HistoryTraversalIntent;
 //#endregion
-export { BfcacheIdMap, HistoryTraversalIntent, createExternalHistoryStatePreservingMetadata, createHashOnlyHistoryStatePreservingNavigationMetadata, createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, isBfcacheSegmentId, isHistoryStateBfcacheVersionCurrent, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent };
+export { BfcacheIdMap, HistoryStateSnapshotCache, HistoryTraversalIntent, RestorableClientStateController, createExternalHistoryStatePreservingMetadata, createHashOnlyHistoryStatePreservingNavigationMetadata, createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, isBfcacheSegmentId, isHistoryStateBfcacheVersionCurrent, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent };

package/dist/server/app-history-state.js

@@ -6,6 +6,114 @@ const VINEXT_PREVIOUS_NEXT_URL_HISTORY_STATE_KEY = "__vinext_previousNextUrl";
 const VINEXT_HISTORY_INDEX_HISTORY_STATE_KEY = "__vinext_historyIndex";
 const VINEXT_BFCACHE_IDS_HISTORY_STATE_KEY = "__vinext_bfcacheIds";
 const VINEXT_BFCACHE_VERSION_HISTORY_STATE_KEY = "__vinext_bfcacheVersion";
+var HistoryStateSnapshotCache = class {
+	#maxEntries;
+	#snapshots = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.#maxEntries = options.maxEntries;
+	}
+	clear() {
+		this.#snapshots.clear();
+	}
+	remember(options) {
+		if (options.historyIndex === null) return;
+		this.#snapshots.delete(options.historyIndex);
+		this.#snapshots.set(options.historyIndex, {
+			bfcacheVersion: options.bfcacheVersion,
+			state: options.state
+		});
+		if (this.#snapshots.size <= this.#maxEntries) return;
+		const oldestIndex = this.#snapshots.keys().next().value;
+		if (typeof oldestIndex === "number") this.#snapshots.delete(oldestIndex);
+	}
+	resolveRestore(options) {
+		const targetHistoryIndex = readHistoryStateTraversalIndex(options.historyState);
+		if (targetHistoryIndex === null) return {
+			kind: "skip",
+			reason: "missing-history-index",
+			targetHistoryIndex
+		};
+		const snapshot = this.#snapshots.get(targetHistoryIndex);
+		if (!snapshot) return {
+			kind: "skip",
+			reason: "missing-snapshot",
+			targetHistoryIndex
+		};
+		if (options.guarded) return {
+			kind: "skip",
+			reason: "guarded",
+			targetHistoryIndex
+		};
+		if (snapshot.bfcacheVersion !== options.currentBfcacheVersion) {
+			this.#snapshots.delete(targetHistoryIndex);
+			return {
+				kind: "skip",
+				reason: "stale-bfcache-version",
+				targetHistoryIndex
+			};
+		}
+		return {
+			kind: "restore",
+			state: snapshot.state,
+			targetHistoryIndex
+		};
+	}
+};
+var RestorableClientStateController = class {
+	#currentBfcacheVersion;
+	#pendingCacheInvalidationGuards = 0;
+	#snapshots;
+	constructor(options) {
+		const initialHistoryBfcacheVersion = readHistoryStateBfcacheVersion(options.initialHistoryState);
+		this.#currentBfcacheVersion = initialHistoryBfcacheVersion === null ? 0 : initialHistoryBfcacheVersion + 1;
+		this.#snapshots = new HistoryStateSnapshotCache({ maxEntries: options.maxHistoryStateSnapshots });
+	}
+	get currentBfcacheVersion() {
+		return this.#currentBfcacheVersion;
+	}
+	beginCacheInvalidationGuard() {
+		this.#pendingCacheInvalidationGuards += 1;
+		let released = false;
+		return () => {
+			if (released) return;
+			released = true;
+			this.#pendingCacheInvalidationGuards = Math.max(0, this.#pendingCacheInvalidationGuards - 1);
+		};
+	}
+	isCacheInvalidationGuarded() {
+		return this.#pendingCacheInvalidationGuards > 0;
+	}
+	isCurrentBfcacheVersion(historyState) {
+		return isHistoryStateBfcacheVersionCurrent(historyState, this.#currentBfcacheVersion);
+	}
+	readCurrentBfcacheVersionHistoryIds(historyState) {
+		if (this.isCacheInvalidationGuarded()) return null;
+		const ids = readHistoryStateBfcacheIds(historyState);
+		if (ids === null) return null;
+		return this.isCurrentBfcacheVersion(historyState) ? ids : null;
+	}
+	#invalidateBfcacheIds() {
+		this.#currentBfcacheVersion += 1;
+	}
+	invalidateClientState() {
+		this.#snapshots.clear();
+		this.#invalidateBfcacheIds();
+	}
+	rememberHistoryStateSnapshot(options) {
+		this.#snapshots.remember({
+			bfcacheVersion: this.#currentBfcacheVersion,
+			historyIndex: options.historyIndex,
+			state: options.state
+		});
+	}
+	resolveHistoryStateSnapshotRestore(historyState) {
+		return this.#snapshots.resolveRestore({
+			currentBfcacheVersion: this.#currentBfcacheVersion,
+			guarded: this.isCacheInvalidationGuarded(),
+			historyState
+		});
+	}
+};
 function cloneHistoryState(state) {
 	if (!state || typeof state !== "object") return {};
 	const nextState = {};
@@ -112,4 +220,4 @@ function resolveHistoryTraversalIntent(options) {
 	};
 }
 //#endregion
-export { createExternalHistoryStatePreservingMetadata, createHashOnlyHistoryStatePreservingNavigationMetadata, createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, isBfcacheSegmentId, isHistoryStateBfcacheVersionCurrent, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent };
+export { HistoryStateSnapshotCache, RestorableClientStateController, createExternalHistoryStatePreservingMetadata, createHashOnlyHistoryStatePreservingNavigationMetadata, createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, isBfcacheSegmentId, isHistoryStateBfcacheVersionCurrent, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent };

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

@@ -1,15 +1,19 @@
 import { AppElementsWire } from "./app-elements-wire.js";
 import "./app-elements.js";
-import { ErrorBoundary } from "../shims/error-boundary.js";
+import { isNavigationSignalError } from "../utils/navigation-signal.js";
+import { ErrorBoundary, GlobalErrorBoundary } from "../shims/error-boundary.js";
 import { LayoutSegmentProvider } from "../shims/layout-segment-context.js";
 import { MetadataHead, ViewportHead } from "../shims/metadata.js";
+import { resolveAppPageSpecialError } from "./app-page-execution.js";
 import { resolveAppPageHead } from "./app-page-head.js";
 import { createAppPageLayoutEntries } from "./app-page-route-wiring.js";
 import { buildClientHookErrorMessage } from "../shims/client-hook-error.js";
+import DefaultGlobalError from "../shims/default-global-error.js";
 import { renderAppPageBoundaryResponse, resolveAppPageErrorBoundary, resolveAppPageHttpAccessBoundaryModule, wrapAppPageBoundaryElement } from "./app-page-boundary.js";
 import { createAppPageFontData, renderAppPageHtmlResponse } from "./app-page-stream.js";
 import { Fragment, createElement } from "react";
 //#region src/server/app-page-boundary-render.ts
+const DEFAULT_GLOBAL_ERROR_COMPONENT = DefaultGlobalError;
 function getDefaultExport(module) {
 	return module?.default ?? null;
 }
@@ -25,9 +29,12 @@ function wrapRenderedBoundaryElement(options) {
 		makeThenableParams: options.makeThenableParams,
 		matchedParams: options.matchedParams,
 		renderErrorBoundary(GlobalErrorComponent, children) {
-			return createElement(ErrorBoundary, {
-				fallback: GlobalErrorComponent,
-				children
+			return createElement(GlobalErrorBoundary, {
+				fallback: DEFAULT_GLOBAL_ERROR_COMPONENT,
+				children: createElement(ErrorBoundary, {
+					fallback: GlobalErrorComponent,
+					children
+				})
 			});
 		},
 		renderLayout(LayoutComponent, children, asyncParams) {
@@ -233,22 +240,28 @@ async function renderAppPageErrorBoundary(options) {
 	} catch (error) {
 		console.error(`[vinext] App page error boundary head resolution failed for ${options.route?.pattern ?? pathname}:`, error);
 	}
-	const element = wrapRenderedBoundaryElement({
-		element: createElement(Fragment, null, ...headElements, createElement(errorBoundary.component, { error: errorObject })),
-		globalErrorModule: options.globalErrorModule,
-		includeGlobalErrorBoundary: !errorBoundary.isGlobalError,
-		isRscRequest: options.isRscRequest,
-		layoutModules,
-		layoutTreePositions: options.route?.layoutTreePositions,
-		makeThenableParams: options.makeThenableParams,
-		matchedParams,
-		resolveChildSegments: options.resolveChildSegments,
-		routeSegments: options.route?.routeSegments,
-		skipLayoutWrapping: errorBoundary.isGlobalError
-	});
-	return renderAppPageBoundaryElementResponse({
+	const buildElement = (BoundaryComponent) => {
+		const boundaryElement = createElement(BoundaryComponent, { error: errorObject });
+		return wrapRenderedBoundaryElement({
+			element: createElement(Fragment, null, ...headElements, errorBoundary.isGlobalError ? createElement(GlobalErrorBoundary, {
+				fallback: DEFAULT_GLOBAL_ERROR_COMPONENT,
+				children: boundaryElement
+			}) : boundaryElement),
+			globalErrorModule: options.globalErrorModule,
+			includeGlobalErrorBoundary: !errorBoundary.isGlobalError,
+			isRscRequest: options.isRscRequest,
+			layoutModules,
+			layoutTreePositions: options.route?.layoutTreePositions,
+			makeThenableParams: options.makeThenableParams,
+			matchedParams,
+			resolveChildSegments: options.resolveChildSegments,
+			routeSegments: options.route?.routeSegments,
+			skipLayoutWrapping: errorBoundary.isGlobalError
+		});
+	};
+	const renderWith = (BoundaryComponent) => renderAppPageBoundaryElementResponse({
 		...options,
-		element,
+		element: buildElement(BoundaryComponent),
 		initialDevServerError: rawError,
 		layoutModules,
 		navigationParams: matchedParams,
@@ -256,6 +269,15 @@ async function renderAppPageErrorBoundary(options) {
 		routePattern: options.route?.pattern,
 		status: 200
 	});
+	try {
+		return await renderWith(errorBoundary.component);
+	} catch (renderError) {
+		if (errorBoundary.isGlobalError && !isNavigationSignalError(renderError) && !resolveAppPageSpecialError(renderError)) {
+			console.error(`[vinext] global-error.tsx threw while rendering for ${options.route?.pattern ?? pathname}; falling back to the built-in default global-error:`, renderError);
+			return renderWith(DEFAULT_GLOBAL_ERROR_COMPONENT);
+		}
+		throw renderError;
+	}
 }
 const _clientHookPattern = /\b(useState|useEffect|useReducer|useRef|useContext|useLayoutEffect|useInsertionEffect|useSyncExternalStore|useTransition|useImperativeHandle|useDeferredValue|useActionState|useOptimistic|useEffectEvent)\b.*is not a function/;
 function rewriteClientHookError(error) {

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

@@ -78,6 +78,12 @@ type DispatchAppPageOptions<TRoute extends AppPageDispatchRoute> = {
    * SSR head. Undefined or empty disables emission entirely.
    */
   clientTraceMetadata?: readonly string[];
+  /**
+   * Maximum total length (in characters) of the preload `Link` header emitted
+   * during SSR. `0` disables emission. From `reactMaxHeadersLength` in
+   * `next.config`. Undefined falls back to the React default downstream.
+   */
+  reactMaxHeadersLength?: number;
   buildPageElement: (route: TRoute, params: AppPageParams, opts: AppPageDispatchInterceptOptions | undefined, searchParams: URLSearchParams, layoutParamAccess?: AppLayoutParamAccessTracker) => Promise<AppPageElement>;
   clientReuseManifest?: ClientReuseManifestParseResult;
   cleanPathname: string;

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

@@ -217,7 +217,7 @@ async function dispatchAppPageInner(options) {
 			expireSeconds: options.expireSeconds,
 			revalidateSeconds: currentRevalidateSeconds ?? 0,
 			renderFreshPageForCache: async () => {
-				const revalidationTarget = resolveAppPageInterceptionRerenderTarget({
+				const revalidationTarget = await resolveAppPageInterceptionRerenderTarget({
 					cleanPathname: options.cleanPathname,
 					currentParams: options.params,
 					currentRoute: route,
@@ -256,6 +256,7 @@ async function dispatchAppPageInner(options) {
 					}, {
 						basePath: options.basePath,
 						clientTraceMetadata: options.clientTraceMetadata,
+						reactMaxHeadersLength: options.reactMaxHeadersLength,
 						rootParams: options.rootParams,
 						waitForAllReady: true,
 						...revalidatedRscCapture.sideStream ? {
@@ -390,6 +391,7 @@ async function dispatchAppPageInner(options) {
 	return renderAppPageLifecycle({
 		basePath: options.basePath,
 		clientTraceMetadata: options.clientTraceMetadata,
+		reactMaxHeadersLength: options.reactMaxHeadersLength,
 		cleanPathname: options.cleanPathname,
 		clearRequestContext: options.clearRequestContext,
 		consumeDynamicUsage,

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

@@ -37,6 +37,7 @@ type BuildPageElementsOptions<TModule extends AppPageModule = AppPageModule, TEr
   route: AppPageBuildRoute<TModule, TErrorModule>;
   params: AppPageParams;
   routePath: string;
+  displayPathname?: string;
   pageRequest: AppPagePageRequest<TModule>; /** Root-level global-error.tsx module. Present when the app defines this file. */
   globalErrorModule?: TErrorModule | null; /** Root-level not-found.tsx module. Present when the app defines this file. */
   rootNotFoundModule?: TModule | null; /** Root-level forbidden.tsx module. Present when the app defines this file. */

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

@@ -9,6 +9,7 @@ import { makeObservedAppPageSearchParamsThenable } from "./app-page-search-param
 import { buildAppPageElements, 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 { createElement } from "react";
 //#region src/server/app-page-element-builder.ts
 /**
@@ -28,18 +29,21 @@ import { createElement } from "react";
 * {@link https://github.com/vercel/next.js/blob/canary/packages/next/src/server/app-render/create-metadata.tsx|create-metadata.tsx}.
 */
 async function buildPageElements(options) {
-	const { route, params, routePath, pageRequest, globalErrorModule, rootNotFoundModule, rootForbiddenModule, rootUnauthorizedModule, metadataRoutes } = 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 pageModule = route.page;
-	const PageComponent = pageModule?.default;
+	const isSiblingIntercept = opts?.interceptSlotKey === "__vinext_page_intercept" && !!opts?.interceptPage;
+	const effectivePageModule = isSiblingIntercept ? opts.interceptPage : pageModule;
+	const EffectivePageComponent = effectivePageModule?.default;
+	const effectiveParams = isSiblingIntercept ? opts.interceptParams ?? params : params;
 	const hasPageModule = !!pageModule;
 	const renderIdentity = createAppPageRenderIdentity({
-		displayPathname: routePath,
+		displayPathname,
 		interceptionContext: opts?.interceptionContext ?? null,
 		interceptSourceMatchedUrl: opts?.interceptSourceMatchedUrl ?? null,
-		interceptSlotId: opts?.interceptSlotId ?? null
+		interceptSlotId: isSiblingIntercept ? null : opts?.interceptSlotId ?? null
 	});
-	if (hasPageModule && !PageComponent) {
+	if ((hasPageModule || isSiblingIntercept) && !EffectivePageComponent) {
 		let noExportRootLayout = null;
 		const noExportLayoutIds = route.ids?.layouts ?? route.layouts.map((_, index) => AppElementsWire.encodeLayoutId(createAppPageTreePath(route.routeSegments, route.layoutTreePositions?.[index] ?? 0)));
 		if (route.layouts?.length > 0) {
@@ -62,7 +66,7 @@ async function buildPageElements(options) {
 		layoutModules: route.layouts,
 		layoutTreePositions: route.layoutTreePositions,
 		metadataRoutes,
-		pageModule: route.page ?? null,
+		pageModule: effectivePageModule ?? null,
 		parallelRoutes: resolveActiveParallelRouteHeadInputs({
 			interceptLayouts: opts?.interceptLayouts ?? null,
 			interceptPage: opts?.interceptPage ?? null,
@@ -72,12 +76,12 @@ async function buildPageElements(options) {
 			routeSegments: route.routeSegments ?? [],
 			slots: route.slots ?? null
 		}),
-		params,
+		params: effectiveParams,
 		routePath: route.pattern,
 		routeSegments: route.routeSegments ?? null,
 		searchParams
 	});
-	const pageProps = { params: makeThenableParams(params) };
+	const pageProps = { params: makeThenableParams(effectiveParams) };
 	let pageSearchParamsThenable;
 	if (searchParams) {
 		pageSearchParamsThenable = !shouldSuppressLoadingBoundaries(renderMode) && Boolean(route.loading?.default) ? makeObservedAppPageSearchParamsThenable(pageSearchParams) : makeThenableParams(pageSearchParams);
@@ -86,8 +90,16 @@ async function buildPageElements(options) {
 	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);
+		}
+	}
 	return buildAppPageElements({
-		element: PageComponent ? createElement(PageComponent, pageProps) : null,
+		element: isSiblingIntercept ? siblingInterceptElement : EffectivePageComponent ? createElement(EffectivePageComponent, pageProps) : null,
 		globalErrorModule: globalErrorModule ?? DEFAULT_GLOBAL_ERROR_MODULE,
 		isRscRequest,
 		layoutParamAccess: options.layoutParamAccess,
@@ -125,7 +137,7 @@ async function buildPageElements(options) {
 */
 function buildSlotOverrides(route, routeParams, routePath, opts) {
 	const overrides = {};
-	if (opts && opts.interceptSlotKey && opts.interceptPage) overrides[opts.interceptSlotKey] = {
+	if (opts && opts.interceptSlotKey && opts.interceptPage && opts.interceptSlotKey !== "__vinext_page_intercept") overrides[opts.interceptSlotKey] = {
 		layoutModules: opts.interceptLayouts || null,
 		pageModule: opts.interceptPage,
 		params: opts.interceptParams || routeParams

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

@@ -28,6 +28,12 @@ type RenderAppPageLifecycleOptions = {
    * Undefined or empty disables emission.
    */
   clientTraceMetadata?: readonly string[];
+  /**
+   * Maximum total length (in characters) of the preload `Link` header emitted
+   * during SSR. `0` disables emission. From `reactMaxHeadersLength` in
+   * `next.config`.
+   */
+  reactMaxHeadersLength?: number;
   cleanPathname: string;
   clearRequestContext: () => void;
   consumeDynamicUsage: () => boolean;

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

@@ -10,7 +10,7 @@ import { DEFAULT_CACHE_VARIANT_BUDGET, buildCacheVariantWithRouteBudget, buildRe
 import { createAppPageHtmlOutputScope, createAppPageRenderObservation, createAppPageRscOutputScope, createEmptyAppPageRenderObservationState } from "./app-page-render-observation.js";
 import { finalizeAppPageHtmlCacheResponse, finalizeAppPageRscCacheResponse } from "./app-page-cache.js";
 import { createStaticLayoutClientReuseArtifactCompatibility, createStaticLayoutClientReusePayloadHash, createStaticLayoutClientReuseRouteId } from "./static-layout-client-reuse-proof.js";
-import { createAppPageFontData, createAppPageRscErrorTracker, deferUntilStreamConsumed, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery, shouldRerenderAppPageWithGlobalError } from "./app-page-stream.js";
+import { buildAppPageLinkHeader, createAppPageFontData, createAppPageRscErrorTracker, deferUntilStreamConsumed, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery, shouldRerenderAppPageWithGlobalError } from "./app-page-stream.js";
 import { getStaticLayoutObservationSkipRejection } from "./app-layout-param-observation.js";
 import { hasDigest } from "./app-rsc-errors.js";
 import { createClientReuseSkipTransportPlan, crossCheckClientReuseManifestEntryWithCache } from "./skip-cache-proof.js";
@@ -418,6 +418,7 @@ async function renderAppPageLifecycle(options) {
 				navigationContext: options.getNavigationContext(),
 				basePath: options.basePath,
 				clientTraceMetadata: options.clientTraceMetadata,
+				reactMaxHeadersLength: options.reactMaxHeadersLength,
 				rootParams: options.rootParams,
 				formState: options.formState ?? null,
 				rscStream: rscForResponse,
@@ -435,6 +436,7 @@ async function renderAppPageLifecycle(options) {
 	if (htmlRender.response) return htmlRender.response;
 	let htmlStream = htmlRender.htmlStream;
 	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) {
 		const captured = rscErrorTracker.getCapturedSpecialError();
@@ -491,7 +493,7 @@ async function renderAppPageLifecycle(options) {
 	if (htmlResponsePolicy.shouldWriteToCache || shouldSpeculativelyWriteCache) {
 		const isrResponse = buildAppPageHtmlResponse(safeHtmlStream, {
 			draftCookie,
-			fontLinkHeader,
+			linkHeader,
 			isEdgeRuntime: options.isEdgeRuntime,
 			middlewareContext: options.middlewareContext,
 			policy: htmlResponsePolicy,
@@ -551,7 +553,7 @@ async function renderAppPageLifecycle(options) {
 	}
 	return buildAppPageHtmlResponse(safeHtmlStream, {
 		draftCookie,
-		fontLinkHeader,
+		linkHeader,
 		isEdgeRuntime: options.isEdgeRuntime,
 		middlewareContext: options.middlewareContext,
 		policy: htmlResponsePolicy,

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

@@ -6,6 +6,7 @@ type AppPageParams = Record<string, string | string[]>;
 type GenerateStaticParams = (args: {
   params: AppPageParams;
 }) => unknown;
+type Awaitable<T> = T | Promise<T>;
 type GenerateStaticParamsModule = {
   generateStaticParams?: GenerateStaticParams | null;
 };
@@ -39,6 +40,7 @@ type BuildAppPageElementResult<TElement> = {
 type AppPageInterceptMatch<TPage = unknown> = {
   matchedParams: AppPageParams;
   page: TPage;
+  __pageLoader?: (() => Promise<TPage>) | null;
   slotId?: string | null;
   slotKey: string;
   sourceRouteIndex: number;
@@ -48,7 +50,7 @@ type ResolveAppPageInterceptMatchOptions<TRoute, TPage, TInterceptOpts> = {
   currentRoute: TRoute;
   findIntercept: (pathname: string) => AppPageInterceptMatch<TPage> | null;
   getRouteParamNames: (route: TRoute) => readonly string[];
-  getSourceRoute: (sourceRouteIndex: number) => TRoute | undefined;
+  getSourceRoute: (sourceRouteIndex: number) => Awaitable<TRoute | undefined>;
   isRscRequest: boolean;
   toInterceptOpts: (intercept: AppPageInterceptMatch<TPage>) => TInterceptOpts;
 };
@@ -64,7 +66,7 @@ type ResolveAppPageInterceptionRerenderTargetOptions<TRoute, TPage, TInterceptOp
   currentRoute: TRoute;
   findIntercept: (pathname: string) => AppPageInterceptMatch<TPage> | null;
   getRouteParamNames: (route: TRoute) => readonly string[];
-  getSourceRoute: (sourceRouteIndex: number) => TRoute | undefined;
+  getSourceRoute: (sourceRouteIndex: number) => Awaitable<TRoute | undefined>;
   isRscRequest: boolean;
   toInterceptOpts: (intercept: AppPageInterceptMatch<TPage>) => TInterceptOpts;
 };
@@ -82,7 +84,7 @@ type ResolveAppPageInterceptOptions<TRoute, TPage, TInterceptOpts, TElement> = {
   currentRoute: TRoute;
   findIntercept: (pathname: string) => AppPageInterceptMatch<TPage> | null;
   getRouteParamNames: (route: TRoute) => readonly string[];
-  getSourceRoute: (sourceRouteIndex: number) => TRoute | undefined;
+  getSourceRoute: (sourceRouteIndex: number) => Awaitable<TRoute | undefined>;
   isRscRequest: boolean;
   layoutParamAccess?: AppLayoutParamAccessTracker;
   renderInterceptResponse: (route: TRoute, element: TElement) => Promise<Response> | Response;
@@ -116,9 +118,9 @@ declare function validateAppPageDynamicParams(options: ValidateAppPageDynamicPar
  * `setNavigationContext` + element build + Response wrap) and the server-action
  * POST path (entries/app-rsc-entry.ts), which runs its own response pipeline.
  */
-declare function resolveAppPageInterceptMatch<TRoute, TPage, TInterceptOpts>(options: ResolveAppPageInterceptMatchOptions<TRoute, TPage, TInterceptOpts>): ResolveAppPageInterceptMatchResult<TRoute, TInterceptOpts> | null;
-declare function resolveAppPageInterceptionRerenderTarget<TRoute, TPage, TInterceptOpts>(options: ResolveAppPageInterceptionRerenderTargetOptions<TRoute, TPage, TInterceptOpts>): ResolveAppPageInterceptionRerenderTargetResult<TRoute, TInterceptOpts>;
-declare function resolveAppPageActionRerenderTarget<TRoute, TPage, TInterceptOpts>(options: ResolveAppPageActionRerenderTargetOptions<TRoute, TPage, TInterceptOpts>): ResolveAppPageActionRerenderTargetResult<TRoute, TInterceptOpts>;
+declare function resolveAppPageInterceptMatch<TRoute, TPage, TInterceptOpts>(options: ResolveAppPageInterceptMatchOptions<TRoute, TPage, TInterceptOpts>): Promise<ResolveAppPageInterceptMatchResult<TRoute, TInterceptOpts> | null>;
+declare function resolveAppPageInterceptionRerenderTarget<TRoute, TPage, TInterceptOpts>(options: ResolveAppPageInterceptionRerenderTargetOptions<TRoute, TPage, TInterceptOpts>): Promise<ResolveAppPageInterceptionRerenderTargetResult<TRoute, TInterceptOpts>>;
+declare function resolveAppPageActionRerenderTarget<TRoute, TPage, TInterceptOpts>(options: ResolveAppPageActionRerenderTargetOptions<TRoute, TPage, TInterceptOpts>): Promise<ResolveAppPageActionRerenderTargetResult<TRoute, TInterceptOpts>>;
 declare function resolveAppPageIntercept<TRoute, TPage, TInterceptOpts, TElement>(options: ResolveAppPageInterceptOptions<TRoute, TPage, TInterceptOpts, TElement>): Promise<ResolveAppPageInterceptResult<TInterceptOpts>>;
 declare function buildAppPageElement<TElement>(options: BuildAppPageElementOptions<TElement>): Promise<BuildAppPageElementResult<TElement>>;
 //#endregion