vinext 1.0.0-beta.2 → 1.0.0-beta.3

package/dist/plugins/transform-cache.js

@@ -0,0 +1,36 @@
+//#region src/plugins/transform-cache.ts
+/**
+* Memoizes a pure per-module transform across the repeated build passes
+* (scan client/server references + rsc/client/ssr builds), which feed the
+* same module source through the same transform up to five times.
+*
+* Entries are keyed by module id and replaced when the source changes, so dev
+* rebuilds retain at most one source version per id. `variant` distinguishes
+* results that also depend on an environment-derived input (e.g. the
+* typeof-window replacement); callers must pass a primitive or stable
+* reference. Cached values include `null` ("no transform applies") so the
+* negative case is not recomputed either.
+*
+* Only safe for transforms whose result depends solely on (id, source,
+* variant) — no filesystem or plugin-state reads inside `compute`.
+*/
+function createTransformCache() {
+	const cache = /* @__PURE__ */ new Map();
+	return (id, source, variant, compute) => {
+		let entry = cache.get(id);
+		if (entry?.source !== source) {
+			entry = {
+				source,
+				results: /* @__PURE__ */ new Map()
+			};
+			cache.set(id, entry);
+		}
+		const boxed = entry.results.get(variant);
+		if (boxed) return boxed.value;
+		const value = compute();
+		entry.results.set(variant, { value });
+		return value;
+	};
+}
+//#endregion
+export { createTransformCache };

package/dist/routing/app-route-graph.d.ts

