vinext 0.0.55 → 0.1.1

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

@@ -3,5 +3,4 @@ declare function createOnUncaughtError(getRecoveryHref: () => string | null): (e
   componentStack?: string;
 }) => void;
 //#endregion
-export { createOnUncaughtError };
-//# sourceMappingURL=app-browser-error.d.ts.map
+export { createOnUncaughtError };

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

@@ -9,5 +9,3 @@ function createOnUncaughtError(getRecoveryHref) {
 }
 //#endregion
 export { createOnUncaughtError };
-
-//# sourceMappingURL=app-browser-error.js.map

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

@@ -27,5 +27,4 @@ declare function hydrateRootInTransition(options: {
   startTransition: StartTransition;
 }): HydrateRootReturn;
 //#endregion
-export { RSC_FORM_STATE_GLOBAL, consumeInitialFormState, createVinextHydrateRootOptions, hydrateRootInTransition };
-//# sourceMappingURL=app-browser-hydration.d.ts.map
+export { RSC_FORM_STATE_GLOBAL, consumeInitialFormState, createVinextHydrateRootOptions, hydrateRootInTransition };

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

@@ -26,5 +26,3 @@ function hydrateRootInTransition(options) {
 }
 //#endregion
 export { RSC_FORM_STATE_GLOBAL, consumeInitialFormState, createVinextHydrateRootOptions, hydrateRootInTransition };
-
-//# sourceMappingURL=app-browser-hydration.js.map

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

