vinext 1.3.1 → 1.4.1

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

@@ -31,6 +31,7 @@ var AppBrowserHistoryController = class {
 	#treeSnapshots = /* @__PURE__ */ new Map();
 	#treeSnapshotClaimCounts = /* @__PURE__ */ new Map();
 	#treeSnapshotClaimByHistoryIndex = /* @__PURE__ */ new Map();
+	#treeSnapshotIdPrefix = createDocumentTreeSnapshotIdPrefix();
 	#readHistoryState;
 	#readCurrentHref;
 	#pushHistoryState;
@@ -41,6 +42,9 @@ var AppBrowserHistoryController = class {
 	#currentTreeSnapshotId = null;
 	#nextTreeSnapshotId = 0;
 	#treeSnapshotIdPendingFreshState = null;
+	#historyIndicesAwaitingTreeSnapshot = /* @__PURE__ */ new Set();
+	#treeSnapshotPending = true;
+	#historyIndexAwaitingTreeClaim = null;
 	constructor(deps) {
 		this.#readHistoryState = deps.readHistoryState;
 		this.#readCurrentHref = deps.readCurrentHref;
@@ -99,18 +103,29 @@ var AppBrowserHistoryController = class {
 		const previousState = this.readCurrentTreeSnapshot();
 		const previousOperation = previousState?.activeOperation;
 		if (previousState && previousOperation?.navigationCommitKind === "detached" && state.activeOperation?.navigationCommitKind === "authoritative" && state.activeOperation.navigationId === previousOperation.navigationId) this.#restorableClientState.replaceHistoryStateSnapshots(previousState, state);
+		for (const historyIndex of this.#historyIndicesAwaitingTreeSnapshot) this.#restorableClientState.rememberHistoryStateSnapshot({
+			historyIndex,
+			state
+		});
+		this.#historyIndicesAwaitingTreeSnapshot.clear();
 		this.#restorableClientState.rememberHistoryStateSnapshot({
 			historyIndex: this.#currentHistoryTraversalIndex,
 			state
 		});
+		this.#treeSnapshotPending = false;
 		const historyTreeSnapshotId = readHistoryStateTreeSnapshotId(this.#readHistoryState());
-		const treeSnapshotId = historyTreeSnapshotId !== null && this.#treeSnapshots.has(historyTreeSnapshotId) && (historyTreeSnapshotId === this.#treeSnapshotIdPendingFreshState || this.#treeSnapshotClaimCounts.has(historyTreeSnapshotId)) ? historyTreeSnapshotId : this.#nextTreeSnapshotId++;
+		const treeSnapshotId = historyTreeSnapshotId !== null && this.#treeSnapshots.has(historyTreeSnapshotId) && (historyTreeSnapshotId === this.#treeSnapshotIdPendingFreshState || this.#treeSnapshotClaimCounts.has(historyTreeSnapshotId)) ? historyTreeSnapshotId : `${this.#treeSnapshotIdPrefix}:${this.#nextTreeSnapshotId++}`;
 		this.#treeSnapshotIdPendingFreshState = null;
 		const previousTreeSnapshotId = this.#currentTreeSnapshotId;
 		this.#currentTreeSnapshotId = treeSnapshotId;
 		this.#treeSnapshots.set(treeSnapshotId, state);
+		const claimingHistoryIndex = this.#historyIndexAwaitingTreeClaim;
+		this.#historyIndexAwaitingTreeClaim = null;
+		const claimsTree = claimingHistoryIndex !== null && claimingHistoryIndex === this.#currentHistoryTraversalIndex && claimingHistoryIndex === readHistoryStateTraversalIndex(this.#readHistoryState());
+		if (claimsTree) this.#claimTreeSnapshotAtHistoryIndex(claimingHistoryIndex, treeSnapshotId);
 		if (previousTreeSnapshotId !== null && previousTreeSnapshotId !== treeSnapshotId && !this.#treeSnapshotClaimCounts.has(previousTreeSnapshotId)) this.#treeSnapshots.delete(previousTreeSnapshotId);
-		if (historyTreeSnapshotId !== treeSnapshotId) this.#replaceHistoryState(createHistoryStateWithTreeSnapshotId(this.#readHistoryState(), treeSnapshotId));
+		if (claimsTree) this.#replaceHistoryState(createHistoryStateWithTreeSnapshotClaim(createHistoryStateWithTreeSnapshotId(this.#readHistoryState(), treeSnapshotId), true));
+		else if (historyTreeSnapshotId !== treeSnapshotId) this.#replaceHistoryState(createHistoryStateWithTreeSnapshotId(this.#readHistoryState(), treeSnapshotId));
 	}
 	/** The router state of the most recently committed render, if any. */
 	readCurrentTreeSnapshot() {
@@ -125,7 +140,21 @@ var AppBrowserHistoryController = class {
 	claimCurrentHistoryTreeSnapshot(historyUpdateMode, previousHistoryState) {
 		let historyState = this.#readHistoryState();
 		const treeSnapshotId = readHistoryStateTreeSnapshotId(historyState);
-		if (treeSnapshotId === null || !this.#treeSnapshots.has(treeSnapshotId)) return;
+		if (treeSnapshotId === null || !this.#treeSnapshots.has(treeSnapshotId)) {
+			if (historyUpdateMode === "push") {
+				const previousHistoryIndex = readHistoryStateTraversalIndex(previousHistoryState);
+				if (previousHistoryIndex !== null && this.#treeSnapshotPending) this.#historyIndicesAwaitingTreeSnapshot.add(previousHistoryIndex);
+				this.#releaseForwardTreeSnapshotClaims();
+				const historyIndex = this.#nextHistoryTraversalIndex + 1;
+				this.#replaceHistoryState(createHistoryStateWithNavigationMetadata(historyState, {
+					previousNextUrl: readHistoryStatePreviousNextUrl(historyState),
+					traversalIndex: historyIndex
+				}));
+				this.commitHistoryTraversalIndex(historyIndex);
+				this.#historyIndexAwaitingTreeClaim = this.#treeSnapshotPending ? historyIndex : null;
+			}
+			return;
+		}
 		let historyIndex;
 		if (historyUpdateMode === "push") {
 			this.#releaseForwardTreeSnapshotClaims();
@@ -185,7 +214,6 @@ var AppBrowserHistoryController = class {
 		if (treeSnapshotId !== this.#currentTreeSnapshotId) this.#treeSnapshots.delete(treeSnapshotId);
 	}
 	commitHashOnlyNavigation(href, historyUpdateMode, scroll) {
-		if (historyUpdateMode === "push") this.#releaseForwardTreeSnapshotClaims();
 		const navigationHistoryIndex = this.allocateNavigationHistoryTraversalIndex(historyUpdateMode);
 		const historyState = this.#readHistoryState();
 		const visible = this.#readVisibleNavigationMetadata();
@@ -199,11 +227,59 @@ var AppBrowserHistoryController = class {
 			previousNextUrl,
 			traversalIndex: navigationHistoryIndex
 		}), true);
-		if (historyUpdateMode === "replace") this.#replaceHistoryState(nextHistoryState, href);
-		else this.#pushHistoryState(nextHistoryState, href);
+		const historyIndex = this.#writeNavigationHistoryState(historyUpdateMode, nextHistoryState, href, navigationHistoryIndex, false);
 		const treeSnapshotId = readHistoryStateTreeSnapshotId(nextHistoryState);
-		if (navigationHistoryIndex !== null && treeSnapshotId !== null) this.#claimTreeSnapshotAtHistoryIndex(navigationHistoryIndex, treeSnapshotId);
-		this.commitHistoryTraversalIndex(navigationHistoryIndex);
+		if (historyIndex !== null && treeSnapshotId !== null) this.#claimTreeSnapshotAtHistoryIndex(historyIndex, treeSnapshotId);
+	}
+	/**
+	* Writes an app-owned push or replace entry and returns the traversal index
+	* it landed at. A history wrapper installed after boot can make its own
+	* writes before forwarding this one. When those moved the indices, the index
+	* is assigned as the write lands: a push goes after them, and a replace takes
+	* the index of the entry it actually overwrites. The index is committed as
+	* soon as the write succeeds, so a push the wrapper makes after forwarding
+	* goes after it.
+	*/
+	#writeNavigationHistoryState(historyUpdateMode, state, href, allocatedIndex, rendersTree) {
+		const allocatedCurrentIndex = this.#currentHistoryTraversalIndex;
+		const allocatedNextIndex = this.#nextHistoryTraversalIndex;
+		const releaseClaims = (overwrittenHistoryState) => {
+			if (historyUpdateMode === "push") {
+				this.#releaseForwardTreeSnapshotClaims();
+				return;
+			}
+			if (!rendersTree) return;
+			const overwrittenIndex = readHistoryStateTraversalIndex(overwrittenHistoryState) ?? this.#currentHistoryTraversalIndex;
+			if (overwrittenIndex !== null) this.#releaseTreeSnapshotClaimAtHistoryIndex(overwrittenIndex);
+		};
+		let landedIndex;
+		let landingStarted = false;
+		const land = (data) => {
+			landingStarted = true;
+			const index = this.#currentHistoryTraversalIndex !== allocatedCurrentIndex || this.#nextHistoryTraversalIndex !== allocatedNextIndex ? this.allocateNavigationHistoryTraversalIndex(historyUpdateMode) : allocatedIndex;
+			const overwrittenHistoryState = this.#readHistoryState();
+			return {
+				data: index === allocatedIndex ? data : createHistoryStateWithNavigationMetadata(data, {
+					previousNextUrl: readHistoryStatePreviousNextUrl(data),
+					traversalIndex: index
+				}),
+				commit: () => {
+					releaseClaims(overwrittenHistoryState);
+					if (rendersTree) this.#treeSnapshotPending = true;
+					landedIndex = index;
+					this.commitHistoryTraversalIndex(index);
+				}
+			};
+		};
+		const historyStateBeforeWrite = this.#readHistoryState();
+		if (historyUpdateMode === "push") this.#pushHistoryState(state, href, land);
+		else this.#replaceHistoryState(state, href, land);
+		if (landedIndex !== void 0) return landedIndex;
+		if (landingStarted) return null;
+		releaseClaims(historyStateBeforeWrite);
+		if (rendersTree) this.#treeSnapshotPending = true;
+		this.commitHistoryTraversalIndex(allocatedIndex);
+		return allocatedIndex;
 	}
 	#createHashOnlyNavigationBaseHistoryState(historyUpdateMode, scroll) {
 		const historyState = this.#readHistoryState();
@@ -238,19 +314,15 @@ var AppBrowserHistoryController = class {
 		let wroteHistoryState = false;
 		if (options.historyUpdateMode === "replace" && (currentHref !== targetHref || replacesClaimedOrExternalTree)) {
 			options.stageClientParams();
-			const currentHistoryIndex = readHistoryStateTraversalIndex(currentHistoryState) ?? this.#currentHistoryTraversalIndex;
-			if (currentHistoryIndex !== null) this.#releaseTreeSnapshotClaimAtHistoryIndex(currentHistoryIndex);
-			this.#replaceHistoryState(historyState, options.href);
+			this.#writeNavigationHistoryState("replace", historyState, options.href, navigationHistoryIndex, true);
 			wroteHistoryState = true;
-			this.commitHistoryTraversalIndex(navigationHistoryIndex);
 		} else if (options.historyUpdateMode === "push" && currentHref !== targetHref) {
 			options.stageClientParams();
-			this.#releaseForwardTreeSnapshotClaims();
-			this.#pushHistoryState(historyState, options.href);
+			this.#writeNavigationHistoryState("push", historyState, options.href, navigationHistoryIndex, true);
 			wroteHistoryState = true;
-			this.commitHistoryTraversalIndex(navigationHistoryIndex);
 		}
 		if (!wroteHistoryState) {
+			this.#treeSnapshotPending = true;
 			this.syncCurrentHistoryStatePreviousNextUrl(options.previousNextUrl, options.bfcacheIds, options.activeRoutePaths);
 			options.stageClientParams();
 			if (options.targetHistoryIndex !== void 0) this.commitHistoryTraversalIndex(options.targetHistoryIndex);
@@ -306,6 +378,7 @@ var AppBrowserHistoryController = class {
 				state,
 				beforeCommit: () => {
 					this.commitTraversalIndexFromHistoryState(options.historyState);
+					this.#treeSnapshotPending = true;
 					options.stageClientParams(state.navigationSnapshot.params);
 				}
 			});
@@ -317,11 +390,16 @@ var AppBrowserHistoryController = class {
 			state: decision.state,
 			beforeCommit: () => {
 				this.commitHistoryTraversalIndex(decision.targetHistoryIndex);
+				this.#treeSnapshotPending = true;
 				options.stageClientParams(decision.state.navigationSnapshot.params);
 			}
 		});
 	}
 };
+function createDocumentTreeSnapshotIdPrefix() {
+	const bytes = crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(8));
+	return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
 function areStringArraysEqual(a, b) {
 	if (a === b) return true;
 	if (a === null || b === null || a.length !== b.length) return false;

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";
@@ -408,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,

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

@@ -1,5 +1,5 @@
 import { isDangerousScheme, reportBlockedDangerousNavigation } from "../shims/url-safety.js";
-import { resolveHardNavigationTargetFromRscResponse, stripRscCacheBustingSearchParam, stripRscSuffix } from "./app-rsc-cache-busting.js";
+import { resolveHardNavigationTargetFromRscResponse, stripRscCacheBustingSearchParam, toPathAbsolutePathname } from "./app-rsc-cache-busting.js";
 //#region src/server/app-browser-rsc-redirect.ts
 const MAX_RSC_REDIRECT_DEPTH = 10;
 function blockDangerousStreamedRscRedirect(response, streamedRedirectTarget) {
@@ -11,11 +11,10 @@ function blockDangerousStreamedRscRedirect(response, streamedRedirectTarget) {
 function toVisibleAppHref(href, origin) {
 	const url = new URL(href, origin);
 	stripRscCacheBustingSearchParam(url);
-	return `${stripRscSuffix(url.pathname)}${url.search}${url.hash}`;
+	return `${toPathAbsolutePathname(url.pathname)}${url.search}${url.hash}`;
 }
-function toStreamedRedirectVisibleAppHref(href, origin) {
-	const url = new URL(href, origin);
-	return `${url.pathname}${url.search}${url.hash}`;
+function toStreamedRedirectVisibleAppHref(url) {
+	return `${toPathAbsolutePathname(url.pathname)}${url.search}${url.hash}`;
 }
 function resolveRedirectLifecycleHopFromTarget(options) {
 	if (options.targetUrl.origin !== options.origin) return {
@@ -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;

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 { VINEXT_RSC_COMPATIBILITY_ID_HEADER, createServerActionRequestUrl, toPathAbsolutePathname } 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 { VINEXT_RSC_COMPATIBILITY_ID_HEADER, createServerActionRequestUrl } from "./app-rsc-cache-busting.js";
-import { throwOnServerActionNotFound } from "./server-action-not-found.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";
@@ -49,7 +49,7 @@ var ServerActionRedirectError = class extends Error {
 	constructor(target) {
 		super("NEXT_REDIRECT");
 		const redirectUrl = new URL(target.href, window.location.href);
-		const redirectHref = redirectUrl.pathname + redirectUrl.search + redirectUrl.hash;
+		const redirectHref = toPathAbsolutePathname(redirectUrl.pathname) + redirectUrl.search + redirectUrl.hash;
 		const redirectType = target.type === "push" ? "push" : "replace";
 		this.digest = `NEXT_REDIRECT;${redirectType};${redirectHref};${target.status};`;
 	}
@@ -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 { 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";
 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-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 = {

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) {
@@ -87,11 +87,11 @@ function reduceApprovedVisibleCommitState(state, commit) {
 			const hmrUniquePreserveElementIds = hmrPreserveElementIds.length > 1 ? [...new Set(hmrPreserveElementIds)] : hmrPreserveElementIds;
 			const preserveElementIds = action.operation.lane === "hmr" ? hmrUniquePreserveElementIds : bfcacheCompatiblePreserveElementIds;
 			const preserveTemplateIds = action.reuseCurrentBfcacheIds && (action.operation.lane === "navigation" || action.operation.lane === "traverse" || action.operation.lane === "server-action") ? Object.keys(state.elements).filter((id) => Object.hasOwn(action.elements, id) && hasSameServerTemplateSeedIdentity(id, state.navigationSnapshot, action.navigationSnapshot)) : [];
-			const mergedPreserveElementIds = preserveTemplateIds.length === 0 ? preserveElementIds : [.../* @__PURE__ */ new Set([...preserveElementIds, ...preserveTemplateIds])];
 			const mergedElements = mergeElements(state.elements, action.elements, {
 				clearAbsentSlots: action.type === "traverse" || !action.reuseCurrentBfcacheIds,
 				preserveAbsentSlots: action.reuseCurrentBfcacheIds && commit.decision.preserveAbsentSlots,
-				preserveElementIds: mergedPreserveElementIds,
+				preserveElementIds,
+				preserveElementSeedIds: preserveTemplateIds,
 				preservePreviousSlotIds: effectivePreservePreviousSlotIds
 			});
 			return commitVisibleRouterState(state, {
@@ -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-elements-wire.d.ts

@@ -1,6 +1,5 @@
 import { ArtifactCompatibilityEnvelope } from "./artifact-compatibility.js";
 import { CacheEntryReuseProof } from "./cache-proof.js";
-import { ClientReuseManifestSkipDisposition } from "./client-reuse-manifest.js";
 import { BfcacheSegmentIdentity } from "./bfcache-identity.js";
 import { compareStrings } from "../utils/compare.js";
 import { AppElementsWireElementKey } from "./app-elements-wire-key.js";
@@ -12,7 +11,6 @@ export declare const APP_DYNAMIC_STALE_TIME_KEY = "__dynamicStaleTime";
 export declare const APP_INTERCEPTION_KEY = "__interception";
 export declare const APP_INTERCEPTION_CONTEXT_KEY = "__interceptionContext";
 export declare const APP_LAYOUT_IDS_KEY = "__layoutIds";
-export declare const APP_LAYOUT_FLAGS_KEY = "__layoutFlags";
 export declare const APP_ROUTE_KEY = "__route";
 export declare const APP_ROOT_LAYOUT_KEY = "__rootLayout";
 export declare const APP_SKIPPED_LAYOUT_IDS_KEY = "__skippedLayoutIds";
@@ -51,28 +49,10 @@ export declare const compareAppElementsSlotIds: typeof compareStrings;
 export declare function normalizeAppElementsSlotBindings(slotBindings: readonly AppElementsSlotBinding[], options?: {
   layoutIds?: readonly string[];
 }): readonly AppElementsSlotBinding[];
-export type AppElementValue = ReactNode | typeof UNMATCHED_SLOT | string | null | LayoutFlags | AppElementsBfcacheSegmentIdentities | ArtifactCompatibilityEnvelope | CacheEntryReuseProof | AppElementsInterception | readonly string[] | readonly AppElementsSlotBinding[];
-type AppWireElementValue = ReactNode | string | null | LayoutFlags | AppElementsBfcacheSegmentIdentities | ArtifactCompatibilityEnvelope | CacheEntryReuseProof | AppElementsInterception | readonly string[] | readonly AppElementsSlotBinding[];
+export type AppElementValue = ReactNode | typeof UNMATCHED_SLOT | string | null | AppElementsBfcacheSegmentIdentities | ArtifactCompatibilityEnvelope | CacheEntryReuseProof | AppElementsInterception | readonly string[] | readonly AppElementsSlotBinding[];
+type AppWireElementValue = ReactNode | string | null | AppElementsBfcacheSegmentIdentities | ArtifactCompatibilityEnvelope | CacheEntryReuseProof | AppElementsInterception | readonly string[] | readonly AppElementsSlotBinding[];
 export type AppElements = Readonly<Record<string, AppElementValue>>;
 export type AppWireElements = Readonly<Record<string, AppWireElementValue>>;
-/**
- * Per-layout static/dynamic flags. `"s"` = static (skippable on next nav);
- * `"d"` = dynamic (must always render).
- *
- * Lifecycle (partial — later PRs extend this):
- *
- *   1. PROBE   — probeAppPageLayouts (server/app-page-execution.ts) returns
- *                LayoutFlags for every layout in the route at render time.
- *
- *   2. ATTACH  — AppElementsWire.encodeOutgoingPayload writes `__layoutFlags`
- *                into the outgoing App Router payload record.
- *
- *   3. WIRE    — renderToReadableStream serializes the record as RSC row 0.
- *
- *   4. PARSE   — AppElementsWire.readMetadata extracts layoutFlags from the
- *                wire payload on the client side.
- */
-export type LayoutFlags = Readonly<Record<string, "s" | "d">>;
 export type AppElementsBfcacheSegmentIdentities = Readonly<Record<string, BfcacheSegmentIdentity>>;
 type AppElementsMetadata = {
   artifactCompatibility: ArtifactCompatibilityEnvelope;
@@ -81,7 +61,6 @@ type AppElementsMetadata = {
   interception: AppElementsInterception | null;
   interceptionContext: string | null;
   layoutIds: readonly string[];
-  layoutFlags: LayoutFlags;
   routeId: string;
   rootLayoutTreePath: string | null;
   bfcacheSegmentIdentities: AppElementsBfcacheSegmentIdentities;
@@ -113,11 +92,11 @@ type AppElementsWireMetadataEntries = Readonly<{
 }>;
 /**
  * The outgoing wire payload shape. Includes ReactNode values for the
- * rendered tree plus metadata values like LayoutFlags attached under
- * known keys (e.g. __layoutFlags). Distinct from AppElements / AppWireElements
+ * rendered tree plus metadata values attached under known keys (e.g.
+ * __artifactCompatibility). Distinct from AppElements / AppWireElements
  * which only carry render-time values.
  */
-export type AppOutgoingElements = Readonly<Record<string, ReactNode | LayoutFlags | AppElementsBfcacheSegmentIdentities | ArtifactCompatibilityEnvelope | CacheEntryReuseProof | AppElementsInterception | number | readonly string[] | readonly AppElementsSlotBinding[]>>;
+export type AppOutgoingElements = Readonly<Record<string, ReactNode | AppElementsBfcacheSegmentIdentities | ArtifactCompatibilityEnvelope | CacheEntryReuseProof | AppElementsInterception | number | readonly string[] | readonly AppElementsSlotBinding[]>>;
 type AppElementsWireKeys = {
   readonly artifactCompatibility: typeof APP_ARTIFACT_COMPATIBILITY_KEY;
   readonly cacheEntryReuseProof: typeof APP_CACHE_ENTRY_REUSE_PROOF_KEY;
@@ -125,7 +104,6 @@ type AppElementsWireKeys = {
   readonly interception: typeof APP_INTERCEPTION_KEY;
   readonly interceptionContext: typeof APP_INTERCEPTION_CONTEXT_KEY;
   readonly layoutIds: typeof APP_LAYOUT_IDS_KEY;
-  readonly layoutFlags: typeof APP_LAYOUT_FLAGS_KEY;
   readonly rootLayout: typeof APP_ROOT_LAYOUT_KEY;
   readonly route: typeof APP_ROUTE_KEY;
   readonly bfcacheSegmentIdentities: typeof APP_BFCACHE_SEGMENT_IDENTITIES_KEY;
@@ -145,8 +123,6 @@ type AppElementsWireCodec = {
     artifactCompatibility?: ArtifactCompatibilityEnvelope;
     cacheEntryReuseProof?: CacheEntryReuseProof;
     dynamicStaleTimeSeconds?: number;
-    layoutFlags: LayoutFlags;
-    skipDisposition?: ClientReuseManifestSkipDisposition;
   }): ReactNode | AppOutgoingElements;
   encodePageId(routePath: string, interceptionContext: string | null): string;
   encodeRouteId(routePath: string, interceptionContext: string | null): string;
@@ -155,9 +131,6 @@ type AppElementsWireCodec = {
   isSlotId(key: string): boolean;
   parseElementKey(key: string): AppElementsWireElementKey | null;
   readMetadata(elements: Readonly<Record<string, unknown>>): AppElementsMetadata;
-  withLayoutFlags<T extends Record<string, unknown>>(elements: T, layoutFlags: LayoutFlags): T & {
-    [APP_LAYOUT_FLAGS_KEY]: LayoutFlags;
-  };
 };
 export declare function normalizeAppElements(elements: AppWireElements): AppElements;
 /**
@@ -165,21 +138,16 @@ export declare function normalizeAppElements(elements: AppWireElements): AppElem
  * Used to distinguish the App Router payload object from bare React elements at
  * the render boundary. Narrows to `Readonly<Record<string, unknown>>` because
  * the outgoing payload carries heterogeneous values (ReactNodes for the rendered
- * tree, plus metadata like `__layoutFlags` which is a plain object). Delegates
+ * tree, plus metadata like `__artifactCompatibility`, a plain object). Delegates
  * to React's canonical `isValidElement` so we don't depend on React's internal
  * `$$typeof` marker scheme.
  */
 export declare function isAppElementsRecord(value: unknown): value is Readonly<Record<string, unknown>>;
-export declare function withLayoutFlags<T extends Record<string, unknown>>(elements: T, layoutFlags: LayoutFlags): T & {
-  [APP_LAYOUT_FLAGS_KEY]: LayoutFlags;
-};
 export declare function buildOutgoingAppPayload(input: {
   element: ReactNode | AppElements;
   artifactCompatibility?: ArtifactCompatibilityEnvelope;
   cacheEntryReuseProof?: CacheEntryReuseProof;
   dynamicStaleTimeSeconds?: number;
-  layoutFlags: LayoutFlags;
-  skipDisposition?: ClientReuseManifestSkipDisposition;
 }): ReactNode | AppOutgoingElements;
 export declare function readAppElementsMetadata(elements: Readonly<Record<string, unknown>>): AppElementsMetadata;
 export declare const AppElementsWire: AppElementsWireCodec;