vinext 1.3.0 → 1.4.0

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

@@ -38,4 +38,5 @@ export declare function resolveFetchedHydrationLocation(renderedPathAndSearch: s
   pathname: string;
   search: string;
 };
-//#endregion
+//#endregion
+export {};

package/dist/server/app-browser-interception-context.d.ts

@@ -20,4 +20,5 @@ type ResolveManifestNavigationInterceptionContextOptions = {
  */
 export declare function resolveManifestNavigationInterceptionContext(options: ResolveManifestNavigationInterceptionContextOptions): string | null;
 export declare function resolveMiddlewareRewriteNavigationInterceptionContext(options: ResolveManifestNavigationInterceptionContextOptions): string | null;
-//#endregion
+//#endregion
+export {};

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

@@ -1,11 +1,11 @@
 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";
 import "./app-elements.js";
+import { ClientNavigationRenderSnapshot, commitClientNavigationState, createSnapshotPathAndSearch } from "../shims/navigation.js";
+import { NavigationRuntimeVisibleCommitMode } from "../client/navigation-runtime.js";
 import { OperationLane } from "./operation-token.js";
 import { ServerActionRevalidationKind } from "./app-browser-action-result.js";
-import { ClientNavigationRenderSnapshot, commitClientNavigationState, createSnapshotPathAndSearch } from "../shims/navigation.js";
 import { AppNavigationPayloadOrigin, AppRouterState } from "./app-browser-state.js";
 import { Dispatch, ReactNode } from "react";
 //#region src/server/app-browser-navigation-controller.d.ts

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

@@ -1,9 +1,9 @@
 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";
 import { resolveActiveRoutePaths } from "./app-history-state.js";
+import { claimAppRouterScrollIntentForCommit, clearAppRouterScrollIntent, consumeAppRouterScrollIntent } from "../shims/app-router-scroll-state.js";
 import { activateNavigationSnapshot, clearPendingPathname, commitClientNavigationState, createSnapshotPathAndSearch } from "../shims/navigation.js";
 import { FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN, createPendingNavigationCommit, createPendingNavigationCommitFromElements } from "./app-browser-state.js";
 import { applyApprovedVisibleCommit, approveHmrVisibleCommit, approvePendingNavigationCommit, resolveAndClassifyNavigationCommit } from "./app-browser-visible-commit.js";
@@ -333,8 +333,12 @@ function createAppBrowserNavigationController(deps = {}) {
 			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));
 	}
 	/**
 	* Rendered before the route tree (see createAppRouteTree). Insertion effects
@@ -357,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) => {
@@ -370,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;
@@ -387,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) {
@@ -403,7 +408,6 @@ function createAppBrowserNavigationController(deps = {}) {
 				elements: options.restoredState.elements,
 				interception: options.restoredState.interception,
 				interceptionContext: options.restoredState.interceptionContext,
-				layoutFlags: options.restoredState.layoutFlags,
 				layoutIds: options.restoredState.layoutIds,
 				navigationSnapshot: options.restoredState.navigationSnapshot,
 				operation,
@@ -444,7 +448,7 @@ function createAppBrowserNavigationController(deps = {}) {
 		});
 		if (approval.approvedCommit === null) return false;
 		options.beforeCommit?.();
-		dispatchSynchronousVisibleCommit(approval.approvedCommit);
+		dispatchVisibleCommit(approval.approvedCommit);
 		return true;
 	}
 	function notifyDiscardedServerActionRevalidation(lifecycleOptions) {
@@ -462,7 +466,7 @@ 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;
@@ -566,12 +570,12 @@ function createAppBrowserNavigationController(deps = {}) {
 				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);
 				});
 			}, () => {});
@@ -634,7 +638,7 @@ function createAppBrowserNavigationController(deps = {}) {
 			if (latestApproval.approvedCommit) {
 				const approvedRevalidationCommit = latestApproval.approvedCommit;
 				startTransition(() => {
-					dispatchSynchronousVisibleCommit(approvedRevalidationCommit);
+					dispatchVisibleCommit(approvedRevalidationCommit);
 				});
 				syncHistoryStatePreviousNextUrl(approvedRevalidationCommit.previousNextUrl, approvedRevalidationCommit.action.bfcacheIds);
 			} else notifyDiscardedServerActionRevalidation(lifecycleOptions);

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-rsc-redirect.js

@@ -13,8 +13,7 @@ function toVisibleAppHref(href, origin) {
 	stripRscCacheBustingSearchParam(url);
 	return `${stripRscSuffix(url.pathname)}${url.search}${url.hash}`;
 }
-function toStreamedRedirectVisibleAppHref(href, origin) {
-	const url = new URL(href, origin);
+function toStreamedRedirectVisibleAppHref(url) {
 	return `${url.pathname}${url.search}${url.hash}`;
 }
 function resolveRedirectLifecycleHopFromTarget(options) {
@@ -53,10 +52,11 @@ function resolveRscRedirectLifecycleHop(options) {
 	});
 }
 function resolveStreamedRscRedirectLifecycleHop(options) {
-	const streamedRedirectUrl = new URL(options.streamedRedirectTarget, options.origin);
+	const requestedUrl = new URL(options.currentHref, options.origin);
+	const streamedRedirectUrl = new URL(options.streamedRedirectTarget, requestedUrl);
 	return resolveRedirectLifecycleHopFromTarget({
 		...options,
-		redirectedHref: toStreamedRedirectVisibleAppHref(options.streamedRedirectTarget, options.origin),
+		redirectedHref: toStreamedRedirectVisibleAppHref(streamedRedirectUrl),
 		targetUrl: streamedRedirectUrl
 	});
 }

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

@@ -21,6 +21,8 @@ type ActionRedirectTarget = {
 export type ClientServerActionDeps = {
   basePath: string;
   clearClientNavigationCaches(): void;
+  /** Evict only the cached navigation data that may be dynamic. */
+  clearDynamicClientNavigationCaches(): void;
   clientRscCompatibilityId: string | null;
   commitSameUrlNavigatePayload(elements: Promise<AppElements>, actionInitiation: ClientServerActionInitiation, returnValue: ServerActionResult["returnValue"] | undefined, revalidation: ServerActionRevalidationKind, renderedPathAndSearch: string | null): Promise<unknown>;
   navigationPlanner: typeof navigationPlanner;