@@ -24,7 +24,9 @@ type InterceptingRoute = {
   pagePath: string; /** Filesystem segments from app/ root to the intercepting page directory. */
   sourcePageSegments?: string[]; /** Absolute layout paths inside the intercepting route tree, outermost to innermost */
   layoutPaths: string[]; /** Normalized branch segments accumulated at each intercept layout. */
-  layoutSegments?: string[][]; /** Full normalized interception branch segments through the page. */
+  layoutSegments?: string[][]; /** Loading conventions inside the intercepted branch, outermost to innermost. */
+  loadingPaths?: string[]; /** Tree positions for loadingPaths in the normalized interception branch. */
+  loadingTreePositions?: number[]; /** Full normalized interception branch segments through the page. */
   branchSegments?: string[]; /** Nearest not-found convention inside the interception branch. */
   notFoundPath?: string | null; /** Slot-root-relative branch segments used to scope not-found params. */
   notFoundBranchSegments?: string[]; /** Tree position relative to the normalized interception branch. */
@@ -41,14 +43,17 @@ type ParallelSlot = {
   key: string; /** Slot name (e.g. "team" from @team) */
   name: string; /** Absolute path to the @slot directory that owns this slot. Internal routing metadata. */
   ownerDir: string; /** Stable tree path for the directory whose layout owns this slot. */
-  ownerTreePath: string; /** Whether the slot owner directory declares its own page component. */
+  ownerTreePath: string; /** Directory depth of the slot owner from app/ root. */
+  ownerTreePosition?: number; /** Whether the slot owner directory declares its own page component. */
   hasPage: boolean; /** Absolute path to the slot's page component */
   pagePath: string | null; /** Absolute path to the slot's default.tsx fallback */
   defaultPath: string | null; /** Absolute path to the slot's layout component (wraps slot content) */
   layoutPath: string | null; /** Nested active-branch layouts whose exports contribute route config. */
   configLayoutPaths?: string[]; /** Tree positions of configLayoutPaths relative to the slot root. */
   configLayoutTreePositions?: number[]; /** Absolute path to the slot's loading component */
-  loadingPath: string | null; /** Absolute path to the slot's error component */
+  loadingPath: string | null; /** Per-segment loading components from the slot root to its active page. */
+  loadingPaths?: string[]; /** Slot-root-relative tree positions aligned with loadingPaths. */
+  loadingTreePositions?: number[]; /** Absolute path to the slot's error component */
   errorPath: string | null; /** Nearest not-found convention for the slot's active branch. */
   notFoundPath?: string | null; /** Tree position of that convention relative to the slot root. */
   notFoundTreePosition?: number | null; /** Intercepting routes within this slot */
@@ -99,8 +104,10 @@ type AppRoute = {
    * On soft-nav, the intercepting page replaces the entire page response.
    * Empty array when there are no sibling-style interception markers.
    */
-  siblingIntercepts: InterceptingRoute[]; /** Loading component path */
-  loadingPath: string | null; /** Error component path (leaf directory only) */
+  siblingIntercepts: InterceptingRoute[]; /** Loading component path (leaf directory only) */
+  loadingPath: string | null; /** Per-segment loading component paths, aligned with loadingTreePositions. */
+  loadingPaths?: string[]; /** Tree position (directory depth from app/ root) for each loading boundary. */
+  loadingTreePositions?: number[]; /** Error component path (leaf directory only) */
   errorPath: string | null;
   /**
    * Per-layout error boundary paths, aligned with the layouts array.
@@ -306,6 +313,7 @@ declare function buildAppRouteGraph(appDir: string, matcher: ValidFileMatcher):
   routeManifest: RouteManifest;
 }>;
 declare function computeRootParamNames(routeSegments: readonly string[], layoutTreePositions: readonly number[]): string[];
+declare function patternsStructurallyEquivalent(a: readonly string[], b: readonly string[]): boolean;
 /**
  * Find the best route to attach a sibling intercept to, given the directory
  * that contains the interception marker.
@@ -359,4 +367,4 @@ declare function computeAppRouteStaticSiblings(allRoutes: readonly {
   patternParts?: readonly string[] | null;
 }): string[];
 //#endregion
-export { AppRoute, AppRouteGraphRoute, AppRouteSemanticIds, GraphVersion, RootBoundaryId, RouteManifest, RouteManifestInterception, RouteManifestRootBoundary, RouteManifestRoute, RouteManifestSlotBinding, StaticSegmentGraph, buildAppRouteGraph, computeAppRouteStaticSiblings, computeRootParamNames, convertSegmentsToRouteParts, findOwnerRouteForDir, isInvisibleSegment };
+export { AppRoute, AppRouteGraphRoute, AppRouteSemanticIds, GraphVersion, RootBoundaryId, RouteManifest, RouteManifestInterception, RouteManifestRootBoundary, RouteManifestRoute, RouteManifestSlotBinding, StaticSegmentGraph, buildAppRouteGraph, computeAppRouteStaticSiblings, computeRootParamNames, convertSegmentsToRouteParts, findOwnerRouteForDir, isInvisibleSegment, patternsStructurallyEquivalent };

package/dist/routing/app-route-graph.js

@@ -460,7 +460,7 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 			if (subPage !== void 0) {
 				const configLayoutPaths = findSlotConfigLayoutPaths(slot.ownerDir, subPage, matcher);
 				const notFoundBoundary = findSlotNotFoundBoundary(slot.ownerDir, subPage, matcher);
-				return {
+				return withSlotLoadingEntries({
 					...slot,
 					pagePath: subPage,
 					configLayoutPaths,
@@ -468,7 +468,7 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 					notFoundPath: notFoundBoundary.path,
 					notFoundTreePosition: notFoundBoundary.treePosition,
 					routeSegments: rawSegments
-				};
+				}, subPage, matcher);
 			}
 			return slot;
 		});
@@ -549,7 +549,7 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 				const subPage = slotPages.get(slot.key);
 				const configLayoutPaths = findSlotConfigLayoutPaths(slot.ownerDir, subPage ?? null, matcher);
 				const notFoundBoundary = findSlotNotFoundBoundary(slot.ownerDir, subPage ?? null, matcher);
-				return {
+				return withSlotLoadingEntries({
 					...slot,
 					pagePath: subPage || null,
 					configLayoutPaths,
@@ -557,7 +557,7 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 					notFoundPath: notFoundBoundary.path,
 					notFoundTreePosition: notFoundBoundary.treePosition,
 					routeSegments: subPage ? rawSegments : null
-				};
+				}, subPage ?? null, matcher);
 			});
 			const newRoute = {
 				ids: createAppRouteSemanticIds({
@@ -580,7 +580,9 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 					ownerTreePath: childrenOwnerTreePath,
 					state: childrenDefault ? "default" : childrenCatchAll ? "active" : "unmatched"
 				},
-				loadingPath: parentRoute.loadingPath,
+				loadingPath: null,
+				loadingPaths: parentRoute.loadingPaths,
+				loadingTreePositions: parentRoute.loadingTreePositions,
 				errorPath: parentRoute.errorPath,
 				layoutErrorPaths: parentRoute.layoutErrorPaths,
 				notFoundPath: parentRoute.notFoundPath,
@@ -678,6 +680,36 @@ function findSlotConfigLayoutTreePositions(slotDir, layoutPaths) {
 		return relativeDir ? relativeDir.split(path.sep).filter(Boolean).length : 0;
 	});
 }
+function findSlotLoadingEntries(slotDir, pagePath, matcher) {
+	const pageDir = pagePath ? path.dirname(pagePath) : slotDir;
+	if (pageDir !== slotDir && !pageDir.startsWith(`${slotDir}${path.sep}`)) return [];
+	const relativeDir = path.relative(slotDir, pageDir);
+	const segments = relativeDir ? relativeDir.split(path.sep).filter(Boolean) : [];
+	const loadings = [];
+	let currentDir = slotDir;
+	const rootLoading = findFile(currentDir, "loading", matcher);
+	if (rootLoading) loadings.push({
+		path: rootLoading,
+		treePosition: 0
+	});
+	for (let index = 0; index < segments.length; index++) {
+		currentDir = path.join(currentDir, segments[index]);
+		const loading = findFile(currentDir, "loading", matcher);
+		if (loading) loadings.push({
+			path: loading,
+			treePosition: index + 1
+		});
+	}
+	return loadings;
+}
+function withSlotLoadingEntries(slot, pagePath, matcher) {
+	const loadingEntries = findSlotLoadingEntries(slot.ownerDir, pagePath, matcher);
+	return {
+		...slot,
+		loadingPaths: loadingEntries.map((entry) => entry.path),
+		loadingTreePositions: loadingEntries.map((entry) => entry.treePosition)
+	};
+}
 function findSlotNotFoundBoundary(slotDir, pagePath, matcher) {
 	let dir = pagePath ? path.dirname(pagePath) : slotDir;
 	while (dir === slotDir || dir.startsWith(`${slotDir}${path.sep}`)) {
@@ -751,6 +783,9 @@ function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath, includeN
 	const templateTreePositions = computeLayoutTreePositions(appDir, templates);
 	const layoutTreePositions = computeLayoutTreePositions(appDir, layouts);
 	const layoutErrorPaths = discoverLayoutAlignedErrors(segments, appDir, matcher);
+	const loadingEntries = discoverSegmentLoadings(segments, appDir, matcher);
+	const loadingPaths = loadingEntries.map((entry) => entry.path);
+	const loadingTreePositions = loadingEntries.map((entry) => entry.treePosition);
 	const errorEntries = discoverSegmentErrors(segments, appDir, matcher);
 	const errorPaths = errorEntries.map((entry) => entry.path);
 	const errorTreePositions = errorEntries.map((entry) => entry.treePosition);
@@ -785,6 +820,8 @@ function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath, includeN
 		templates,
 		parallelSlots,
 		loadingPath,
+		loadingPaths,
+		loadingTreePositions,
 		errorPath,
 		layoutErrorPaths,
 		errorPaths,
@@ -933,6 +970,31 @@ function discoverSegmentErrors(segments, appDir, matcher) {
 	return errors;
 }
 /**
+* Discover loading.tsx files by segment tree position.
+*
+* Loading conventions belong to loader-tree segments rather than layouts. A
+* segment without layout.tsx can therefore provide the boundary that suspends
+* while its child layout renders.
+*/
+function discoverSegmentLoadings(segments, appDir, matcher) {
+	const loadings = [];
+	const rootLoading = findFile(appDir, "loading", matcher);
+	if (rootLoading) loadings.push({
+		path: rootLoading,
+		treePosition: 0
+	});
+	let currentDir = appDir;
+	for (let index = 0; index < segments.length; index++) {
+		currentDir = path.join(currentDir, segments[index]);
+		const loading = findFile(currentDir, "loading", matcher);
+		if (loading) loadings.push({
+			path: loading,
+			treePosition: index + 1
+		});
+	}
+	return loadings;
+}
+/**
 * Discover error.tsx files aligned with the layouts array.
 *
 * Route manifests still model layout-owned boundary facts by layout index.
@@ -1037,7 +1099,7 @@ function discoverInheritedParallelSlots(segments, appDir, routeDir, matcher, inc
 				slotParamNames = [...ownerUrl?.params ?? [], ...mirror.slotParamNames];
 			}
 			const configLayoutPaths = findSlotConfigLayoutPaths(slot.ownerDir, mirror?.pagePath ?? null, matcher);
-			const inheritedSlot = {
+			const inheritedSlot = withSlotLoadingEntries({
 				...slot,
 				pagePath: mirror?.pagePath ?? null,
 				configLayoutPaths,
@@ -1046,7 +1108,7 @@ function discoverInheritedParallelSlots(segments, appDir, routeDir, matcher, inc
 				routeSegments: mirror?.segments ?? null,
 				slotPatternParts,
 				slotParamNames
-			};
+			}, mirror?.pagePath ?? null, matcher);
 			slotMap.set(slot.key, inheritedSlot);
 		}
 	}
@@ -1209,6 +1271,7 @@ function discoverParallelSlots(dir, appDir, matcher, includeNestedOnlySlots = fa
 		const ownerSegments = path.relative(appDir, dir).split(path.sep).filter((segment) => segment.length > 0);
 		const ownerTreePath = createAppRouteGraphTreePath(ownerSegments, ownerSegments.length);
 		const configLayoutPaths = findSlotConfigLayoutPaths(slotDir, pagePath, matcher);
+		const loadingEntries = findSlotLoadingEntries(slotDir, pagePath, matcher);
 		const notFoundBoundary = findSlotNotFoundBoundary(slotDir, pagePath, matcher);
 		slots.push({
 			id: createAppRouteGraphSlotId(slotName, ownerTreePath),
@@ -1216,6 +1279,7 @@ function discoverParallelSlots(dir, appDir, matcher, includeNestedOnlySlots = fa
 			name: slotName,
 			ownerDir: slotDir,
 			ownerTreePath,
+			ownerTreePosition: ownerSegments.length,
 			hasPage: pagePath !== null,
 			pagePath,
 			defaultPath,
@@ -1223,6 +1287,8 @@ function discoverParallelSlots(dir, appDir, matcher, includeNestedOnlySlots = fa
 			configLayoutPaths,
 			configLayoutTreePositions: findSlotConfigLayoutTreePositions(slotDir, configLayoutPaths),
 			loadingPath: findFile(slotDir, "loading", matcher),
+			loadingPaths: loadingEntries.map((loading) => loading.path),
+			loadingTreePositions: loadingEntries.map((loading) => loading.treePosition),
 			errorPath: findFile(slotDir, "error", matcher),
 			notFoundPath: notFoundBoundary.path,
 			notFoundTreePosition: notFoundBoundary.treePosition,
@@ -1374,7 +1440,7 @@ function findOwnerRouteForDir(dir, appDir, routes, routesByDir) {
 * Recursively scan a directory tree for page.tsx files that are inside
 * intercepting route directories.
 */
-function scanForInterceptingPages(currentDir, slotRootDir, routeDir, appDir, results, matcher) {
+function scanForInterceptingPages(currentDir, slotRootDir, routeDir, appDir, results, matcher, parentLoadingEntries = []) {
 	if (!fs.existsSync(currentDir)) return;
 	const entries = fs.readdirSync(currentDir, { withFileTypes: true });
 	for (const entry of entries) {
@@ -1384,8 +1450,14 @@ function scanForInterceptingPages(currentDir, slotRootDir, routeDir, appDir, res
 		const interceptDir = path.join(currentDir, entry.name);
 		if (interceptMatch) {
 			const restOfName = entry.name.slice(interceptMatch.prefix.length);
-			collectInterceptingPages(interceptDir, interceptDir, interceptMatch.convention, restOfName, routeDir, appDir, currentDir, slotRootDir, results, matcher);
-		} else scanForInterceptingPages(interceptDir, slotRootDir, routeDir, appDir, results, matcher);
+			collectInterceptingPages(interceptDir, interceptDir, interceptMatch.convention, restOfName, routeDir, appDir, currentDir, slotRootDir, results, matcher, [], parentLoadingEntries, path.relative(slotRootDir, currentDir).split(path.sep).filter(Boolean).length);
+		} else {
+			const loading = findFile(interceptDir, "loading", matcher);
+			scanForInterceptingPages(interceptDir, slotRootDir, routeDir, appDir, results, matcher, loading ? [...parentLoadingEntries, {
+				path: loading,
+				treePosition: path.relative(slotRootDir, interceptDir).split(path.sep).filter(Boolean).length
+			}] : parentLoadingEntries);
+		}
 	}
 }
 /**
@@ -1399,25 +1471,43 @@ function matchInterceptConvention(name) {
 * Collect page.tsx files inside an intercepting route directory tree
 * and compute their target URL patterns.
 */
-function collectInterceptingPages(currentDir, interceptRoot, convention, interceptSegment, routeDir, appDir, interceptParentDir, slotRootDir, results, matcher, parentLayoutPaths = []) {
+function collectInterceptingPages(currentDir, interceptRoot, convention, interceptSegment, routeDir, appDir, interceptParentDir, slotRootDir, results, matcher, parentLayoutPaths = [], parentLoadingEntries = [], treePositionOffset = 0) {
 	const currentLayoutPath = findFile(currentDir, "layout", matcher);
 	const layoutPaths = currentLayoutPath ? [...parentLayoutPaths, currentLayoutPath] : parentLayoutPaths;
+	const currentLoadingPath = findFile(currentDir, "loading", matcher);
+	const relativeCurrentDir = path.relative(interceptRoot, currentDir);
+	const currentTreePosition = treePositionOffset + 1 + (relativeCurrentDir ? relativeCurrentDir.split(path.sep).filter(Boolean).length : 0);
+	const loadingEntries = currentLoadingPath ? [...parentLoadingEntries, {
+		path: currentLoadingPath,
+		treePosition: currentTreePosition
+	}] : parentLoadingEntries;
 	const page = findFile(currentDir, "page", matcher);
 	if (page) {
 		const targetPattern = computeInterceptTarget(convention, interceptSegment, currentDir, interceptRoot, routeDir, appDir);
 		if (targetPattern) {
 			const sourceMatchPattern = computeInterceptSourceMatchPattern(interceptParentDir, appDir);
 			const notFoundBoundary = findSlotNotFoundBoundary(slotRootDir ?? interceptRoot, page, matcher);
-			const branchSegments = [interceptSegment, ...path.relative(interceptRoot, path.dirname(page)).split(path.sep).filter(Boolean)];
 			const slotParentSegments = slotRootDir ? path.relative(slotRootDir, interceptParentDir).split(path.sep).filter(Boolean) : [];
+			const branchSegments = [
+				...slotParentSegments,
+				interceptSegment,
+				...path.relative(interceptRoot, path.dirname(page)).split(path.sep).filter(Boolean)
+			];
 			results.push({
 				branchSegments,
 				convention,
 				layoutPaths: [...layoutPaths],
 				layoutSegments: layoutPaths.map((layoutPath) => {
-					return [interceptSegment, ...path.relative(interceptRoot, path.dirname(layoutPath)).split(path.sep).filter(Boolean)];
+					const relativeDir = path.relative(interceptRoot, path.dirname(layoutPath));
+					return [
+						...slotParentSegments,
+						interceptSegment,
+						...relativeDir.split(path.sep).filter(Boolean)
+					];
 				}),
-				notFoundBranchSegments: [...slotParentSegments, ...branchSegments],
+				loadingPaths: loadingEntries.map((loading) => loading.path),
+				loadingTreePositions: loadingEntries.map((loading) => loading.treePosition),
+				notFoundBranchSegments: branchSegments,
 				notFoundPath: notFoundBoundary.path,
 				notFoundTreePosition: notFoundBoundary.treePosition === null ? null : slotRootDir ? notFoundBoundary.treePosition : notFoundBoundary.treePosition + 1,
 				targetPattern: targetPattern.pattern,
@@ -1433,7 +1523,7 @@ function collectInterceptingPages(currentDir, interceptRoot, convention, interce
 	for (const entry of entries) {
 		if (!entry.isDirectory()) continue;
 		if (entry.name.startsWith("_")) continue;
-		collectInterceptingPages(path.join(currentDir, entry.name), interceptRoot, convention, interceptSegment, routeDir, appDir, interceptParentDir, slotRootDir, results, matcher, layoutPaths);
+		collectInterceptingPages(path.join(currentDir, entry.name), interceptRoot, convention, interceptSegment, routeDir, appDir, interceptParentDir, slotRootDir, results, matcher, layoutPaths, loadingEntries, treePositionOffset);
 	}
 }
 /**
@@ -1661,4 +1751,4 @@ function computeAppRouteStaticSiblings(allRoutes, matchedRoute) {
 	return Array.from(siblings);
 }
 //#endregion
-export { buildAppRouteGraph, computeAppRouteStaticSiblings, computeRootParamNames, convertSegmentsToRouteParts, findOwnerRouteForDir, isInvisibleSegment };
+export { buildAppRouteGraph, computeAppRouteStaticSiblings, computeRootParamNames, convertSegmentsToRouteParts, findOwnerRouteForDir, isInvisibleSegment, patternsStructurallyEquivalent };

package/dist/server/api-handler.d.ts

@@ -11,6 +11,8 @@ import { IncomingMessage, ServerResponse } from "node:http";
 declare function handleApiRoute(runner: ModuleImporter, req: IncomingMessage, res: ServerResponse, url: string, apiRoutes: Route[], nextConfig?: {
   basePath?: string;
   i18n?: NextI18nConfig | null;
+  trustedRevalidateOrigin?: string;
+  allowedRevalidateHeaderKeys?: readonly string[];
   trailingSlash?: boolean;
 }): Promise<boolean>;
 //#endregion

package/dist/server/api-handler.js

@@ -160,7 +160,7 @@ async function writeEdgeApiResponseBody(res, body) {
 /**
 * Enhance a Node.js req/res pair with Next.js API route helpers.
 */
-function enhanceApiObjects(req, res, query, body) {
+function enhanceApiObjects(req, res, query, body, trustedRevalidateOrigin, allowedRevalidateHeaderKeys = [], dev = false) {
 	const apiReq = Object.assign(req, {
 		body,
 		query
@@ -202,7 +202,7 @@ function enhanceApiObjects(req, res, query, body) {
 			return this;
 		},
 		async revalidate(urlPath, opts) {
-			await performOnDemandRevalidate(req, urlPath, opts);
+			await performOnDemandRevalidate(req, urlPath, opts, trustedRevalidateOrigin, allowedRevalidateHeaderKeys, dev);
 		}
 	});
 	attachPagesPreviewApi(apiReq, apiRes);
@@ -248,7 +248,7 @@ async function handleApiRoute(runner, req, res, url, apiRoutes, nextConfig) {
 		}
 		const query = mergeRouteParamsIntoQuery(parseQueryString(url), params);
 		const bodyParserConfig = resolveBodyParserConfig(apiModule.config);
-		const { apiReq, apiRes } = enhanceApiObjects(req, res, query, bodyParserConfig.enabled ? await parseBody(req, bodyParserConfig.sizeLimit) : void 0);
+		const { apiReq, apiRes } = enhanceApiObjects(req, res, query, bodyParserConfig.enabled ? await parseBody(req, bodyParserConfig.sizeLimit) : void 0, nextConfig?.trustedRevalidateOrigin, nextConfig?.allowedRevalidateHeaderKeys, true);
 		await handler(apiReq, apiRes);
 		return true;
 	} catch (e) {

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

@@ -302,28 +302,29 @@ function createNavigationCommitEffect(options) {
 		commitClientNavigationState(navId);
 	};
 }
-async function renderNavigationPayload(payload, navigationSnapshot, targetHref, navId, historyUpdateMode, params, previousNextUrl, pendingRouterState, payloadOrigin, actionType = "navigate", operationLane = "navigation", traversalIntent = null, scrollIntent = null, restoredBfcacheIds = null, reuseCurrentBfcacheIds = true, visibleCommitMode = "transition", onCommittedState, navigationCommitKind) {
+async function renderNavigationPayload(options) {
 	syncServerActionHttpFallbackHead(null);
 	return browserNavigationController.renderNavigationPayload({
-		actionType,
+		actionType: options.actionType ?? "navigate",
 		createNavigationCommitEffect,
-		historyUpdateMode,
-		navigationSnapshot,
-		nextElements: payload,
-		operationLane,
-		payloadOrigin,
-		params,
-		pendingRouterState,
-		previousNextUrl,
-		scrollIntent,
-		restoredBfcacheIds,
-		reuseCurrentBfcacheIds,
-		targetHistoryIndex: traversalIntent === null ? void 0 : traversalIntent.targetHistoryIndex,
-		targetHref,
-		navId,
-		navigationCommitKind,
-		visibleCommitMode,
-		onCommittedState
+		historyUpdateMode: options.historyUpdateMode,
+		navigationCommitKind: options.navigationCommitKind,
+		navigationInitiationState: options.navigationInitiationState,
+		navigationSnapshot: options.navigationSnapshot,
+		navId: options.navId,
+		nextElements: options.payload,
+		onCommittedState: options.onCommittedState,
+		operationLane: options.operationLane ?? "navigation",
+		params: options.params,
+		payloadOrigin: options.payloadOrigin,
+		pendingRouterState: options.pendingRouterState,
+		previousNextUrl: options.previousNextUrl,
+		restoredBfcacheIds: options.restoredBfcacheIds ?? null,
+		reuseCurrentBfcacheIds: options.reuseCurrentBfcacheIds ?? true,
+		scrollIntent: options.scrollIntent ?? null,
+		targetHistoryIndex: options.traversalIntent?.targetHistoryIndex,
+		targetHref: options.targetHref,
+		visibleCommitMode: options.visibleCommitMode ?? "transition"
 	});
 }
 async function commitSameUrlNavigatePayload(nextElements, actionInitiation, returnValue, revalidation = "none") {
@@ -725,7 +726,21 @@ function registerServerActionCallback() {
 				const hashIdx = target.href.indexOf("#");
 				const actionScrollIntent = beginAppRouterScrollIntent((hashIdx !== -1 ? target.href.slice(hashIdx) : "") || null);
 				if (target.type === "push") saveScrollPosition();
-				renderNavigationPayload(Promise.resolve(elements), createClientNavigationRenderSnapshot(target.href, actionInitiation.routerState.navigationSnapshot.params), target.href, actionInitiation.navigationId, target.type === "push" ? "push" : "replace", {}, null, null, FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN, target.type === "push" ? "navigate" : "replace", resolveServerActionOperationLane(revalidation), null, actionScrollIntent).catch(() => {
+				renderNavigationPayload({
+					actionType: target.type === "push" ? "navigate" : "replace",
+					historyUpdateMode: target.type === "push" ? "push" : "replace",
+					navigationInitiationState: actionInitiation.routerState,
+					navigationSnapshot: createClientNavigationRenderSnapshot(target.href, actionInitiation.routerState.navigationSnapshot.params),
+					navId: actionInitiation.navigationId,
+					operationLane: resolveServerActionOperationLane(revalidation),
+					params: {},
+					payload: Promise.resolve(elements),
+					payloadOrigin: FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN,
+					pendingRouterState: null,
+					previousNextUrl: null,
+					scrollIntent: actionScrollIntent,
+					targetHref: target.href
+				}).catch(() => {
 					browserNavigationController.performHardNavigation(target.href);
 				});
 			},
@@ -870,6 +885,8 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 					if (!browserNavigationController.isCurrentNavigation(navId)) return;
 					if (shouldUsePendingRouterState) pendingRouterState = beginPendingBrowserRouterState();
 				}
+				const navigationInitiationState = getBrowserRouterState();
+				const mountedSlotsHeader = getMountedSlotIdsHeader(navigationInitiationState.elements);
 				while (true) {
 					const url = new URL(currentHref, window.location.origin);
 					const requestState = getRequestState(navigationKind, url.pathname, currentPrevNextUrl, activeTraversalIntent?.historyState);
@@ -877,12 +894,9 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 					const requestPreviousNextUrl = requestState.previousNextUrl;
 					if (navigationKind === "refresh") historyController.syncCurrentHistoryStatePreviousNextUrl(requestPreviousNextUrl, getBrowserRouterState().bfcacheIds);
 					setPendingPathname(url.pathname, navId);
-					const routerStateAtNavStart = getBrowserRouterState();
-					const elementsAtNavStart = routerStateAtNavStart.elements;
-					const mountedSlotsHeader = getMountedSlotIdsHeader(elementsAtNavStart);
 					const earlyIntentDecision = navigationKind === "navigate" ? navigationPlanner.classifyEarlyNavigationIntent({
 						basePath: __basePath,
-						currentHref: clientNavigationSnapshotHref(routerStateAtNavStart.navigationSnapshot),
+						currentHref: clientNavigationSnapshotHref(navigationInitiationState.navigationSnapshot),
 						mode: "push",
 						scroll: false,
 						targetHref: url.href
@@ -960,7 +974,26 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 						const cachedNavigationSnapshot = createClientNavigationRenderSnapshot(currentHref, cachedParams);
 						const cachedPayload = cachedRoute.elements ? Promise.resolve(cachedRoute.elements) : decodeAppElementsPromise(createFromFetch(Promise.resolve(restoreRscResponse(cachedRoute.response))));
 						if (!browserNavigationController.isCurrentNavigation(navId)) return;
-						if (await renderNavigationPayload(cachedPayload, cachedNavigationSnapshot, currentHref, navId, currentHistoryMode, cachedParams, requestPreviousNextUrl, detachedNavigationCommits ? null : pendingRouterState, cachedRoute.elements ? COMMITTED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN : VISITED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN, toActionType(navigationKind), toOperationLane(navigationKind), activeTraversalIntent, scrollIntent, restoredBfcacheIds, reuseCurrentBfcacheIds, visibleCommitMode) === "no-commit") {
+						if (await renderNavigationPayload({
+							actionType: toActionType(navigationKind),
+							historyUpdateMode: currentHistoryMode,
+							navigationCommitKind: detachedNavigationCommits ? "authoritative" : void 0,
+							navigationInitiationState,
+							navigationSnapshot: cachedNavigationSnapshot,
+							navId,
+							operationLane: toOperationLane(navigationKind),
+							params: cachedParams,
+							payload: cachedPayload,
+							payloadOrigin: cachedRoute.elements ? COMMITTED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN : VISITED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN,
+							pendingRouterState: detachedNavigationCommits ? null : pendingRouterState,
+							previousNextUrl: requestPreviousNextUrl,
+							restoredBfcacheIds,
+							reuseCurrentBfcacheIds,
+							scrollIntent,
+							targetHref: currentHref,
+							traversalIntent: activeTraversalIntent,
+							visibleCommitMode
+						}) === "no-commit") {
 							if (!browserNavigationController.isCurrentNavigation(navId)) return;
 							deleteVisitedResponse(rscUrl, requestInterceptionContext);
 							continue;
@@ -1016,7 +1049,26 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 							if (optimisticPayload !== null) {
 								detachedNavigationCommits = true;
 								const optimisticNavigationSnapshot = createClientNavigationRenderSnapshot(currentHref, optimisticPayload.params);
-								renderNavigationPayload(Promise.resolve(optimisticPayload.elements), optimisticNavigationSnapshot, currentHref, navId, currentHistoryMode, optimisticPayload.params, requestPreviousNextUrl, null, FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN, toActionType(navigationKind), toOperationLane(navigationKind), activeTraversalIntent, scrollIntent, restoredBfcacheIds, reuseCurrentBfcacheIds, visibleCommitMode, void 0, "detached").catch((error) => {
+								renderNavigationPayload({
+									actionType: toActionType(navigationKind),
+									historyUpdateMode: currentHistoryMode,
+									navigationCommitKind: "detached",
+									navigationInitiationState,
+									navigationSnapshot: optimisticNavigationSnapshot,
+									navId,
+									operationLane: toOperationLane(navigationKind),
+									params: optimisticPayload.params,
+									payload: Promise.resolve(optimisticPayload.elements),
+									payloadOrigin: FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN,
+									pendingRouterState: null,
+									previousNextUrl: requestPreviousNextUrl,
+									restoredBfcacheIds,
+									reuseCurrentBfcacheIds,
+									scrollIntent,
+									targetHref: currentHref,
+									traversalIntent: activeTraversalIntent,
+									visibleCommitMode
+								}).catch((error) => {
 									if (browserNavigationController.isCurrentNavigation(navId)) console.error("[vinext] Optimistic RSC navigation error:", error);
 								});
 							}
@@ -1024,7 +1076,7 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 					}
 					if (!navResponse) {
 						if (navigationKind === "navigate") {
-							const clientReuseManifestHeader = createClientReuseManifestHeaderFromVisibleAppState(routerStateAtNavStart);
+							const clientReuseManifestHeader = createClientReuseManifestHeaderFromVisibleAppState(navigationInitiationState);
 							if (clientReuseManifestHeader !== null) requestHeaders.set(VINEXT_CLIENT_REUSE_MANIFEST_HEADER, clientReuseManifestHeader);
 						}
 						navResponse = await fetch(rscUrl, {
@@ -1086,10 +1138,30 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 					const rscPayload = decodeAppElementsPromise(createFromFetch(Promise.resolve(reactResponse)));
 					if (!browserNavigationController.isCurrentNavigation(navId)) return;
 					let committedState = null;
-					if (await renderNavigationPayload(rscPayload, navigationSnapshot, currentHref, navId, currentHistoryMode, navParams, requestPreviousNextUrl, detachedNavigationCommits ? null : pendingRouterState, FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN, toActionType(navigationKind), toOperationLane(navigationKind), activeTraversalIntent, scrollIntent, restoredBfcacheIds, reuseCurrentBfcacheIds, visibleCommitMode, (state) => {
-						committedState = state;
-						if (activeNavigationAbortController === navigationAbortController) activeNavigationAbortController = null;
-					}, detachedNavigationCommits ? "authoritative" : void 0) !== "committed") return;
+					if (await renderNavigationPayload({
+						actionType: toActionType(navigationKind),
+						historyUpdateMode: currentHistoryMode,
+						navigationCommitKind: detachedNavigationCommits ? "authoritative" : void 0,
+						navigationInitiationState,
+						navigationSnapshot,
+						navId,
+						onCommittedState: (state) => {
+							committedState = state;
+							if (activeNavigationAbortController === navigationAbortController) activeNavigationAbortController = null;
+						},
+						operationLane: toOperationLane(navigationKind),
+						params: navParams,
+						payload: rscPayload,
+						payloadOrigin: FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN,
+						pendingRouterState: detachedNavigationCommits ? null : pendingRouterState,
+						previousNextUrl: requestPreviousNextUrl,
+						restoredBfcacheIds,
+						reuseCurrentBfcacheIds,
+						scrollIntent,
+						targetHref: currentHref,
+						traversalIntent: activeTraversalIntent,
+						visibleCommitMode
+					}) !== "committed") return;
 					try {
 						const renderedElements = await rscPayload;
 						if (navigationCacheGeneration !== clientNavigationCacheGeneration) return;

package/dist/server/app-browser-navigation-controller.d.ts

@@ -43,6 +43,28 @@ type BrowserNavigationControllerDeps = {
   getRouteManifest?: () => RouteManifest | null;
   syncHistoryStatePreviousNextUrl?: (previousNextUrl: string | null, bfcacheIds?: Readonly<Record<string, string>> | null) => void;
 };
+type BrowserNavigationPayloadOptions = {
+  actionType: "navigate" | "replace" | "traverse";
+  createNavigationCommitEffect: BrowserNavigationCommitEffectFactory;
+  historyUpdateMode: HistoryUpdateMode | undefined;
+  navigationCommitKind?: "authoritative" | "detached";
+  navigationInitiationState: AppRouterState;
+  navigationSnapshot: ClientNavigationRenderSnapshot;
+  navId: number;
+  nextElements: Promise<AppElements>;
+  onCommittedState?: (state: AppRouterState) => void;
+  operationLane: OperationLane;
+  params: Record<string, string | string[]>;
+  payloadOrigin: AppNavigationPayloadOrigin;
+  pendingRouterState: PendingBrowserRouterState | null;
+  previousNextUrl: string | null;
+  restoredBfcacheIds?: Readonly<Record<string, string>> | null;
+  reuseCurrentBfcacheIds?: boolean;
+  scrollIntent?: AppRouterScrollIntent | null;
+  targetHistoryIndex?: number | null;
+  targetHref: string;
+  visibleCommitMode?: NavigationRuntimeVisibleCommitMode;
+};
 type BrowserNavigationController = {
   beginNavigation(): number;
   getActiveNavigationId(): number;
@@ -60,27 +82,7 @@ type BrowserNavigationController = {
     state: AppRouterState;
     targetHref: string;
   }): boolean;
-  renderNavigationPayload(options: {
-    actionType: "navigate" | "replace" | "traverse";
-    createNavigationCommitEffect: BrowserNavigationCommitEffectFactory;
-    historyUpdateMode: HistoryUpdateMode | undefined;
-    navigationSnapshot: ClientNavigationRenderSnapshot;
-    nextElements: Promise<AppElements>;
-    operationLane: OperationLane;
-    payloadOrigin: AppNavigationPayloadOrigin;
-    params: Record<string, string | string[]>;
-    pendingRouterState: PendingBrowserRouterState | null;
-    previousNextUrl: string | null;
-    scrollIntent?: AppRouterScrollIntent | null;
-    restoredBfcacheIds?: Readonly<Record<string, string>> | null;
-    reuseCurrentBfcacheIds?: boolean;
-    targetHistoryIndex?: number | null;
-    targetHref: string;
-    navId: number;
-    navigationCommitKind?: "authoritative" | "detached";
-    visibleCommitMode?: NavigationRuntimeVisibleCommitMode;
-    onCommittedState?: (state: AppRouterState) => void;
-  }): Promise<NavigationPayloadOutcome>;
+  renderNavigationPayload(options: BrowserNavigationPayloadOptions): Promise<NavigationPayloadOutcome>;
   commitSameUrlNavigatePayload(nextElements: Promise<AppElements>, navigationSnapshot: ClientNavigationRenderSnapshot, returnValue?: {
     ok: boolean;
     data: unknown;

package/dist/server/app-browser-navigation-controller.js

@@ -349,7 +349,7 @@ function createAppBrowserNavigationController(deps = {}) {
 		let snapshotActivated = false;
 		try {
 			const pending = await createPendingNavigationCommit({
-				currentState: getBrowserRouterState(),
+				currentState: options.navigationInitiationState,
 				navigationCommitKind: options.navigationCommitKind,
 				navigationId: options.navId,
 				nextElements: options.nextElements,