@@ -19,6 +19,6 @@ type ResolveManifestNavigationInterceptionContextOptions = {
  * is owned by the deterministic route graph builder.
  */
 declare function resolveManifestNavigationInterceptionContext(options: ResolveManifestNavigationInterceptionContextOptions): string | null;
+declare function resolveMiddlewareRewriteNavigationInterceptionContext(options: ResolveManifestNavigationInterceptionContextOptions): string | null;
 //#endregion
-export { resolveManifestNavigationInterceptionContext };
-//# sourceMappingURL=app-browser-interception-context.d.ts.map
+export { resolveManifestNavigationInterceptionContext, resolveMiddlewareRewriteNavigationInterceptionContext };

package/dist/server/app-browser-interception-context.js

@@ -1,6 +1,6 @@
 import { splitPathnameForRouteMatch } from "../routing/utils.js";
 import { stripBasePath } from "../utils/base-path.js";
-import { matchRoutePattern, matchRoutePatternPrefix } from "../routing/route-pattern.js";
+import { matchRoutePattern, matchRoutePatternPrefix, matchRoutePatternWithOptionalDynamicSegments } from "../routing/route-pattern.js";
 //#region src/server/app-browser-interception-context.ts
 /**
 * Resolve the first-hop interception context from declared route topology.
@@ -26,7 +26,18 @@ function resolveManifestNavigationInterceptionContext(options) {
 	}
 	return null;
 }
+function resolveMiddlewareRewriteNavigationInterceptionContext(options) {
+	if (options.routeManifest === null) return null;
+	const currentPathname = stripBasePath(options.currentPathname, options.basePath);
+	const targetPathname = stripBasePath(options.targetPathname, options.basePath);
+	const sourceParts = splitPathnameForRouteMatch(currentPathname);
+	const targetParts = splitPathnameForRouteMatch(targetPathname);
+	for (const interception of options.routeManifest.segmentGraph.interceptions.values()) {
+		if (!matchRoutePatternPrefix(sourceParts, interception.sourcePatternParts)) continue;
+		if (!matchRoutePatternWithOptionalDynamicSegments(targetParts, interception.targetPatternParts)) continue;
+		return currentPathname;
+	}
+	return null;
+}
 //#endregion
-export { resolveManifestNavigationInterceptionContext };
-
-//# sourceMappingURL=app-browser-interception-context.js.map
+export { resolveManifestNavigationInterceptionContext, resolveMiddlewareRewriteNavigationInterceptionContext };

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

@@ -6,11 +6,11 @@ type AppBrowserMpaNavigationWindow = {
   requestAnimationFrame?: (callback: FrameRequestCallback) => unknown;
   setTimeout(callback: () => void, timeout: number): unknown;
 };
+declare function hasPendingAppRouterPageRedirect(targetDocument: unknown): boolean;
 declare class AppBrowserMpaNavigationScheduler {
   #private;
   reset(): void;
   navigate(targetWindow: AppBrowserMpaNavigationWindow, href: string, historyUpdateMode: HistoryUpdateMode): void;
 }
 //#endregion
-export { AppBrowserMpaNavigationScheduler, AppBrowserMpaNavigationWindow };
-//# sourceMappingURL=app-browser-mpa-navigation.d.ts.map
+export { AppBrowserMpaNavigationScheduler, AppBrowserMpaNavigationWindow, hasPendingAppRouterPageRedirect };

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

@@ -1,4 +1,12 @@
 //#region src/server/app-browser-mpa-navigation.ts
+const NEXT_APP_ROUTER_PAGE_REDIRECT_MARKER_ID = "__next-page-redirect";
+function hasPendingAppRouterPageRedirect(targetDocument) {
+	if (typeof targetDocument !== "object" || targetDocument === null) return false;
+	if (!("getElementById" in targetDocument)) return false;
+	const { getElementById } = targetDocument;
+	if (typeof getElementById !== "function") return false;
+	return getElementById.call(targetDocument, NEXT_APP_ROUTER_PAGE_REDIRECT_MARKER_ID) !== null;
+}
 var AppBrowserMpaNavigationScheduler = class {
 	#pendingNavigation = null;
 	#nextToken = 0;
@@ -31,6 +39,4 @@ var AppBrowserMpaNavigationScheduler = class {
 	}
 };
 //#endregion
-export { AppBrowserMpaNavigationScheduler };
-
-//# sourceMappingURL=app-browser-mpa-navigation.js.map
+export { AppBrowserMpaNavigationScheduler, hasPendingAppRouterPageRedirect };

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;
@@ -34,10 +35,11 @@ type SameUrlServerActionLifecycleOptions = {
   targetHref?: string;
 };
 type BrowserNavigationControllerDeps = {
+  basePath?: string;
   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;
@@ -50,6 +52,12 @@ type BrowserNavigationController = {
   attachBrowserRouterState(setter: Dispatch<AppRouterState | Promise<AppRouterState>>, stateRef: BrowserRouterStateRef): () => void;
   beginPendingBrowserRouterState(): PendingBrowserRouterState;
   finalizeNavigation(navId: number, pending: PendingBrowserRouterState | null | undefined): void;
+  restoreHistorySnapshotVisibleState(options: {
+    beforeCommit?: () => void;
+    navId: number;
+    state: AppRouterState;
+    targetHref: string;
+  }): boolean;
   renderNavigationPayload(options: {
     actionType: "navigate" | "replace" | "traverse";
     createNavigationCommitEffect: BrowserNavigationCommitEffectFactory;
@@ -62,6 +70,8 @@ type BrowserNavigationController = {
     pendingRouterState: PendingBrowserRouterState | null;
     previousNextUrl: string | null;
     scrollIntent?: AppRouterScrollIntent | null;
+    restoredBfcacheIds?: Readonly<Record<string, string>> | null;
+    reuseCurrentBfcacheIds?: boolean;
     targetHistoryIndex?: number | null;
     targetHref: string;
     navId: number;
@@ -89,7 +99,8 @@ type BrowserNavigationController = {
   }): ReactNode;
 };
 declare function clearHardNavigationLoopGuard(): void;
+declare function createSnapshotPathAndSearch(snapshot: ClientNavigationRenderSnapshot): string;
+declare function createBasePathStrippedPathAndSearch(url: URL, basePath: string): string;
 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, createBasePathStrippedPathAndSearch, createSnapshotPathAndSearch };

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

@@ -1,3 +1,4 @@
+import { stripBasePath } from "../utils/base-path.js";
 import { claimAppRouterScrollIntentForCommit, consumeAppRouterScrollIntent } from "../shims/app-router-scroll-state.js";
 import { activateNavigationSnapshot, clearPendingPathname, commitClientNavigationState } from "../shims/navigation.js";
 import { shouldScheduleRefreshForDiscardedServerAction } from "./app-browser-action-result.js";
@@ -49,7 +50,25 @@ function performHardNavigationWithLoopGuard(href, mode = "assign") {
 	else window.location.assign(href);
 	return true;
 }
+function createSnapshotPathAndSearch(snapshot) {
+	const query = snapshot.searchParams.toString();
+	return query === "" ? snapshot.pathname : `${snapshot.pathname}?${query}`;
+}
+function createBasePathStrippedPathAndSearch(url, basePath) {
+	const pathname = stripBasePath(url.pathname, basePath);
+	const query = new URLSearchParams(url.search).toString();
+	return query === "" ? pathname : `${pathname}?${query}`;
+}
+function isSnapshotTargetHref(basePath, snapshot, targetHref) {
+	try {
+		const baseHref = typeof window === "undefined" ? "http://localhost" : window.location.href;
+		return createBasePathStrippedPathAndSearch(new URL(targetHref, baseHref), basePath) === createSnapshotPathAndSearch(snapshot);
+	} catch {
+		return false;
+	}
+}
 function createAppBrowserNavigationController(deps = {}) {
+	const basePath = deps.basePath ?? "";
 	const commitClientNavigationStateImpl = deps.commitClientNavigationState ?? commitClientNavigationState;
 	const performHardNavigation = deps.performHardNavigation ?? performHardNavigationWithLoopGuard;
 	const getRouteManifest = deps.getRouteManifest ?? (() => null);
@@ -215,6 +234,61 @@ function createAppBrowserNavigationController(deps = {}) {
 	function dispatchSynchronousVisibleCommit(commit) {
 		getBrowserRouterStateSetter()(applyApprovedVisibleCommit(getBrowserRouterState(), commit));
 	}
+	function createRestoredHistorySnapshotCommit(options) {
+		const operation = {
+			id: options.renderId,
+			lane: "traverse",
+			startedVisibleCommitVersion: options.currentState.visibleCommitVersion,
+			state: "pending"
+		};
+		return {
+			action: {
+				bfcacheIds: options.restoredState.bfcacheIds,
+				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,
+				previousNextUrl: options.restoredState.previousNextUrl,
+				renderId: options.renderId,
+				rootLayoutTreePath: options.restoredState.rootLayoutTreePath,
+				reuseCurrentBfcacheIds: false,
+				routeId: options.restoredState.routeId,
+				skippedLayoutIds: [],
+				slotBindings: options.restoredState.slotBindings,
+				type: "traverse"
+			},
+			interception: options.restoredState.interception,
+			interceptionContext: options.restoredState.interceptionContext,
+			previousNextUrl: options.restoredState.previousNextUrl,
+			rootLayoutTreePath: options.restoredState.rootLayoutTreePath,
+			routeId: options.restoredState.routeId,
+			skippedLayoutIds: []
+		};
+	}
+	function restoreHistorySnapshotVisibleState(options) {
+		if (!isSnapshotTargetHref(basePath, options.state.navigationSnapshot, options.targetHref)) return false;
+		const currentState = getBrowserRouterState();
+		const pending = createRestoredHistorySnapshotCommit({
+			currentState,
+			renderId: allocateRenderId(),
+			restoredState: options.state
+		});
+		const approval = approvePendingNavigationCommit({
+			activeNavigationId,
+			currentState,
+			pending,
+			routeManifest: getRouteManifest(),
+			startedNavigationId: options.navId,
+			targetHref: options.targetHref
+		});
+		if (approval.approvedCommit === null) return false;
+		options.beforeCommit?.();
+		dispatchSynchronousVisibleCommit(approval.approvedCommit);
+		return true;
+	}
 	function notifyDiscardedServerActionRevalidation(lifecycleOptions) {
 		if (!shouldScheduleRefreshForDiscardedServerAction(lifecycleOptions?.revalidation ?? "none")) return;
 		lifecycleOptions?.onDiscardedRevalidation?.();
@@ -236,6 +310,8 @@ function createAppBrowserNavigationController(deps = {}) {
 				payloadOrigin: options.payloadOrigin,
 				previousNextUrl: options.previousNextUrl,
 				renderId,
+				restoredBfcacheIds: options.restoredBfcacheIds,
+				reuseCurrentBfcacheIds: options.reuseCurrentBfcacheIds,
 				type: options.actionType
 			});
 			const approval = approvePendingNavigationCommit({
@@ -262,6 +338,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 +398,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) {
@@ -352,6 +429,7 @@ function createAppBrowserNavigationController(deps = {}) {
 		attachBrowserRouterState,
 		beginPendingBrowserRouterState,
 		finalizeNavigation,
+		restoreHistorySnapshotVisibleState,
 		renderNavigationPayload,
 		commitSameUrlNavigatePayload,
 		hmrReplaceTree,
@@ -360,6 +438,4 @@ function createAppBrowserNavigationController(deps = {}) {
 	};
 }
 //#endregion
-export { clearHardNavigationLoopGuard, createAppBrowserNavigationController };
-
-//# sourceMappingURL=app-browser-navigation-controller.js.map
+export { clearHardNavigationLoopGuard, createAppBrowserNavigationController, createBasePathStrippedPathAndSearch, createSnapshotPathAndSearch };

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

@@ -1,18 +1,26 @@
+import { NavigationRuntimeNavigate } from "../client/navigation-runtime.js";
+
 //#region src/server/app-browser-popstate.d.ts
 type RestoreScrollPosition = (state: unknown, options?: {
   shouldContinue?: () => boolean;
 }) => void;
-type NavigateRsc = (href: string, redirectDepth?: number, navigationKind?: "navigate" | "traverse" | "refresh") => Promise<void>;
 type BrowserPopstateRestoreDeps = {
   getActiveNavigationId: () => number;
   getPendingNavigation: () => Promise<void> | null | undefined;
-  getNavigate: () => NavigateRsc | undefined;
+  getNavigate: () => NavigationRuntimeNavigate | undefined;
   isCurrentNavigation: (navId: number) => boolean;
   notifyAppRouterTransitionStart: (href: string) => void;
   restorePopstateScrollPosition: RestoreScrollPosition;
   setPendingNavigation: (pendingNavigation: Promise<void> | null) => void;
+  shouldSkipScrollRestore: (navId: number) => boolean;
 };
+type SynchronousPopstateScrollRestoreDeps = {
+  getActiveNavigationId: () => number;
+  isCurrentNavigation: (navId: number) => boolean;
+  markScrollRestoreConsumed: (navId: number) => void;
+  restorePopstateScrollPosition: RestoreScrollPosition;
+};
+declare function restoreSynchronousPopstateScrollPosition(deps: SynchronousPopstateScrollRestoreDeps, state: unknown): void;
 declare function createPopstateRestoreHandler(deps: BrowserPopstateRestoreDeps): (event: PopStateEvent) => void;
 //#endregion
-export { createPopstateRestoreHandler };
-//# sourceMappingURL=app-browser-popstate.d.ts.map
+export { createPopstateRestoreHandler, restoreSynchronousPopstateScrollPosition };

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

@@ -1,7 +1,14 @@
+import { readHistoryStateTraversalIndex } from "./app-history-state.js";
+import "./app-browser-state.js";
 //#region src/server/app-browser-popstate.ts
 function hasSavedScrollPosition(state) {
 	return Boolean(state && typeof state === "object" && "__vinext_scrollY" in state);
 }
+function restoreSynchronousPopstateScrollPosition(deps, state) {
+	const navId = deps.getActiveNavigationId();
+	deps.markScrollRestoreConsumed(navId);
+	deps.restorePopstateScrollPosition(state, { shouldContinue: () => deps.isCurrentNavigation(navId) });
+}
 function scheduleAfterFrame(callback) {
 	if (typeof window !== "undefined" && typeof window.requestAnimationFrame === "function") {
 		window.requestAnimationFrame(callback);
@@ -9,23 +16,29 @@ function scheduleAfterFrame(callback) {
 	}
 	queueMicrotask(callback);
 }
+function createPopstateTraversalIntent(historyState) {
+	return {
+		direction: "unknown",
+		historyState,
+		targetHistoryIndex: readHistoryStateTraversalIndex(historyState)
+	};
+}
 function createPopstateRestoreHandler(deps) {
 	return (event) => {
 		deps.notifyAppRouterTransitionStart(window.location.href);
-		const pendingNavigation = deps.getNavigate()?.(window.location.href, 0, "traverse") ?? Promise.resolve();
+		const pendingNavigation = deps.getNavigate()?.(window.location.href, 0, "traverse", void 0, void 0, false, createPopstateTraversalIntent(event.state)) ?? Promise.resolve();
 		const popstateNavId = deps.getActiveNavigationId();
 		deps.setPendingNavigation(pendingNavigation);
 		const shouldRestoreSavedScroll = hasSavedScrollPosition(event.state);
+		const shouldRestoreScrollForNavigation = () => deps.isCurrentNavigation(popstateNavId) && !deps.shouldSkipScrollRestore(popstateNavId);
 		if (shouldRestoreSavedScroll) scheduleAfterFrame(() => {
-			if (deps.isCurrentNavigation(popstateNavId)) deps.restorePopstateScrollPosition(event.state, { shouldContinue: () => deps.isCurrentNavigation(popstateNavId) });
+			if (shouldRestoreScrollForNavigation()) deps.restorePopstateScrollPosition(event.state, { shouldContinue: shouldRestoreScrollForNavigation });
 		});
 		pendingNavigation.finally(() => {
-			if (deps.isCurrentNavigation(popstateNavId) && !shouldRestoreSavedScroll) deps.restorePopstateScrollPosition(event.state);
+			if (shouldRestoreScrollForNavigation() && !shouldRestoreSavedScroll) deps.restorePopstateScrollPosition(event.state);
 			if (deps.getPendingNavigation() === pendingNavigation) deps.setPendingNavigation(null);
 		});
 	};
 }
 //#endregion
-export { createPopstateRestoreHandler };
-
-//# sourceMappingURL=app-browser-popstate.js.map
+export { createPopstateRestoreHandler, restoreSynchronousPopstateScrollPosition };

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;
@@ -47,7 +49,9 @@ type AppRouterAction = {
   previousNextUrl: string | null;
   renderId: number;
   rootLayoutTreePath: string | null;
+  reuseCurrentBfcacheIds: boolean;
   routeId: string;
+  skippedLayoutIds: readonly string[];
   slotBindings: readonly AppElementsSlotBinding[];
   type: "navigate" | "replace" | "traverse";
 };
@@ -59,17 +63,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 +91,25 @@ 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;
+  reuseCurrent?: boolean;
+}): BfcacheIdMap;
+declare function preserveBfcacheIdsForMergedElements(options: {
+  elements: AppElements;
+  next: BfcacheIdMap;
+  previous: BfcacheIdMap;
+}): BfcacheIdMap;
 declare function isCacheRestorableAppPayloadMetadata(metadata: CacheRestorableAppPayloadMetadata): metadata is CacheRestorableAppPayloadMetadata & {
   cacheEntryReuseProof: CacheEntryReuseProof;
 };
@@ -125,8 +151,9 @@ declare function createPendingNavigationCommit(options: {
   payloadOrigin: AppNavigationPayloadOrigin;
   previousNextUrl?: string | null;
   renderId: number;
+  restoredBfcacheIds?: BfcacheIdMap | null;
+  reuseCurrentBfcacheIds?: boolean;
   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 };