@@ -30,4 +32,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-server-action-client.js

@@ -1,10 +1,10 @@
 import { hasBasePath } from "../utils/base-path.js";
 import { ACTION_REDIRECT_HEADER, ACTION_REDIRECT_STATUS_HEADER, VINEXT_RENDERED_PATH_AND_SEARCH_HEADER } from "./headers.js";
 import { DANGEROUS_URL_BLOCK_MESSAGE, isDangerousScheme } from "../shims/url-safety.js";
-import { AppElementsWire } from "./app-elements-wire.js";
-import "./app-elements.js";
 import { VINEXT_RSC_COMPATIBILITY_ID_HEADER, createServerActionRequestUrl } from "./app-rsc-cache-busting.js";
 import { throwOnServerActionNotFound } from "./server-action-not-found.js";
+import { AppElementsWire } from "./app-elements-wire.js";
+import "./app-elements.js";
 import { createServerActionResultFacts, isServerActionResult, normalizeServerActionThrownValue, parseServerActionRevalidationHeader, readInvalidServerActionResponseError, shouldClearClientNavigationCachesForServerActionResult, shouldSyncServerActionHttpFallbackHead } from "./app-browser-action-result.js";
 import { parseRenderedPathAndSearchHeader } from "../shims/navigation.js";
 import { resolveServerActionRequestState } from "./app-browser-state.js";
