vinext 1.2.1 → 1.3.1

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

@@ -1,4 +1,4 @@
-import { RouteManifest } from "../routing/app-route-graph.js";
+import { BrowserRouteManifest } from "../routing/browser-route-manifest.js";
 import { AppRouterScrollIntent } from "../shims/app-router-scroll-state.js";
 import { NavigationRuntimeVisibleCommitMode } from "../client/navigation-runtime.js";
 import { AppElements } from "./app-elements-wire.js";
@@ -17,10 +17,14 @@ export type PendingBrowserRouterState = {
 };
 export type NavigationPayloadOutcome = "committed" | "no-commit" | "hard-navigate";
 type HardNavigationMode = "assign" | "replace";
-type BrowserNavigationCommitEffect = (options: {
-  keepCurrentUrl: boolean;
-  releaseSnapshot: boolean;
-}) => void;
+type BrowserNavigationCommitEffect = {
+  writeHistory(options: {
+    keepCurrentUrl: boolean;
+  }): void;
+  publish(options: {
+    releaseSnapshot: boolean;
+  }): void;
+};
 type BrowserNavigationCommitEffectFactory = (options: {
   activeRoutePaths: readonly string[];
   bfcacheIds: Readonly<Record<string, string>>;
@@ -43,8 +47,10 @@ type SameUrlServerActionLifecycleOptions = {
 type BrowserNavigationControllerDeps = {
   basePath?: string;
   commitClientNavigationState?: typeof commitClientNavigationState;
+  navigateDocument?: (href: string, mode: HardNavigationMode) => void;
   performHardNavigation?: (href: string, mode?: HardNavigationMode) => boolean;
-  getRouteManifest?: () => RouteManifest | null;
+  getRouteManifest?: () => BrowserRouteManifest | null;
+  loadRouteManifest?: () => Promise<boolean> | null;
   syncHistoryStatePreviousNextUrl?: (previousNextUrl: string | null, bfcacheIds?: Readonly<Record<string, string>> | null) => void;
 };
 type BrowserNavigationPayloadOptions = {
@@ -80,6 +86,7 @@ type BrowserNavigationController = {
   waitForBrowserRouterStateReady(): Promise<void>;
   attachBrowserRouterState(setter: Dispatch<AppRouterState | Promise<AppRouterState>>, stateRef: BrowserRouterStateRef): () => void;
   beginPendingBrowserRouterState(): PendingBrowserRouterState;
+  abandonPendingBrowserRouterState(pending: PendingBrowserRouterState | null | undefined): void;
   finalizeNavigation(navId: number, pending: PendingBrowserRouterState | null | undefined): void;
   discardPendingNavigation(visibleState: AppRouterState | null): boolean;
   flushCommittingNavigationUrl(): void;
@@ -112,8 +119,12 @@ type BrowserNavigationController = {
     renderId: number;
     children?: ReactNode;
   }): ReactNode;
+  NavigationHistoryCommit(this: void, { renderId }: {
+    renderId: number;
+  }): null;
 };
 export declare function clearHardNavigationLoopGuard(): void;
+export declare function navigateDocumentDirectly(href: string, mode: HardNavigationMode): void;
 export declare function createBasePathStrippedPathAndSearch(url: URL, basePath: string): string;
 export declare function createAppBrowserNavigationController(deps?: BrowserNavigationControllerDeps): BrowserNavigationController;
 //#endregion

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

@@ -1,4 +1,5 @@
 import { stripBasePath } from "../utils/base-path.js";
+import { withBasePath } from "../shims/url-utils.js";
 import { clearAppNavigationFailureTarget, getAppNavigationFailureTarget } from "../client/app-nav-failure-handler.js";
 import { claimAppRouterScrollIntentForCommit, clearAppRouterScrollIntent, consumeAppRouterScrollIntent } from "../shims/app-router-scroll-state.js";
 import { resolveServerActionOperationLane, shouldScheduleRefreshForDiscardedServerAction } from "./app-browser-action-result.js";
@@ -37,7 +38,11 @@ function clearHardNavigationLoopGuard() {
 		window.sessionStorage.removeItem(HARD_NAVIGATION_LOOP_GUARD_KEY);
 	} catch {}
 }
-function performHardNavigationWithLoopGuard(href, mode = "assign") {
+function navigateDocumentDirectly(href, mode) {
+	if (mode === "replace") window.location.replace(href);
+	else window.location.assign(href);
+}
+function performHardNavigationWithLoopGuard(href, mode = "assign", navigateDocument = navigateDocumentDirectly) {
 	const targetHref = normalizeBrowserHref(href);
 	const currentHref = normalizeBrowserHref(window.location.href);
 	if (readHardNavigationLoopGuard() === targetHref && currentHref === targetHref) {
@@ -49,8 +54,7 @@ function performHardNavigationWithLoopGuard(href, mode = "assign") {
 		console.error(`[vinext] Hard navigation to ${targetHref} requires a reload-loop guard, but sessionStorage is unavailable; leaving the current document in place.`);
 		return false;
 	}
-	if (mode === "replace") window.location.replace(href);
-	else window.location.assign(href);
+	navigateDocument(href, mode);
 	return true;
 }
 function createBasePathStrippedPathAndSearch(url, basePath) {
@@ -69,8 +73,9 @@ function isSnapshotTargetHref(basePath, snapshot, targetHref) {
 function createAppBrowserNavigationController(deps = {}) {
 	const basePath = deps.basePath ?? "";
 	const commitClientNavigationStateImpl = deps.commitClientNavigationState ?? commitClientNavigationState;
-	const performHardNavigation = deps.performHardNavigation ?? performHardNavigationWithLoopGuard;
+	const performHardNavigation = deps.performHardNavigation ?? ((href, mode) => performHardNavigationWithLoopGuard(href, mode, deps.navigateDocument));
 	const getRouteManifest = deps.getRouteManifest ?? (() => null);
+	const loadRouteManifest = deps.loadRouteManifest ?? (() => null);
 	const syncHistoryStatePreviousNextUrl = deps.syncHistoryStatePreviousNextUrl ?? (() => {});
 	let nextNavigationRenderId = 0;
 	let activeNavigationId = 0;
@@ -162,6 +167,11 @@ function createAppBrowserNavigationController(deps = {}) {
 		pending.resolve(getBrowserRouterState());
 		if (activePendingBrowserRouterState === pending) activePendingBrowserRouterState = null;
 	}
+	function abandonPendingBrowserRouterState(pending) {
+		if (!pending || pending.settled) return;
+		pending.settled = true;
+		if (activePendingBrowserRouterState === pending) activePendingBrowserRouterState = null;
+	}
 	function finalizeNavigation(navId, pending) {
 		settlePendingBrowserRouterState(pending);
 		if (isCurrentNavigation(navId)) {
@@ -209,11 +219,11 @@ function createAppBrowserNavigationController(deps = {}) {
 		return true;
 	}
 	/**
-	* Run the URL update of a navigation render React is committing right now.
-	* It normally runs in NavigationCommitSignal's layout effect, after the
-	* route's own layout effects. Next.js writes the URL in an insertion effect
-	* instead, so a raw history write from a destination layout effect lands on
-	* top of the destination entry. Called before such a write to keep that order.
+	* Publish the URL update of a navigation render React is committing right
+	* now. Its history entry is already written, but publishing normally runs in
+	* NavigationCommitSignal's layout effect, after the route's own layout
+	* effects. Called before a raw history write from such an effect, so the
+	* write is published on top of the destination's.
 	*/
 	function flushCommittingNavigationUrl() {
 		if (committingNavigationRenderId !== null) drainPrePaintEffects(committingNavigationRenderId);
@@ -224,9 +234,12 @@ function createAppBrowserNavigationController(deps = {}) {
 	function isRetiredNavigationUrl(navId, targetHref) {
 		return retiredNavigationUrl !== null && retiredNavigationUrl.navigationId === navId && retiredNavigationUrl.href === normalizeBrowserHref(targetHref);
 	}
-	function queuePrePaintNavigationEffect(renderId, effect) {
-		if (!effect) return;
-		pendingNavigationPrePaintEffects.set(renderId, effect);
+	function writeNavigationRenderHistory(renderId) {
+		const effect = pendingNavigationPrePaintEffects.get(renderId);
+		const writeHistory = effect?.writeHistory;
+		if (!effect || !writeHistory) return;
+		effect.writeHistory = null;
+		writeHistory();
 	}
 	/**
 	* Run all queued pre-paint effects for renderIds up to and including the
@@ -243,8 +256,10 @@ function createAppBrowserNavigationController(deps = {}) {
 		for (const [id, effect] of pendingNavigationPrePaintEffects) {
 			if (id > upToRenderId) continue;
 			pendingNavigationPrePaintEffects.delete(id);
-			if (id === upToRenderId) effect();
-			else releaseRenderSnapshot(id);
+			if (id === upToRenderId) {
+				effect.writeHistory?.();
+				effect.publish();
+			} else releaseRenderSnapshot(id);
 		}
 	}
 	/**
@@ -261,7 +276,10 @@ function createAppBrowserNavigationController(deps = {}) {
 			pendingCommit.resolve(didCommit);
 		}
 	}
-	/** Runs when React starts committing a render, before any layout effect. */
+	/**
+	* Runs when React starts committing a render, before it changes the route
+	* tree's DOM, and writes the render's history entry.
+	*/
 	function beginNavigationRenderCommit(renderId) {
 		committingNavigationRenderId = renderId;
 		const committingCommit = pendingNavigationCommits.get(renderId);
@@ -269,6 +287,7 @@ function createAppBrowserNavigationController(deps = {}) {
 		if (committingCommit && committingOperation?.navigationCommitKind === "detached" && committingOperation.navigationId === pendingUserNavigationId) pendingUserNavigationShellHref = normalizeBrowserHref(committingCommit.targetHref);
 		else pendingUserNavigationCommitStarted = true;
 		clearCommittedNavigationFailureTargets(renderId);
+		writeNavigationRenderHistory(renderId);
 	}
 	function commitNavigationRender(renderId) {
 		committingNavigationRenderId = null;
@@ -288,7 +307,11 @@ function createAppBrowserNavigationController(deps = {}) {
 		if (!hasBrowserRouterState()) return;
 		const currentState = getBrowserRouterState();
 		const renderId = allocateRenderId();
-		const [navigationSnapshot] = await Promise.all([pendingNavigationSnapshot, nextElements]);
+		const [navigationSnapshot, , routeManifestLoaded] = await Promise.all([
+			pendingNavigationSnapshot,
+			nextElements,
+			loadRouteManifest()
+		]);
 		const pending = await createPendingNavigationCommit({
 			currentState,
 			nextElements,
@@ -300,19 +323,36 @@ function createAppBrowserNavigationController(deps = {}) {
 		});
 		if (hmrUpdateId !== latestHmrUpdateId || startedDuringUserNavigation) return;
 		if (!hasBrowserRouterState()) return;
+		if (routeManifestLoaded === false) {
+			performHardNavigation(withBasePath(createSnapshotPathAndSearch(navigationSnapshot), basePath));
+			return;
+		}
 		const approval = approveHmrVisibleCommit({
 			currentState: getBrowserRouterState(),
 			pending,
 			routeManifest: deps.getRouteManifest?.() ?? null,
 			targetHref: createSnapshotPathAndSearch(navigationSnapshot)
 		});
-		if (approval.approvedCommit) dispatchSynchronousVisibleCommit(approval.approvedCommit);
-		else if (approval.decision.disposition === "hard-navigate") performHardNavigation(createSnapshotPathAndSearch(navigationSnapshot));
+		if (approval.approvedCommit) {
+			const approvedHmrCommit = approval.approvedCommit;
+			startTransition(() => {
+				dispatchVisibleCommit(approvedHmrCommit);
+			});
+		} else if (approval.decision.disposition === "hard-navigate") performHardNavigation(createSnapshotPathAndSearch(navigationSnapshot));
 	}
-	function NavigationCommitSignal({ renderId, children }) {
+	/**
+	* Rendered before the route tree (see createAppRouteTree). Insertion effects
+	* run in the mutation phase, in tree order, after each component's own
+	* subtree mutations, so this one runs before React changes the route tree's
+	* DOM. An effect on NavigationCommitSignal itself would run after them.
+	*/
+	function NavigationHistoryCommit({ renderId }) {
 		useInsertionEffect(() => {
 			beginNavigationRenderCommit(renderId);
 		}, [renderId]);
+		return null;
+	}
+	function NavigationCommitSignal({ renderId, children }) {
 		useLayoutEffect(() => {
 			commitNavigationRender(renderId);
 			return () => {
@@ -321,7 +361,7 @@ function createAppBrowserNavigationController(deps = {}) {
 		}, [renderId]);
 		return children;
 	}
-	function dispatchApprovedVisibleCommit(renderId, commit, pendingRouterState, visibleCommitMode) {
+	function dispatchApprovedVisibleCommit(renderId, commit, pendingRouterState, visibleCommitMode, republishPendingRouterState) {
 		const setter = getBrowserRouterStateSetter();
 		const pendingCommit = pendingNavigationCommits.get(renderId);
 		const captureCandidateState = (state) => {
@@ -334,7 +374,7 @@ function createAppBrowserNavigationController(deps = {}) {
 			pendingRouterState.settled = true;
 			pendingRouterState.resolve(committedState);
 			if (activePendingBrowserRouterState === pendingRouterState) activePendingBrowserRouterState = null;
-			if (visibleCommitMode === "synchronous") flushSync(() => {
+			if (republishPendingRouterState) startTransition(() => {
 				setter(committedState);
 			});
 			return;
@@ -351,7 +391,8 @@ function createAppBrowserNavigationController(deps = {}) {
 			setter(committedState);
 		});
 	}
-	function dispatchSynchronousVisibleCommit(commit) {
+	/** Calls the setter directly; the caller chooses the update's priority. */
+	function dispatchVisibleCommit(commit) {
 		getBrowserRouterStateSetter()(applyApprovedVisibleCommit(getBrowserRouterState(), commit));
 	}
 	function createRestoredHistorySnapshotCommit(options) {
@@ -408,7 +449,7 @@ function createAppBrowserNavigationController(deps = {}) {
 		});
 		if (approval.approvedCommit === null) return false;
 		options.beforeCommit?.();
-		dispatchSynchronousVisibleCommit(approval.approvedCommit);
+		dispatchVisibleCommit(approval.approvedCommit);
 		return true;
 	}
 	function notifyDiscardedServerActionRevalidation(lifecycleOptions) {
@@ -426,13 +467,20 @@ function createAppBrowserNavigationController(deps = {}) {
 			return false;
 		}
 	}
-	function shouldForceSynchronousCommit(options) {
+	function shouldRepublishPendingRouterState(options) {
 		if (options.actionType === "traverse") return false;
 		if (options.historyUpdateMode === void 0) return false;
 		if (options.scrollIntent?.hash == null) return false;
 		return isSamePathSearchHashCommit(options.targetHref);
 	}
 	async function renderNavigationPayload(options) {
+		const routeManifestLoad = loadRouteManifest();
+		if (routeManifestLoad !== null && !await routeManifestLoad) {
+			settlePendingBrowserRouterState(options.pendingRouterState);
+			consumeAppRouterScrollIntent(options.scrollIntent ?? null);
+			if (isCurrentNavigation(options.navId)) performHardNavigation(options.targetHref, options.historyUpdateMode === "push" ? "assign" : "replace");
+			return "no-commit";
+		}
 		if (options.navId === pendingUserNavigationId) pendingUserNavigationLane = options.operationLane;
 		const renderId = allocateRenderId();
 		const failureTarget = getAppNavigationFailureTarget(options.targetHref);
@@ -486,11 +534,14 @@ function createAppBrowserNavigationController(deps = {}) {
 				return "no-commit";
 			}
 			if (approval.decision.disposition === "hard-navigate") {
-				settlePendingBrowserRouterState(options.pendingRouterState);
 				pendingNavigationFailureTargets.delete(renderId);
 				pendingNavigationCommits.delete(renderId);
 				consumeAppRouterScrollIntent(options.scrollIntent ?? null);
-				if (performHardNavigation(options.targetHref)) return "hard-navigate";
+				if (performHardNavigation(options.targetHref, options.historyUpdateMode === "push" ? "assign" : "replace")) {
+					abandonPendingBrowserRouterState(options.pendingRouterState);
+					return "hard-navigate";
+				}
+				settlePendingBrowserRouterState(options.pendingRouterState);
 				if (failureTarget) clearAppNavigationFailureTarget(failureTarget);
 				return "no-commit";
 			}
@@ -507,23 +558,25 @@ function createAppBrowserNavigationController(deps = {}) {
 				previousNextUrl: approvedCommit.previousNextUrl,
 				targetHistoryIndex: options.targetHistoryIndex
 			});
-			queuePrePaintNavigationEffect(renderId, () => {
-				commitEffect({
-					keepCurrentUrl: isRetiredNavigationUrl(options.navId, options.targetHref),
-					releaseSnapshot: snapshotRenderIds.delete(renderId)
-				});
+			pendingNavigationPrePaintEffects.set(renderId, {
+				writeHistory: () => {
+					commitEffect.writeHistory({ keepCurrentUrl: isRetiredNavigationUrl(options.navId, options.targetHref) });
+				},
+				publish: () => {
+					commitEffect.publish({ releaseSnapshot: snapshotRenderIds.delete(renderId) });
+				}
 			});
 			claimAppRouterScrollIntentForCommit(options.scrollIntent, renderId);
 			if (!isRetiredNavigationUrl(options.navId, options.targetHref)) {
 				activateNavigationSnapshot();
 				snapshotRenderIds.add(renderId);
 			}
-			dispatchApprovedVisibleCommit(renderId, approvedCommit, options.pendingRouterState, shouldForceSynchronousCommit(options) ? "synchronous" : options.visibleCommitMode ?? "transition");
+			dispatchApprovedVisibleCommit(renderId, approvedCommit, options.pendingRouterState, options.visibleCommitMode ?? "transition", shouldRepublishPendingRouterState(options));
 			if (options.navigationResponseCompletion) options.navigationResponseCompletion.then(() => {
 				if (!isCurrentNavigation(options.navId) || !hasBrowserRouterState()) return;
 				const committedState = pendingNavigationCommits.get(renderId)?.committedState;
 				if (!committedState) return;
-				flushSync(() => {
+				startTransition(() => {
 					getBrowserRouterStateSetter()(committedState);
 				});
 			}, () => {});
@@ -542,6 +595,15 @@ function createAppBrowserNavigationController(deps = {}) {
 		const currentState = actionInitiationState ?? getBrowserRouterState();
 		const startedNavigationId = lifecycleOptions?.startedNavigationId ?? activeNavigationId;
 		const targetHref = lifecycleOptions?.targetHref ?? window.location.href;
+		const routeManifestLoad = loadRouteManifest();
+		if (routeManifestLoad !== null && !await routeManifestLoad) {
+			if (isCurrentNavigation(startedNavigationId)) {
+				performHardNavigation(targetHref);
+				return;
+			}
+			notifyDiscardedServerActionRevalidation(lifecycleOptions);
+			return resolveSameUrlActionReturnValue(returnValue);
+		}
 		const { approvedCommit, decision, pending, trace: _navigationTrace } = await resolveAndClassifyNavigationCommit({
 			activeNavigationId,
 			currentState,
@@ -577,11 +639,14 @@ function createAppBrowserNavigationController(deps = {}) {
 			if (latestApproval.approvedCommit) {
 				const approvedRevalidationCommit = latestApproval.approvedCommit;
 				startTransition(() => {
-					dispatchSynchronousVisibleCommit(approvedRevalidationCommit);
+					dispatchVisibleCommit(approvedRevalidationCommit);
 				});
 				syncHistoryStatePreviousNextUrl(approvedRevalidationCommit.previousNextUrl, approvedRevalidationCommit.action.bfcacheIds);
 			} else notifyDiscardedServerActionRevalidation(lifecycleOptions);
 		} else if (decision.disposition === "no-commit") notifyDiscardedServerActionRevalidation(lifecycleOptions);
+		return resolveSameUrlActionReturnValue(returnValue);
+	}
+	async function resolveSameUrlActionReturnValue(returnValue) {
 		if (returnValue) {
 			if (!returnValue.ok) throw await returnValue.data;
 			return returnValue.data;
@@ -609,6 +674,7 @@ function createAppBrowserNavigationController(deps = {}) {
 		waitForBrowserRouterStateReady,
 		attachBrowserRouterState,
 		beginPendingBrowserRouterState,
+		abandonPendingBrowserRouterState,
 		finalizeNavigation,
 		discardPendingNavigation,
 		flushCommittingNavigationUrl,
@@ -620,8 +686,9 @@ function createAppBrowserNavigationController(deps = {}) {
 		beginNavigationRenderCommit,
 		commitNavigationRender,
 		clearCommittedNavigationFailureTargets,
-		NavigationCommitSignal
+		NavigationCommitSignal,
+		NavigationHistoryCommit
 	};
 }
 //#endregion
-export { clearHardNavigationLoopGuard, createAppBrowserNavigationController, createBasePathStrippedPathAndSearch, createSnapshotPathAndSearch };
+export { clearHardNavigationLoopGuard, createAppBrowserNavigationController, createBasePathStrippedPathAndSearch, createSnapshotPathAndSearch, navigateDocumentDirectly };

package/dist/server/app-browser-popstate.d.ts

@@ -26,4 +26,5 @@ export declare function shouldCommitPopstateUrlWithoutNavigation(options: {
   isSameAppRouteTarget: boolean;
 }): boolean;
 export declare function createPopstateRestoreHandler(deps: BrowserPopstateRestoreDeps): (event: PopStateEvent) => void;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-browser-rsc-redirect.d.ts

@@ -34,4 +34,5 @@ export declare function resolveStreamedRscRedirectLifecycleHop(options: {
   requestPreviousNextUrl: string | null;
   streamedRedirectTarget: string;
 }): RscRedirectLifecycleDecision;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-browser-server-action-client.d.ts

@@ -30,4 +30,5 @@ export type ClientServerActionDeps = {
   syncServerActionHttpFallbackHead(status: number | null): void;
 };
 export declare function invokeClientServerAction(id: string, args: unknown[], actionInitiation: ClientServerActionInitiation, deps: ClientServerActionDeps): Promise<unknown>;
-//#endregion
+//#endregion
+export {};

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

@@ -1,4 +1,4 @@
-import { RouteManifest } from "../routing/app-route-graph.js";
+import { BrowserRouteManifest } from "../routing/browser-route-manifest.js";
 import { CacheEntryReuseProof } from "./cache-proof.js";
 import { AppElements, AppElementsInterception, AppElementsSlotBinding, LayoutFlags } from "./app-elements-wire.js";
 import "./app-elements.js";
@@ -130,7 +130,7 @@ export declare function resolvePendingNavigationCommitDispositionDecision(option
   activeNavigationId: number;
   currentState: AppRouterState;
   pending: PendingNavigationCommit;
-  routeManifest?: RouteManifest | null;
+  routeManifest?: BrowserRouteManifest | null;
   startedNavigationId: number;
   targetHref?: string;
 }): PendingNavigationCommitDispositionDecision;

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

@@ -7,8 +7,8 @@ import { AppElementsWire } from "./app-elements-wire.js";
 import { getMountedSlotIds, getMountedSlotIdsHeader } from "./app-elements.js";
 import { bindAppElementsRenderedSearch } from "../shims/slot.js";
 import { createRscRequestHeaders } from "./app-rsc-cache-busting.js";
-import { createCacheEntryReuseProof } from "./cache-proof.js";
 import { createBfcacheSegmentIdentityMap, createInitialBfcacheIdMap, createNextBfcacheIdMap, preserveBfcacheIdsForMergedElements } from "./app-bfcache-identity.js";
+import { createCacheEntryReuseProof } from "./cache-proof.js";
 import { createAppOwnedHistoryState, createExternalHistoryStatePreservingMetadata, createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, createHistoryStateWithTreeSnapshotId, isExternalHistoryState, isHistoryStateBfcacheVersionCurrent, readHistoryStateActiveRoutePaths, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveActiveRoutePaths, resolveHistoryTraversalIntent } from "./app-history-state.js";
 import { NavigationTraceReasonCodes, createNavigationLifecycleTraceFields, createNavigationTrace } from "./navigation-trace.js";
 import { verifyOperationTokenForCommit } from "./operation-token.js";

package/dist/server/app-browser-stream.d.ts

@@ -21,4 +21,5 @@ export declare function chunksToReadableStream(chunks: readonly RscEmbeddedChunk
  * immediately instead of polling with setTimeout.
  */
 export declare function createProgressiveRscStream(): ReadableStream<Uint8Array>;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-browser-visible-commit.d.ts

@@ -1,4 +1,4 @@
-import { RouteManifest } from "../routing/app-route-graph.js";
+import { BrowserRouteManifest } from "../routing/browser-route-manifest.js";
 import { AppElements } from "./app-elements-wire.js";
 import "./app-elements.js";
 import { NavigationTrace } from "./navigation-trace.js";
@@ -52,14 +52,14 @@ export declare function applyApprovedVisibleCommit(state: AppRouterState, commit
 export declare function approveHmrVisibleCommit(options: {
   currentState: AppRouterState;
   pending: PendingNavigationCommit;
-  routeManifest?: RouteManifest | null;
+  routeManifest?: BrowserRouteManifest | null;
   targetHref: string;
 }): CommitApproval;
 export declare function approvePendingNavigationCommit(options: {
   activeNavigationId: number;
   currentState: AppRouterState;
   pending: PendingNavigationCommit;
-  routeManifest?: RouteManifest | null;
+  routeManifest?: BrowserRouteManifest | null;
   startedNavigationId: number;
   targetHref: string;
 }): CommitApproval;
@@ -74,9 +74,10 @@ export declare function resolveAndClassifyNavigationCommit(options: {
   payloadOrigin: AppNavigationPayloadOrigin;
   previousNextUrl?: string | null;
   renderId: number;
-  routeManifest?: RouteManifest | null;
+  routeManifest?: BrowserRouteManifest | null;
   startedNavigationId: number;
   targetHref: string;
   type: "navigate" | "replace" | "traverse";
 }): Promise<ClassifiedPendingNavigationCommit>;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-client-reference-manifest.d.ts

@@ -0,0 +1,31 @@
+import { ClientReferenceChunks } from "../utils/client-reference-chunks.js";
+//#region src/server/app-client-reference-manifest.d.ts
+type ClientManifestEntry = {
+  id: string;
+  name: string;
+  chunks: string[];
+  async?: boolean;
+};
+type ClientManifest = Record<string, ClientManifestEntry>;
+/**
+ * Names the chunks each client reference loads in its Flight row, as Next.js
+ * does, so the browser loads a reference without a registry of every client
+ * reference in the app (see shims/internal/client-reference-loader.ts). Returns a
+ * function that wraps @vitejs/plugin-rsc's client manifest, which leaves the
+ * chunks empty. Without chunk data (development, or `rsc: false`) it returns
+ * the manifest unchanged.
+ */
+export declare function createClientReferenceChunksManifest(referenceChunks: ClientReferenceChunks | undefined): (manifest: ClientManifest) => ClientManifest;
+/**
+ * The SSR Flight client's consumer manifest. React's webpack binding loads the
+ * chunks a client reference's row names before requiring the reference, which
+ * only the browser can do, so SSR resolves each reference to itself without
+ * them. A null `moduleLoading` keeps React from preinitializing the chunks as
+ * classic scripts; SSR preloads them through @vitejs/plugin-rsc instead.
+ */
+export declare const ssrServerConsumerManifest: {
+  moduleMap: Record<string, Record<string, ClientManifestEntry>>;
+  moduleLoading: null;
+};
+//#endregion
+export {};

package/dist/server/app-client-reference-manifest.js

@@ -0,0 +1,46 @@
+import { toFlightChunks } from "../utils/client-reference-chunks.js";
+//#region src/server/app-client-reference-manifest.ts
+/**
+* Names the chunks each client reference loads in its Flight row, as Next.js
+* does, so the browser loads a reference without a registry of every client
+* reference in the app (see shims/internal/client-reference-loader.ts). Returns a
+* function that wraps @vitejs/plugin-rsc's client manifest, which leaves the
+* chunks empty. Without chunk data (development, or `rsc: false`) it returns
+* the manifest unchanged.
+*/
+function createClientReferenceChunksManifest(referenceChunks) {
+	if (!referenceChunks) return (manifest) => manifest;
+	const flightChunks = referenceChunks.modules.map(toFlightChunks);
+	return (manifest) => new Proxy(manifest, { get(target, id, receiver) {
+		const entry = Reflect.get(target, id, receiver);
+		if (typeof id !== "string" || !entry || typeof entry !== "object") return entry;
+		const reference = entry;
+		const index = Object.hasOwn(referenceChunks.references, reference.id) ? referenceChunks.references[reference.id] : void 0;
+		return index === void 0 ? reference : {
+			...reference,
+			chunks: flightChunks[index]
+		};
+	} });
+}
+/**
+* The SSR Flight client's consumer manifest. React's webpack binding loads the
+* chunks a client reference's row names before requiring the reference, which
+* only the browser can do, so SSR resolves each reference to itself without
+* them. A null `moduleLoading` keeps React from preinitializing the chunks as
+* classic scripts; SSR preloads them through @vitejs/plugin-rsc instead.
+*/
+const ssrServerConsumerManifest = {
+	moduleMap: new Proxy({}, { get(_target, id) {
+		if (typeof id !== "string") return void 0;
+		return new Proxy({}, { get(_exports, name) {
+			return typeof name === "string" ? {
+				id,
+				chunks: [],
+				name
+			} : void 0;
+		} });
+	} }),
+	moduleLoading: null
+};
+//#endregion
+export { createClientReferenceChunksManifest, ssrServerConsumerManifest };

package/dist/server/app-client-reference-preloader.d.ts

@@ -7,7 +7,50 @@ type ClientReferencePreloaderOptions = {
   onPreloadError?: (id: string, error: unknown) => void;
 };
 type ClientReferencePreloader = {
-  preload: (referenceIds?: Iterable<string>) => Promise<void>;
+  /**
+   * Load `referenceIds` in order, or every reference without them. The
+   * returned promise doesn't wait for those in `streamedIds`.
+   */
+  preload: (referenceIds?: Iterable<string>, streamedIds?: ReadonlySet<string>) => Promise<void>;
 };
+/**
+ * The client references each App Router route preloads before SSR, generated
+ * by plugins/rsc-client-reference-loaders.ts from the RSC build's module graph.
+ * Each list holds indices into `references`, or for routes into `files`.
+ */
+export type RouteClientReferences = {
+  /** Client reference keys. */
+  references: readonly string[];
+  /** References any render may use, whatever its route. */
+  always: readonly number[];
+  /** The references each route file reaches. */
+  files: readonly (readonly number[])[];
+  /** Each route pattern's files. */
+  routes: Readonly<Record<string, readonly number[]>>;
+  /** The files of a render without a route, such as a route-miss 404. */
+  routeless: readonly number[];
+  /**
+   * References whose SSR modules evaluate asynchronously (top-level await),
+   * which a render streams instead of waiting for.
+   */
+  async: readonly number[];
+};
+/** The client references a render loads, and those it streams instead of waiting for. */
+export type RouteClientReferenceSet = {
+  /**
+   * In import order: the `always` set, then each route file's references in
+   * the order its route files render.
+   */
+  references: string[];
+  streamed: string[];
+};
+/**
+ * The client references a render of `routePattern` preloads, or of no route
+ * when it is null, and those it streams.
+ * Undefined, meaning every reference, without a plan or a route to look up,
+ * or for a pattern the plan doesn't know.
+ */
+export declare function resolveRouteClientReferences(plan: RouteClientReferences | null, routePattern: string | null | undefined): RouteClientReferenceSet | undefined;
 export declare function createClientReferencePreloader(options: ClientReferencePreloaderOptions): ClientReferencePreloader;
-//#endregion
+//#endregion
+export {};