vinext 0.0.55 → 0.1.0

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

@@ -1,9 +1,9 @@
 import { RouteManifest } from "../routing/app-route-graph.js";
 import { AppRouterScrollIntent } from "../shims/app-router-scroll-state.js";
 import { ServerActionRevalidationKind } from "./app-browser-action-result.js";
-import { ClientNavigationRenderSnapshot, commitClientNavigationState } from "../shims/navigation.js";
 import { AppElements } from "./app-elements-wire.js";
 import { OperationLane } from "./navigation-planner.js";
+import { ClientNavigationRenderSnapshot, commitClientNavigationState } from "../shims/navigation.js";
 import { AppNavigationPayloadOrigin, AppRouterState } from "./app-browser-state.js";
 import { Dispatch, ReactNode } from "react";
 
@@ -17,6 +17,7 @@ type PendingBrowserRouterState = {
 type NavigationPayloadOutcome = "committed" | "no-commit" | "hard-navigate";
 type HardNavigationMode = "assign" | "replace";
 type BrowserNavigationCommitEffectFactory = (options: {
+  bfcacheIds: Readonly<Record<string, string>>;
   href: string;
   historyUpdateMode: HistoryUpdateMode | undefined;
   navId: number;
@@ -37,7 +38,7 @@ type BrowserNavigationControllerDeps = {
   commitClientNavigationState?: typeof commitClientNavigationState;
   performHardNavigation?: (href: string, mode?: HardNavigationMode) => boolean;
   getRouteManifest?: () => RouteManifest | null;
-  syncHistoryStatePreviousNextUrl?: (previousNextUrl: string | null) => void;
+  syncHistoryStatePreviousNextUrl?: (previousNextUrl: string | null, bfcacheIds?: Readonly<Record<string, string>> | null) => void;
 };
 type BrowserNavigationController = {
   beginNavigation(): number;
@@ -62,6 +63,7 @@ type BrowserNavigationController = {
     pendingRouterState: PendingBrowserRouterState | null;
     previousNextUrl: string | null;
     scrollIntent?: AppRouterScrollIntent | null;
+    restoredBfcacheIds?: Readonly<Record<string, string>> | null;
     targetHistoryIndex?: number | null;
     targetHref: string;
     navId: number;
@@ -91,5 +93,4 @@ type BrowserNavigationController = {
 declare function clearHardNavigationLoopGuard(): void;
 declare function createAppBrowserNavigationController(deps?: BrowserNavigationControllerDeps): BrowserNavigationController;
 //#endregion
-export { HistoryUpdateMode, NavigationPayloadOutcome, PendingBrowserRouterState, clearHardNavigationLoopGuard, createAppBrowserNavigationController };
-//# sourceMappingURL=app-browser-navigation-controller.d.ts.map
+export { HistoryUpdateMode, NavigationPayloadOutcome, PendingBrowserRouterState, clearHardNavigationLoopGuard, createAppBrowserNavigationController };

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

@@ -236,6 +236,7 @@ function createAppBrowserNavigationController(deps = {}) {
 				payloadOrigin: options.payloadOrigin,
 				previousNextUrl: options.previousNextUrl,
 				renderId,
+				restoredBfcacheIds: options.restoredBfcacheIds,
 				type: options.actionType
 			});
 			const approval = approvePendingNavigationCommit({
@@ -262,6 +263,7 @@ function createAppBrowserNavigationController(deps = {}) {
 			const approvedCommit = approval.approvedCommit;
 			if (approvedCommit === null) throw new Error("[vinext] Commit decision did not approve a visible commit");
 			queuePrePaintNavigationEffect(renderId, options.createNavigationCommitEffect({
+				bfcacheIds: approvedCommit.action.bfcacheIds,
 				href: options.targetHref,
 				historyUpdateMode: options.historyUpdateMode,
 				navId: options.navId,
@@ -321,7 +323,7 @@ function createAppBrowserNavigationController(deps = {}) {
 			}
 			if (latestApproval.approvedCommit) {
 				dispatchSynchronousVisibleCommit(latestApproval.approvedCommit);
-				syncHistoryStatePreviousNextUrl(latestApproval.approvedCommit.previousNextUrl);
+				syncHistoryStatePreviousNextUrl(latestApproval.approvedCommit.previousNextUrl, latestApproval.approvedCommit.action.bfcacheIds);
 			} else notifyDiscardedServerActionRevalidation(lifecycleOptions);
 		} else if (decision.disposition === "no-commit") notifyDiscardedServerActionRevalidation(lifecycleOptions);
 		if (returnValue) {
@@ -361,5 +363,3 @@ function createAppBrowserNavigationController(deps = {}) {
 }
 //#endregion
 export { clearHardNavigationLoopGuard, createAppBrowserNavigationController };
-
-//# sourceMappingURL=app-browser-navigation-controller.js.map

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

@@ -14,5 +14,4 @@ type BrowserPopstateRestoreDeps = {
 };
 declare function createPopstateRestoreHandler(deps: BrowserPopstateRestoreDeps): (event: PopStateEvent) => void;
 //#endregion
-export { createPopstateRestoreHandler };
-//# sourceMappingURL=app-browser-popstate.d.ts.map
+export { createPopstateRestoreHandler };

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

@@ -27,5 +27,3 @@ function createPopstateRestoreHandler(deps) {
 }
 //#endregion
 export { createPopstateRestoreHandler };
-
-//# sourceMappingURL=app-browser-popstate.js.map

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

@@ -25,5 +25,4 @@ declare function resolveRscRedirectLifecycleHop(options: {
   responseUrl: string;
 }): RscRedirectLifecycleDecision;
 //#endregion
-export { MAX_RSC_REDIRECT_DEPTH, resolveRscRedirectLifecycleHop };
-//# sourceMappingURL=app-browser-rsc-redirect.d.ts.map
+export { MAX_RSC_REDIRECT_DEPTH, resolveRscRedirectLifecycleHop };

package/dist/server/app-browser-rsc-redirect.js

@@ -33,5 +33,3 @@ function resolveRscRedirectLifecycleHop(options) {
 }
 //#endregion
 export { MAX_RSC_REDIRECT_DEPTH, resolveRscRedirectLifecycleHop };
-
-//# sourceMappingURL=app-browser-rsc-redirect.js.map

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

@@ -1,10 +1,10 @@
 import { RouteManifest } from "../routing/app-route-graph.js";
 import { CacheEntryReuseProof } from "./cache-proof.js";
-import { ClientNavigationRenderSnapshot } from "../shims/navigation.js";
 import { AppElements, AppElementsInterception, AppElementsSlotBinding, LayoutFlags } from "./app-elements-wire.js";
 import { NavigationTrace } from "./navigation-trace.js";
 import { OperationLane } from "./navigation-planner.js";
-import { HistoryTraversalIntent, createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent } from "./app-history-state.js";
+import { ClientNavigationRenderSnapshot } from "../shims/navigation.js";
+import { BfcacheIdMap, HistoryTraversalIntent, createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, isHistoryStateBfcacheVersionCurrent, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent } from "./app-history-state.js";
 
 //#region src/server/app-browser-state.d.ts
 type OperationRecordBase = {
@@ -22,6 +22,7 @@ type CommittedOperationRecord = OperationRecordBase & {
 type OperationRecord = PendingOperationRecord | CommittedOperationRecord;
 type AppRouterState = {
   activeOperation: OperationRecord | null;
+  bfcacheIds: BfcacheIdMap;
   elements: AppElements;
   interception: AppElementsInterception | null;
   interceptionContext: string | null;
@@ -36,6 +37,7 @@ type AppRouterState = {
   visibleCommitVersion: number;
 };
 type AppRouterAction = {
+  bfcacheIds: BfcacheIdMap;
   cacheEntryReuseProof?: CacheEntryReuseProof;
   elements: AppElements;
   interception: AppElementsInterception | null;
@@ -48,6 +50,7 @@ type AppRouterAction = {
   renderId: number;
   rootLayoutTreePath: string | null;
   routeId: string;
+  skippedLayoutIds: readonly string[];
   slotBindings: readonly AppElementsSlotBinding[];
   type: "navigate" | "replace" | "traverse";
 };
@@ -59,17 +62,20 @@ type PendingNavigationCommit = {
   previousNextUrl: string | null;
   rootLayoutTreePath: string | null;
   routeId: string;
+  skippedLayoutIds: readonly string[];
 };
 type AppNavigationPayloadOrigin = Readonly<{
   origin: "fresh";
 } | {
   origin: "visited-cache";
 }>;
+type BfcacheStateKeyMap = Readonly<Record<string, string>>;
 declare const FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN: AppNavigationPayloadOrigin;
 declare const VISITED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN: AppNavigationPayloadOrigin;
 type PendingNavigationCommitDisposition = "dispatch" | "hard-navigate" | "skip";
 type CacheRestorableAppPayloadMetadata = Readonly<{
   cacheEntryReuseProof?: CacheEntryReuseProof;
+  skippedLayoutIds: readonly string[];
 }>;
 type DispatchPendingNavigationCommitDispositionDecision = {
   disposition: "dispatch";
@@ -84,6 +90,24 @@ type NonDispatchPendingNavigationCommitDispositionDecision = {
   trace: NavigationTrace;
 };
 type PendingNavigationCommitDispositionDecision = DispatchPendingNavigationCommitDispositionDecision | NonDispatchPendingNavigationCommitDispositionDecision;
+declare function createInitialBfcacheIdMap(elements: AppElements): BfcacheIdMap;
+declare function createBfcacheSegmentStateKeyMap(options: {
+  elements: AppElements;
+  pathname: string;
+}): BfcacheStateKeyMap;
+declare function createNextBfcacheIdMap(options: {
+  current: BfcacheIdMap;
+  currentElements: AppElements;
+  currentPathname: string;
+  elements: AppElements;
+  nextPathname: string;
+  restored?: BfcacheIdMap | null;
+}): BfcacheIdMap;
+declare function preserveBfcacheIdsForMergedElements(options: {
+  elements: AppElements;
+  next: BfcacheIdMap;
+  previous: BfcacheIdMap;
+}): BfcacheIdMap;
 declare function isCacheRestorableAppPayloadMetadata(metadata: CacheRestorableAppPayloadMetadata): metadata is CacheRestorableAppPayloadMetadata & {
   cacheEntryReuseProof: CacheEntryReuseProof;
 };
@@ -125,8 +149,8 @@ declare function createPendingNavigationCommit(options: {
   payloadOrigin: AppNavigationPayloadOrigin;
   previousNextUrl?: string | null;
   renderId: number;
+  restoredBfcacheIds?: BfcacheIdMap | null;
   type: "navigate" | "replace" | "traverse";
 }): Promise<PendingNavigationCommit>;
 //#endregion
-export { AppNavigationPayloadOrigin, AppRouterAction, AppRouterState, CommittedOperationRecord, FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN, type HistoryTraversalIntent, type OperationLane, OperationRecord, PendingNavigationCommit, PendingOperationRecord, VISITED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN, createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, createPendingNavigationCommit, isCacheRestorableAppPayloadMetadata, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent, resolveInterceptionContextFromPreviousNextUrl, resolvePendingNavigationCommitDispositionDecision, resolveServerActionRequestState };
-//# sourceMappingURL=app-browser-state.d.ts.map
+export { AppNavigationPayloadOrigin, AppRouterAction, AppRouterState, type BfcacheIdMap, CommittedOperationRecord, FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN, type HistoryTraversalIntent, type OperationLane, PendingNavigationCommit, PendingOperationRecord, VISITED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN, createBfcacheSegmentStateKeyMap, createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, createInitialBfcacheIdMap, createNextBfcacheIdMap, createPendingNavigationCommit, isCacheRestorableAppPayloadMetadata, isHistoryStateBfcacheVersionCurrent, preserveBfcacheIdsForMergedElements, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent, resolveInterceptionContextFromPreviousNextUrl, resolvePendingNavigationCommitDispositionDecision, resolveServerActionRequestState };

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

@@ -1,17 +1,141 @@
-import { normalizePathnameForRouteMatch } from "../routing/utils.js";
+import { countConsumedPathnameSegments, isInvisibleSegment, normalizePathnameForRouteMatch, splitPathSegments } from "../routing/utils.js";
 import { stripBasePath } from "../utils/base-path.js";
 import { NEXT_ACTION_HEADER, RSC_ACTION_HEADER, VINEXT_INTERCEPTION_CONTEXT_HEADER, VINEXT_MOUNTED_SLOTS_HEADER } from "./headers.js";
 import { normalizePath } from "./normalize-path.js";
 import { AppElementsWire } from "./app-elements-wire.js";
 import { getMountedSlotIds, getMountedSlotIdsHeader } from "./app-elements.js";
-import { createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent } from "./app-history-state.js";
+import "./app-bfcache-id.js";
+import { createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, isBfcacheSegmentId, isHistoryStateBfcacheVersionCurrent, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent } from "./app-history-state.js";
 import { createRscRequestHeaders } from "./app-rsc-cache-busting.js";
-import { NavigationTraceReasonCodes, createNavigationLifecycleTraceFields, createNavigationTrace } from "./navigation-trace.js";
 import { createCacheEntryReuseProof } from "./cache-proof.js";
-import { navigationPlanner } from "./navigation-planner.js";
+import { NavigationTraceReasonCodes, createNavigationLifecycleTraceFields, createNavigationTrace } from "./navigation-trace.js";
+import { navigationPlanner, resolveDefaultOrUnmatchedSlotPersistenceForLayouts } from "./navigation-planner.js";
 //#region src/server/app-browser-state.ts
 const FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN = { origin: "fresh" };
 const VISITED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN = { origin: "visited-cache" };
+let nextBfcacheId = 0;
+function rememberBfcacheId(value) {
+	const match = /^_b_(\d+)_$/.exec(value);
+	if (!match) return;
+	nextBfcacheId = Math.max(nextBfcacheId, Number(match[1]));
+}
+function mintBfcacheId() {
+	nextBfcacheId += 1;
+	return `_b_${nextBfcacheId}_`;
+}
+function getVisibleTreePathSegments(treePath) {
+	return splitPathSegments(treePath).filter((segment) => !isInvisibleSegment(segment));
+}
+function getTreePathIdentityPrefix(pathname, treePath) {
+	const pathnameSegments = splitPathSegments(pathname);
+	const consumedPathnameSegments = countConsumedPathnameSegments(getVisibleTreePathSegments(treePath), pathnameSegments.length);
+	if (consumedPathnameSegments === 0) return "/";
+	return `/${pathnameSegments.slice(0, consumedPathnameSegments).join("/")}`;
+}
+function readAppElementsMetadata(elements) {
+	let metadata;
+	try {
+		metadata = AppElementsWire.readMetadata(elements);
+	} catch {
+		return null;
+	}
+	const slotBindingsBySlotId = /* @__PURE__ */ new Map();
+	for (const binding of metadata.slotBindings) slotBindingsBySlotId.set(binding.slotId, binding);
+	return {
+		metadata,
+		slotBindingsBySlotId
+	};
+}
+function createActiveSlotIdentity(id, parsed) {
+	const activeSlotBinding = parsed?.slotBindingsBySlotId.get(id);
+	if (activeSlotBinding?.activeRouteId != null) return `${id}@${activeSlotBinding.activeRouteId}`;
+	const interception = parsed?.metadata.interception;
+	if (interception?.slotId !== id) return null;
+	return `${id}@${interception.targetRouteId}`;
+}
+/**
+* Legacy bridge for deriving a bfcache segment identity from AppElements wire
+* keys. Keep wire-key parsing contained here until Vinext has a route-manifest
+* semantic authority equivalent to Next.js CacheNode/segment-cache state.
+*/
+function createBfcacheSegmentIdentity(id, options) {
+	const parsed = AppElementsWire.parseElementKey(id);
+	if (!parsed) return null;
+	if (parsed.kind === "page") return `${id}@${options.pathname}`;
+	if (parsed.kind === "slot") {
+		const activeSlotIdentity = createActiveSlotIdentity(id, options.metadata);
+		if (activeSlotIdentity !== null) return activeSlotIdentity;
+		return `${id}@${getTreePathIdentityPrefix(options.pathname, parsed.treePath)}`;
+	}
+	if (parsed.kind === "layout" || parsed.kind === "template") return `${id}@${getTreePathIdentityPrefix(options.pathname, parsed.treePath)}`;
+	return null;
+}
+function collectBfcacheSegmentIds(elements, parsed) {
+	const ids = new Set(Object.keys(elements));
+	const metadata = parsed === void 0 ? readAppElementsMetadata(elements) : parsed;
+	for (const layoutId of metadata?.metadata.layoutIds ?? []) ids.add(layoutId);
+	return Array.from(ids).filter(isBfcacheSegmentId);
+}
+function createInitialBfcacheIdMap(elements) {
+	const ids = {};
+	for (const id of collectBfcacheSegmentIds(elements)) ids[id] = "0";
+	return ids;
+}
+function normalizeBfcachePathname(pathname) {
+	const normalized = normalizePath(normalizePathnameForRouteMatch(pathname));
+	return normalized.length > 1 ? normalized.replace(/\/$/, "") : normalized;
+}
+function createBfcacheSegmentStateKeyMap(options) {
+	const metadata = readAppElementsMetadata(options.elements);
+	const normalizedPathname = normalizeBfcachePathname(options.pathname);
+	const stateKeys = {};
+	for (const id of collectBfcacheSegmentIds(options.elements, metadata)) {
+		const stateKey = createBfcacheSegmentIdentity(id, {
+			metadata,
+			pathname: normalizedPathname
+		});
+		if (stateKey !== null) stateKeys[id] = stateKey;
+	}
+	return stateKeys;
+}
+function createNextBfcacheIdMap(options) {
+	for (const value of Object.values(options.current)) rememberBfcacheId(value);
+	for (const value of Object.values(options.restored ?? {})) rememberBfcacheId(value);
+	const currentMetadata = readAppElementsMetadata(options.currentElements);
+	const nextMetadata = readAppElementsMetadata(options.elements);
+	const currentPathname = normalizeBfcachePathname(options.currentPathname);
+	const nextPathname = normalizeBfcachePathname(options.nextPathname);
+	const ids = {};
+	for (const id of collectBfcacheSegmentIds(options.elements, nextMetadata)) {
+		const currentValue = createBfcacheSegmentIdentity(id, {
+			metadata: currentMetadata,
+			pathname: currentPathname
+		}) === createBfcacheSegmentIdentity(id, {
+			metadata: nextMetadata,
+			pathname: nextPathname
+		}) ? options.current[id] : void 0;
+		const value = options.restored?.[id] ?? currentValue ?? mintBfcacheId();
+		ids[id] = value;
+		rememberBfcacheId(value);
+	}
+	return ids;
+}
+function preserveBfcacheIdsForMergedElements(options) {
+	const ids = {};
+	for (const id of collectBfcacheSegmentIds(options.elements)) {
+		const nextValue = options.next[id];
+		if (nextValue !== void 0) {
+			ids[id] = nextValue;
+			continue;
+		}
+		const previousValue = options.previous[id];
+		if (previousValue !== void 0) {
+			ids[id] = previousValue;
+			rememberBfcacheId(previousValue);
+		}
+	}
+	return ids;
+}
 function createOperationRecord(options) {
 	return {
 		id: options.id,
@@ -21,7 +145,7 @@ function createOperationRecord(options) {
 	};
 }
 function isCacheRestorableAppPayloadMetadata(metadata) {
-	return metadata.cacheEntryReuseProof !== void 0;
+	return metadata.cacheEntryReuseProof !== void 0 && metadata.skippedLayoutIds.length === 0;
 }
 function requiresCacheEntryReuseProof(origin) {
 	switch (origin.origin) {
@@ -71,13 +195,18 @@ function resolvePendingNavigationCommitDispositionDecision(options) {
 		preserveElementIds: [],
 		trace: createNavigationTrace(NavigationTraceReasonCodes.staleOperation, traceFields)
 	};
-	return mapNavigationDecisionToPendingDisposition(planPendingRootBoundaryFlightResponse({
+	const decision = mapNavigationDecisionToPendingDisposition(planPendingRootBoundaryFlightResponse({
 		currentState: options.currentState,
 		pending: options.pending,
 		routeManifest: options.routeManifest ?? null,
 		targetHref: options.targetHref,
 		traceFields
 	}));
+	return mergeSkippedLayoutPreservation({
+		currentState: options.currentState,
+		decision,
+		pending: options.pending
+	});
 }
 function createPendingNavigationTraceFields(options) {
 	return {
@@ -207,6 +336,52 @@ function mapNavigationDecisionToPendingDisposition(decision) {
 		default: throw new Error("[vinext] Unknown navigation decision: " + String(decision));
 	}
 }
+function mergeSkippedLayoutPreservation(options) {
+	if (options.decision.disposition !== "dispatch") return options.decision;
+	if (options.pending.skippedLayoutIds.length === 0) return options.decision;
+	const currentLayoutIds = new Set(options.currentState.layoutIds);
+	const targetLayoutIds = new Set(options.pending.action.layoutIds);
+	const preserveElementIds = [...options.decision.preserveElementIds];
+	const seenPreservedIds = new Set(preserveElementIds);
+	const newlyPreservedLayoutIds = [];
+	for (const id of options.pending.skippedLayoutIds) {
+		if (seenPreservedIds.has(id)) continue;
+		if (AppElementsWire.parseElementKey(id)?.kind !== "layout") continue;
+		if (!currentLayoutIds.has(id) || !targetLayoutIds.has(id)) continue;
+		if (!Object.hasOwn(options.currentState.elements, id)) continue;
+		preserveElementIds.push(id);
+		seenPreservedIds.add(id);
+		newlyPreservedLayoutIds.push(id);
+	}
+	if (newlyPreservedLayoutIds.length === 0) return options.decision;
+	const preservePreviousSlotIds = mergeSkippedLayoutSlotPreservation({
+		currentSlotBindings: options.currentState.slotBindings,
+		preservePreviousSlotIds: options.decision.preservePreviousSlotIds,
+		skippedLayoutIds: newlyPreservedLayoutIds,
+		targetSlotBindings: options.pending.action.slotBindings
+	});
+	return {
+		...options.decision,
+		preserveElementIds,
+		preservePreviousSlotIds
+	};
+}
+function mergeSkippedLayoutSlotPreservation(options) {
+	const ownedSlotIds = resolveDefaultOrUnmatchedSlotPersistenceForLayouts({
+		currentSlotBindings: options.currentSlotBindings,
+		preservedLayoutIds: options.skippedLayoutIds,
+		targetSlotBindings: options.targetSlotBindings
+	});
+	if (ownedSlotIds.length === 0) return options.preservePreviousSlotIds;
+	const preservePreviousSlotIds = [...options.preservePreviousSlotIds];
+	const seenSlotIds = new Set(preservePreviousSlotIds);
+	for (const slotId of ownedSlotIds) {
+		if (seenSlotIds.has(slotId)) continue;
+		preservePreviousSlotIds.push(slotId);
+		seenSlotIds.add(slotId);
+	}
+	return preservePreviousSlotIds;
+}
 async function createPendingNavigationCommit(options) {
 	const elements = await options.nextElements;
 	const metadata = AppElementsWire.readMetadata(elements);
@@ -215,6 +390,14 @@ async function createPendingNavigationCommit(options) {
 	const previousNextUrl = metadata.interception === null ? null : requestedPreviousNextUrl;
 	return {
 		action: {
+			bfcacheIds: createNextBfcacheIdMap({
+				current: options.currentState.bfcacheIds,
+				currentElements: options.currentState.elements,
+				currentPathname: options.currentState.navigationSnapshot.pathname,
+				elements,
+				nextPathname: options.navigationSnapshot.pathname,
+				restored: options.restoredBfcacheIds
+			}),
 			...cacheEntryReuseProof ? { cacheEntryReuseProof } : {},
 			elements,
 			interception: metadata.interception,
@@ -232,6 +415,7 @@ async function createPendingNavigationCommit(options) {
 			renderId: options.renderId,
 			rootLayoutTreePath: metadata.rootLayoutTreePath,
 			routeId: metadata.routeId,
+			skippedLayoutIds: metadata.skippedLayoutIds,
 			type: options.type
 		},
 		...cacheEntryReuseProof ? { cacheEntryReuseProof } : {},
@@ -239,10 +423,9 @@ async function createPendingNavigationCommit(options) {
 		interceptionContext: metadata.interceptionContext,
 		previousNextUrl,
 		rootLayoutTreePath: metadata.rootLayoutTreePath,
-		routeId: metadata.routeId
+		routeId: metadata.routeId,
+		skippedLayoutIds: metadata.skippedLayoutIds
 	};
 }
 //#endregion
-export { FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN, VISITED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN, createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, createPendingNavigationCommit, isCacheRestorableAppPayloadMetadata, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent, resolveInterceptionContextFromPreviousNextUrl, resolvePendingNavigationCommitDispositionDecision, resolveServerActionRequestState };
-
-//# sourceMappingURL=app-browser-state.js.map
+export { FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN, VISITED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN, createBfcacheSegmentStateKeyMap, createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, createInitialBfcacheIdMap, createNextBfcacheIdMap, createPendingNavigationCommit, isCacheRestorableAppPayloadMetadata, isHistoryStateBfcacheVersionCurrent, preserveBfcacheIdsForMergedElements, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent, resolveInterceptionContextFromPreviousNextUrl, resolvePendingNavigationCommitDispositionDecision, resolveServerActionRequestState };

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

@@ -25,5 +25,4 @@ declare function chunksToReadableStream(chunks: readonly RscEmbeddedChunk[]): Re
  */
 declare function createProgressiveRscStream(): ReadableStream<Uint8Array>;
 //#endregion
-export { chunksToReadableStream, createProgressiveRscStream, getVinextBrowserGlobal };
-//# sourceMappingURL=app-browser-stream.d.ts.map
+export { chunksToReadableStream, createProgressiveRscStream, getVinextBrowserGlobal };

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

@@ -77,5 +77,3 @@ function createProgressiveRscStream() {
 }
 //#endregion
 export { chunksToReadableStream, createProgressiveRscStream, getVinextBrowserGlobal };
-
-//# sourceMappingURL=app-browser-stream.js.map

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

@@ -1,8 +1,8 @@
 import { RouteManifest } from "../routing/app-route-graph.js";
-import { ClientNavigationRenderSnapshot } from "../shims/navigation.js";
 import { AppElements } from "./app-elements-wire.js";
 import { NavigationTrace } from "./navigation-trace.js";
 import { OperationLane } from "./navigation-planner.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
@@ -75,5 +75,4 @@ declare function resolveAndClassifyNavigationCommit(options: {
   type: "navigate" | "replace" | "traverse";
 }): Promise<ClassifiedPendingNavigationCommit>;
 //#endregion
-export { ApprovedVisibleCommit, applyApprovedVisibleCommit, approveHmrVisibleCommit, approvePendingNavigationCommit, resolveAndClassifyNavigationCommit };
-//# sourceMappingURL=app-browser-visible-commit.d.ts.map
+export { ApprovedVisibleCommit, applyApprovedVisibleCommit, approveHmrVisibleCommit, approvePendingNavigationCommit, resolveAndClassifyNavigationCommit };

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

@@ -2,7 +2,7 @@ import { normalizeAppElementsSlotBindings } from "./app-elements-wire.js";
 import "./app-elements.js";
 import { mergeElements } from "../shims/slot.js";
 import { NavigationTraceReasonCodes, NavigationTraceTransactionCodes, createNavigationTrace, prependNavigationTraceEntry } from "./navigation-trace.js";
-import { createPendingNavigationCommit, resolvePendingNavigationCommitDispositionDecision } from "./app-browser-state.js";
+import { createPendingNavigationCommit, preserveBfcacheIdsForMergedElements, resolvePendingNavigationCommitDispositionDecision } from "./app-browser-state.js";
 //#region src/server/app-browser-visible-commit.ts
 const approvedVisibleCommitBrand = Symbol("ApprovedVisibleCommit");
 function applyApprovedVisibleCommit(state, commit) {
@@ -55,25 +55,34 @@ function reduceApprovedVisibleCommitState(state, commit) {
 	const { action } = commit;
 	switch (action.type) {
 		case "traverse":
-		case "navigate": return commitVisibleRouterState(state, {
-			elements: mergeElements(state.elements, action.elements, {
+		case "navigate": {
+			const mergedElements = mergeElements(state.elements, action.elements, {
 				clearAbsentSlots: action.type === "traverse",
 				preserveAbsentSlots: commit.decision.preserveAbsentSlots,
 				preserveElementIds: commit.decision.preserveElementIds,
 				preservePreviousSlotIds: commit.decision.preservePreviousSlotIds
-			}),
-			interception: action.interception,
-			interceptionContext: action.interceptionContext,
-			layoutFlags: mergeLayoutFlags(state.layoutFlags, action.layoutFlags, commit.decision.preserveElementIds),
-			layoutIds: action.layoutIds,
-			navigationSnapshot: action.navigationSnapshot,
-			previousNextUrl: action.previousNextUrl,
-			renderId: action.renderId,
-			rootLayoutTreePath: action.rootLayoutTreePath,
-			routeId: action.routeId,
-			slotBindings: mergeSlotBindings(state.slotBindings, action.slotBindings, action.layoutIds, commit.decision.preservePreviousSlotIds)
-		}, action.operation);
+			});
+			return commitVisibleRouterState(state, {
+				bfcacheIds: preserveBfcacheIdsForMergedElements({
+					elements: mergedElements,
+					next: action.bfcacheIds,
+					previous: state.bfcacheIds
+				}),
+				elements: mergedElements,
+				interception: action.interception,
+				interceptionContext: action.interceptionContext,
+				layoutFlags: mergeLayoutFlags(state.layoutFlags, action.layoutFlags, commit.decision.preserveElementIds),
+				layoutIds: action.layoutIds,
+				navigationSnapshot: action.navigationSnapshot,
+				previousNextUrl: action.previousNextUrl,
+				renderId: action.renderId,
+				rootLayoutTreePath: action.rootLayoutTreePath,
+				routeId: action.routeId,
+				slotBindings: mergeSlotBindings(state.slotBindings, action.slotBindings, action.layoutIds, commit.decision.preservePreviousSlotIds)
+			}, action.operation);
+		}
 		case "replace": return commitVisibleRouterState(state, {
+			bfcacheIds: action.bfcacheIds,
 			elements: action.elements,
 			interception: action.interception,
 			interceptionContext: action.interceptionContext,
@@ -227,5 +236,3 @@ async function resolveAndClassifyNavigationCommit(options) {
 }
 //#endregion
 export { applyApprovedVisibleCommit, approveHmrVisibleCommit, approvePendingNavigationCommit, resolveAndClassifyNavigationCommit };
-
-//# sourceMappingURL=app-browser-visible-commit.js.map

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

@@ -11,5 +11,4 @@ type ClientReferencePreloader = {
 };
 declare function createClientReferencePreloader(options: ClientReferencePreloaderOptions): ClientReferencePreloader;
 //#endregion
-export { createClientReferencePreloader };
-//# sourceMappingURL=app-client-reference-preloader.d.ts.map
+export { createClientReferencePreloader };

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

@@ -42,5 +42,3 @@ function createClientReferencePreloader(options) {
 }
 //#endregion
 export { createClientReferencePreloader };
-
-//# sourceMappingURL=app-client-reference-preloader.js.map