@@ -89,7 +89,8 @@ async function invokeClientServerAction(id, args, actionInitiation, deps) {
 	const actionResultDecision = deps.navigationPlanner.classifyServerActionResult(actionResultFacts);
 	if (applyServerActionResultDecision(actionResultDecision, () => deps.clearClientNavigationCaches(), (url, historyMode) => deps.performHardNavigation(url, historyMode))) return;
 	const revalidation = parseServerActionRevalidationHeader(fetchResponse.headers);
-	if (revalidation !== "none") deps.clearClientNavigationCaches();
+	if (revalidation === "staticAndDynamic") deps.clearClientNavigationCaches();
+	else if (revalidation === "dynamicOnly") deps.clearDynamicClientNavigationCaches();
 	const invalidResponseError = await readInvalidServerActionResponseError(fetchResponse.clone(), actionRedirectTarget !== null);
 	if (invalidResponseError) throw invalidResponseError;
 	if (actionRedirectTarget && !fetchResponseIsRsc) {

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

@@ -1,13 +1,13 @@
 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 { AppElements, AppElementsInterception, AppElementsSlotBinding } from "./app-elements-wire.js";
 import "./app-elements.js";
+import { ClientNavigationRenderSnapshot } from "../shims/navigation.js";
 import { NavigationTrace } from "./navigation-trace.js";
 import { OperationLane } from "./operation-token.js";
 import "./navigation-planner.js";
 import { BfcacheIdMap, HistoryTraversalIntent, createAppOwnedHistoryState, createExternalHistoryStatePreservingMetadata, createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, createHistoryStateWithTreeSnapshotId, isExternalHistoryState, isHistoryStateBfcacheVersionCurrent, readHistoryStateActiveRoutePaths, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveActiveRoutePaths, resolveHistoryTraversalIntent } from "./app-history-state.js";
 import { createBfcacheSegmentIdentityMap, createInitialBfcacheIdMap, createNextBfcacheIdMap, preserveBfcacheIdsForMergedElements } from "./app-bfcache-identity.js";
-import { ClientNavigationRenderSnapshot } from "../shims/navigation.js";
 //#region src/server/app-browser-state.d.ts
 type OperationRecordBase = {
   id: number;
@@ -30,7 +30,6 @@ export type AppRouterState = {
   elements: AppElements;
   interception: AppElementsInterception | null;
   interceptionContext: string | null;
-  layoutFlags: LayoutFlags;
   layoutIds: readonly string[];
   previousNextUrl: string | null;
   renderId: number;
@@ -46,7 +45,6 @@ export type AppRouterAction = {
   elements: AppElements;
   interception: AppElementsInterception | null;
   interceptionContext: string | null;
-  layoutFlags: LayoutFlags;
   layoutIds: readonly string[];
   navigationSnapshot: ClientNavigationRenderSnapshot;
   operation: PendingOperationRecord;

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

@@ -3,17 +3,18 @@ import { VINEXT_INTERCEPTION_CONTEXT_HEADER, VINEXT_MOUNTED_SLOTS_HEADER } from
 import { NEXT_ACTION_HEADER, RSC_ACTION_HEADER } from "./headers.js";
 import { normalizePathnameForRouteMatch } from "../routing/utils.js";
 import { normalizePath } from "./normalize-path.js";
+import { createRscRequestHeaders } from "./app-rsc-cache-busting.js";
 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 { 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";
 import { navigationPlanner, resolveDefaultOrUnmatchedSlotPersistenceForLayouts } from "./navigation-planner.js";
 import { createSnapshotPathAndSearch } from "../shims/navigation.js";
+import { holdsSkippedLayouts } from "./app-mounted-layouts.js";
+import { createCacheEntryReuseProof } from "./cache-proof.js";
+import { bindAppElementsRenderedSearch } from "../shims/slot.js";
 //#region src/server/app-browser-state.ts
 const COMMITTED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN = { origin: "committed-cache" };
 const FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN = { origin: "fresh" };
@@ -239,6 +240,11 @@ function mapNavigationDecisionToPendingDisposition(decision) {
 function mergeSkippedLayoutPreservation(options) {
 	if (options.decision.disposition !== "dispatch") return options.decision;
 	if (options.pending.skippedLayoutIds.length === 0) return options.decision;
+	if (!holdsSkippedLayouts(options.currentState, options.pending.action.elements)) return {
+		disposition: "hard-navigate",
+		preserveElementIds: [],
+		trace: options.decision.trace
+	};
 	const currentLayoutIds = new Set(options.currentState.layoutIds);
 	const targetLayoutIds = new Set(options.pending.action.layoutIds);
 	const preserveElementIds = [...options.decision.preserveElementIds];
@@ -303,7 +309,6 @@ function createPendingNavigationCommitFromElements(options) {
 			interception: metadata.interception,
 			interceptionContext: metadata.interceptionContext,
 			layoutIds: metadata.layoutIds,
-			layoutFlags: metadata.layoutFlags,
 			slotBindings: metadata.slotBindings,
 			navigationSnapshot: options.navigationSnapshot,
 			operation: createOperationRecord({

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-supplemental-refresh.js

@@ -1,8 +1,9 @@
 import { addBasePathToPathname, removeTrailingSlash, stripBasePath } from "../utils/base-path.js";
 import { normalizePathnameForRouteMatch } from "../routing/utils.js";
 import { normalizePath } from "./normalize-path.js";
-import { APP_INTERCEPTION_CONTEXT_KEY, APP_INTERCEPTION_KEY, APP_SLOT_BINDINGS_KEY, AppElementsWire, normalizeAppElementsSlotBindings } from "./app-elements-wire.js";
+import { APP_BFCACHE_SEGMENT_IDENTITIES_KEY, APP_INTERCEPTION_CONTEXT_KEY, APP_INTERCEPTION_KEY, APP_SLOT_BINDINGS_KEY, AppElementsWire, normalizeAppElementsSlotBindings } from "./app-elements-wire.js";
 import "./app-elements.js";
+import { isNestedBfcacheSlotSegmentIdFor } from "./bfcache-identity.js";
 //#region src/server/app-browser-supplemental-refresh.ts
 const SUPPLEMENTAL_REFRESH_TIMEOUT_MS = 1e4;
 var SupplementalRefreshError = class extends Error {
@@ -67,6 +68,7 @@ function mergeRefreshedParallelSlot(currentElements, refreshedElements) {
 				[APP_SLOT_BINDINGS_KEY]: normalizeAppElementsSlotBindings(slotBindings, { layoutIds: refreshedMetadata.layoutIds })
 			};
 			for (const binding of retainedBindings) merged[binding.slotId] = currentElements[binding.slotId];
+			copySlotIdentities(merged, refreshedElements, currentElements, retainedBindings.map((binding) => binding.slotId));
 			if (promotedBindings.length === 1) merged[promotedBindings[0].slotId] = refreshedElements[refreshedChildrenBindings[0].slotId];
 			copyRefreshedBranchElements(merged, currentElements, { overwrite: false });
 			return merged;
@@ -79,6 +81,7 @@ function mergeRefreshedParallelSlot(currentElements, refreshedElements) {
 			[APP_SLOT_BINDINGS_KEY]: normalizeAppElementsSlotBindings(slotBindings, { layoutIds: currentMetadata.layoutIds })
 		};
 		for (const binding of refreshedBindings) merged[binding.slotId] = refreshedElements[binding.slotId];
+		copySlotIdentities(merged, currentElements, refreshedElements, refreshedBindings.map((binding) => binding.slotId));
 		copyRefreshedBranchElements(merged, refreshedElements);
 		return merged;
 	}
@@ -93,9 +96,21 @@ function mergeRefreshedParallelSlot(currentElements, refreshedElements) {
 		[interception.slotId]: refreshedSlot,
 		[APP_SLOT_BINDINGS_KEY]: normalizeAppElementsSlotBindings(slotBindings, { layoutIds: currentMetadata.layoutIds })
 	};
+	copySlotIdentities(merged, currentElements, refreshedElements, [interception.slotId]);
 	copyRefreshedBranchElements(merged, refreshedElements);
 	return merged;
 }
+function copySlotIdentities(target, baseElements, slotElements, slotIds) {
+	const isSlotSegment = (id) => slotIds.some((slotId) => id === slotId || isNestedBfcacheSlotSegmentIdFor(id, slotId));
+	const isNestedSegment = (id) => !slotIds.includes(id) && isSlotSegment(id);
+	for (const id of Object.keys(baseElements)) if (isNestedSegment(id)) delete target[id];
+	for (const [id, element] of Object.entries(slotElements)) if (isNestedSegment(id)) target[id] = element;
+	const identities = {};
+	for (const [id, identity] of Object.entries(AppElementsWire.readMetadata(baseElements).bfcacheSegmentIdentities)) if (!isSlotSegment(id)) identities[id] = identity;
+	for (const [id, identity] of Object.entries(AppElementsWire.readMetadata(slotElements).bfcacheSegmentIdentities)) if (isSlotSegment(id)) identities[id] = identity;
+	if (Object.keys(identities).length > 0) target[APP_BFCACHE_SEGMENT_IDENTITIES_KEY] = identities;
+	else delete target[APP_BFCACHE_SEGMENT_IDENTITIES_KEY];
+}
 function copyRefreshedBranchElements(target, refreshedElements, options = {}) {
 	for (const [elementId, element] of Object.entries(refreshedElements)) {
 		const parsed = AppElementsWire.parseElementKey(elementId);

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

@@ -1,9 +1,9 @@
 import { BrowserRouteManifest } from "../routing/browser-route-manifest.js";
 import { AppElements } from "./app-elements-wire.js";
 import "./app-elements.js";
+import { ClientNavigationRenderSnapshot } from "../shims/navigation.js";
 import { NavigationTrace } from "./navigation-trace.js";
 import { OperationLane } from "./operation-token.js";
-import { ClientNavigationRenderSnapshot } from "../shims/navigation.js";
 import { AppNavigationPayloadOrigin, AppRouterAction, AppRouterState, PendingNavigationCommit } from "./app-browser-state.js";
 //#region src/server/app-browser-visible-commit.d.ts
 type VisibleCommitDecision = {
@@ -79,4 +79,5 @@ export declare function resolveAndClassifyNavigationCommit(options: {
   targetHref: string;
   type: "navigate" | "replace" | "traverse";
 }): Promise<ClassifiedPendingNavigationCommit>;
-//#endregion
+//#endregion
+export {};

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

@@ -1,10 +1,10 @@
 import { AppElementsWire, normalizeAppElementsSlotBindings } from "./app-elements-wire.js";
 import "./app-elements.js";
-import { mergeElements } from "../shims/slot.js";
-import { resolveAppPageRouteStateKey } from "./app-page-segment-state.js";
 import { createBfcacheSegmentIdentityMap, preserveBfcacheIdsForMergedElements } from "./app-bfcache-identity.js";
 import { NavigationTraceReasonCodes, NavigationTraceTransactionCodes, createNavigationTrace, prependNavigationTraceEntry } from "./navigation-trace.js";
+import { mergeElements } from "../shims/slot.js";
 import { createPendingNavigationCommit, resolvePendingNavigationCommitDispositionDecision } from "./app-browser-state.js";
+import { resolveAppPageRouteStateKey } from "./app-page-segment-state.js";
 //#region src/server/app-browser-visible-commit.ts
 const approvedVisibleCommitBrand = Symbol("ApprovedVisibleCommit");
 function hasSameServerTemplateSeedIdentity(id, currentSnapshot, nextSnapshot) {
@@ -105,7 +105,6 @@ function reduceApprovedVisibleCommitState(state, commit) {
 				elements: mergedElements,
 				interception: action.interception,
 				interceptionContext: action.interceptionContext,
-				layoutFlags: mergeLayoutFlags(state.layoutFlags, action.layoutFlags, preserveElementIds),
 				layoutIds: action.layoutIds,
 				navigationSnapshot: action.navigationSnapshot,
 				previousNextUrl: action.previousNextUrl,
@@ -145,15 +144,6 @@ function createVisibleCommitDecision(trace = createNavigationTrace(NavigationTra
 		trace
 	};
 }
-function mergeLayoutFlags(previousFlags, nextFlags, preserveElementIds) {
-	const merged = { ...nextFlags };
-	for (const id of preserveElementIds) {
-		if (Object.hasOwn(merged, id)) continue;
-		const value = previousFlags[id];
-		if (value) merged[id] = value;
-	}
-	return merged;
-}
 function createApprovedVisibleCommit(options) {
 	return {
 		[approvedVisibleCommitBrand]: true,

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,11 @@ 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
@@ -25,12 +29,28 @@ export type RouteClientReferences = {
   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. Undefined, meaning every reference, without a plan or a
- * route to look up, or for a pattern the plan doesn't know.
+ * 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): string[] | undefined;
+export declare function resolveRouteClientReferences(plan: RouteClientReferences | null, routePattern: string | null | undefined): RouteClientReferenceSet | undefined;
 export declare function createClientReferencePreloader(options: ClientReferencePreloaderOptions): ClientReferencePreloader;
-//#endregion
+//#endregion
+export {};

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

@@ -3,8 +3,9 @@ import { shareIsolatePromise } from "./isolate-shared-promise.js";
 const resolvedPreload = Promise.resolve();
 /**
 * The client references a render of `routePattern` preloads, or of no route
-* when it is null. Undefined, meaning every reference, without a plan or a
-* route to look up, or for a pattern the plan doesn't know.
+* 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.
 */
 function resolveRouteClientReferences(plan, routePattern) {
 	if (!plan || routePattern === void 0) return void 0;
@@ -14,7 +15,18 @@ function resolveRouteClientReferences(plan, routePattern) {
 	else return;
 	const indices = new Set(plan.always);
 	for (const file of files) for (const index of plan.files[file]) indices.add(index);
-	return Array.from(indices, (index) => plan.references[index]);
+	const asyncIndices = new Set(plan.async);
+	const references = [];
+	const streamed = [];
+	for (const index of indices) {
+		const id = plan.references[index];
+		references.push(id);
+		if (asyncIndices.has(index)) streamed.push(id);
+	}
+	return {
+		references,
+		streamed
+	};
 }
 function createClientReferencePreloader(options) {
 	let allReferencesPreloaded = false;
@@ -42,17 +54,20 @@ function createClientReferencePreloader(options) {
 		referencePreloadPromises.set(id, preloadPromise);
 		return preloadPromise;
 	}
-	function preloadReferenceSet(referenceIds, refs, clientRequire) {
+	function preloadReferenceSet(referenceIds, refs, clientRequire, streamedIds) {
 		const pending = [];
-		for (const id of referenceIds) if (Object.hasOwn(refs, id) && !preloadedReferences.has(id)) pending.push(preloadReference(id, clientRequire));
+		for (const id of referenceIds) if (Object.hasOwn(refs, id) && !preloadedReferences.has(id)) {
+			const loading = preloadReference(id, clientRequire);
+			if (!streamedIds?.has(id)) pending.push(loading);
+		}
 		if (pending.length === 0) return resolvedPreload;
 		return Promise.all(pending).then(() => {});
 	}
-	return { preload(referenceIds) {
+	return { preload(referenceIds, streamedIds) {
 		const refs = options.getReferences();
 		const clientRequire = options.getClientRequire();
 		if (!refs || !clientRequire) return resolvedPreload;
-		if (referenceIds) return preloadReferenceSet(referenceIds, refs, clientRequire);
+		if (referenceIds) return preloadReferenceSet(referenceIds, refs, clientRequire, streamedIds);
 		if (allReferencesPreloaded) return resolvedPreload;
 		if (allReferencesPreloadPromise) return allReferencesPreloadPromise;
 		allReferencesPreloadPromise = shareIsolatePromise(preloadReferenceSet(Object.keys(refs), refs, clientRequire).then(() => {