vinext 0.0.55 → 0.1.1

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

@@ -1,17 +1,142 @@
-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) {
+	const current = options.reuseCurrent === false ? {} : options.current;
+	for (const value of Object.values(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
+		}) ? 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 +146,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 +196,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 +337,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 +391,15 @@ 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,
+				reuseCurrent: options.reuseCurrentBfcacheIds
+			}),
 			...cacheEntryReuseProof ? { cacheEntryReuseProof } : {},
 			elements,
 			interception: metadata.interception,
@@ -231,7 +416,9 @@ async function createPendingNavigationCommit(options) {
 			previousNextUrl,
 			renderId: options.renderId,
 			rootLayoutTreePath: metadata.rootLayoutTreePath,
+			reuseCurrentBfcacheIds: options.reuseCurrentBfcacheIds ?? true,
 			routeId: metadata.routeId,
+			skippedLayoutIds: metadata.skippedLayoutIds,
 			type: options.type
 		},
 		...cacheEntryReuseProof ? { cacheEntryReuseProof } : {},
@@ -239,10 +426,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,36 @@ function reduceApprovedVisibleCommitState(state, commit) {
 	const { action } = commit;
 	switch (action.type) {
 		case "traverse":
-		case "navigate": return commitVisibleRouterState(state, {
-			elements: 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);
+		case "navigate": {
+			const preserveElementIds = action.reuseCurrentBfcacheIds ? commit.decision.preserveElementIds : [];
+			const preservePreviousSlotIds = action.reuseCurrentBfcacheIds ? commit.decision.preservePreviousSlotIds : [];
+			const mergedElements = mergeElements(state.elements, action.elements, {
+				clearAbsentSlots: action.type === "traverse" || !action.reuseCurrentBfcacheIds,
+				preserveAbsentSlots: action.reuseCurrentBfcacheIds && commit.decision.preserveAbsentSlots,
+				preserveElementIds,
+				preservePreviousSlotIds
+			});
+			return commitVisibleRouterState(state, {
+				bfcacheIds: preserveBfcacheIdsForMergedElements({
+					elements: mergedElements,
+					next: action.bfcacheIds,
+					previous: action.reuseCurrentBfcacheIds ? state.bfcacheIds : {}
+				}),
+				elements: mergedElements,
+				interception: action.interception,
+				interceptionContext: action.interceptionContext,
+				layoutFlags: mergeLayoutFlags(state.layoutFlags, action.layoutFlags, 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, preservePreviousSlotIds)
+			}, action.operation);
+		}
 		case "replace": return commitVisibleRouterState(state, {
+			bfcacheIds: action.bfcacheIds,
 			elements: action.elements,
 			interception: action.interception,
 			interceptionContext: action.interceptionContext,
@@ -227,5 +238,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

package/dist/server/app-elements-wire.d.ts

@@ -1,5 +1,6 @@
 import { ArtifactCompatibilityEnvelope } from "./artifact-compatibility.js";
 import { CacheEntryReuseProof, RenderObservation } from "./cache-proof.js";
+import { ClientReuseManifestSkipDisposition } from "./client-reuse-manifest.js";
 import { ReactNode } from "react";
 
 //#region src/server/app-elements-wire.d.ts
@@ -12,6 +13,7 @@ declare const APP_LAYOUT_FLAGS_KEY = "__layoutFlags";
 declare const APP_RENDER_OBSERVATION_KEY = "__renderObservation";
 declare const APP_ROUTE_KEY = "__route";
 declare const APP_ROOT_LAYOUT_KEY = "__rootLayout";
+declare const APP_SKIPPED_LAYOUT_IDS_KEY = "__skippedLayoutIds";
 declare const APP_SLOT_BINDINGS_KEY = "__slotBindings";
 /**
  * Static sibling segment names for the matched route, surfaced so the client
@@ -26,6 +28,7 @@ declare const APP_UNMATCHED_SLOT_WIRE_VALUE = "__VINEXT_UNMATCHED_SLOT__";
 declare const UNMATCHED_SLOT: unique symbol;
 type AppElementsSlotBindingState = "active" | "default" | "unmatched";
 type AppElementsSlotBinding = Readonly<{
+  activeRouteId?: string | null;
   ownerLayoutId: string | null;
   slotId: string;
   state: AppElementsSlotBindingState;
@@ -37,12 +40,12 @@ type AppElementsInterception = Readonly<{
   targetMatchedUrl: string;
   targetRouteId: string;
 }>;
-declare function compareAppElementsSlotIds(left: string, right: string): number;
+declare const compareAppElementsSlotIds: (left: string, right: string) => number;
 declare function normalizeAppElementsSlotBindings(slotBindings: readonly AppElementsSlotBinding[], options?: {
   layoutIds?: readonly string[];
 }): readonly AppElementsSlotBinding[];
-type AppElementValue = ReactNode | typeof UNMATCHED_SLOT | string | null | LayoutFlags | ArtifactCompatibilityEnvelope | CacheEntryReuseProof | AppElementsInterception | readonly AppElementsSlotBinding[];
-type AppWireElementValue = ReactNode | string | null | LayoutFlags | ArtifactCompatibilityEnvelope | CacheEntryReuseProof | AppElementsInterception | readonly AppElementsSlotBinding[];
+type AppElementValue = ReactNode | typeof UNMATCHED_SLOT | string | null | LayoutFlags | ArtifactCompatibilityEnvelope | CacheEntryReuseProof | AppElementsInterception | readonly string[] | readonly AppElementsSlotBinding[];
+type AppWireElementValue = ReactNode | string | null | LayoutFlags | ArtifactCompatibilityEnvelope | CacheEntryReuseProof | AppElementsInterception | readonly string[] | readonly AppElementsSlotBinding[];
 type AppElements = Readonly<Record<string, AppElementValue>>;
 type AppWireElements = Readonly<Record<string, AppWireElementValue>>;
 /**
@@ -72,6 +75,7 @@ type AppElementsMetadata = {
   layoutFlags: LayoutFlags;
   routeId: string;
   rootLayoutTreePath: string | null;
+  skippedLayoutIds: readonly string[];
   slotBindings: readonly AppElementsSlotBinding[];
 };
 type AppElementsWireElementKey = {
@@ -115,7 +119,7 @@ type AppElementsWireMetadataEntries = Readonly<{
  * known keys (e.g. __layoutFlags). Distinct from AppElements / AppWireElements
  * which only carry render-time values.
  */
-type AppOutgoingElements = Readonly<Record<string, ReactNode | LayoutFlags | ArtifactCompatibilityEnvelope | CacheEntryReuseProof | AppElementsInterception | RenderObservation | readonly AppElementsSlotBinding[] | readonly string[]>>;
+type AppOutgoingElements = Readonly<Record<string, ReactNode | LayoutFlags | ArtifactCompatibilityEnvelope | CacheEntryReuseProof | AppElementsInterception | RenderObservation | readonly string[] | readonly AppElementsSlotBinding[]>>;
 type AppElementsWireKeys = {
   readonly artifactCompatibility: typeof APP_ARTIFACT_COMPATIBILITY_KEY;
   readonly cacheEntryReuseProof: typeof APP_CACHE_ENTRY_REUSE_PROOF_KEY;
@@ -126,6 +130,7 @@ type AppElementsWireKeys = {
   readonly renderObservation: typeof APP_RENDER_OBSERVATION_KEY;
   readonly rootLayout: typeof APP_ROOT_LAYOUT_KEY;
   readonly route: typeof APP_ROUTE_KEY;
+  readonly skippedLayoutIds: typeof APP_SKIPPED_LAYOUT_IDS_KEY;
   readonly slotBindings: typeof APP_SLOT_BINDINGS_KEY;
 };
 type AppElementsWireCodec = {
@@ -136,11 +141,12 @@ type AppElementsWireCodec = {
   encodeCacheKey(rscUrl: string, interceptionContext: string | null): string;
   encodeLayoutId(treePath: string): string;
   encodeOutgoingPayload(input: {
-    element: ReactNode | Readonly<Record<string, ReactNode | AppElementsInterception | readonly AppElementsSlotBinding[] | readonly string[]>>;
+    element: ReactNode | AppElements;
     artifactCompatibility?: ArtifactCompatibilityEnvelope;
     cacheEntryReuseProof?: CacheEntryReuseProof;
     layoutFlags: LayoutFlags;
     renderObservation?: RenderObservation;
+    skipDisposition?: ClientReuseManifestSkipDisposition;
   }): ReactNode | AppOutgoingElements;
   encodePageId(routePath: string, interceptionContext: string | null): string;
   encodeRouteId(routePath: string, interceptionContext: string | null): string;
@@ -168,14 +174,14 @@ declare function withLayoutFlags<T extends Record<string, unknown>>(elements: T,
   [APP_LAYOUT_FLAGS_KEY]: LayoutFlags;
 };
 declare function buildOutgoingAppPayload(input: {
-  element: ReactNode | Readonly<Record<string, ReactNode | AppElementsInterception | readonly AppElementsSlotBinding[] | readonly string[]>>;
+  element: ReactNode | AppElements;
   artifactCompatibility?: ArtifactCompatibilityEnvelope;
   cacheEntryReuseProof?: CacheEntryReuseProof;
   layoutFlags: LayoutFlags;
   renderObservation?: RenderObservation;
+  skipDisposition?: ClientReuseManifestSkipDisposition;
 }): ReactNode | AppOutgoingElements;
 declare function readAppElementsMetadata(elements: Readonly<Record<string, unknown>>): AppElementsMetadata;
 declare const AppElementsWire: AppElementsWireCodec;
 //#endregion
-export { APP_ARTIFACT_COMPATIBILITY_KEY, APP_CACHE_ENTRY_REUSE_PROOF_KEY, APP_INTERCEPTION_CONTEXT_KEY, APP_INTERCEPTION_KEY, APP_LAYOUT_FLAGS_KEY, APP_LAYOUT_IDS_KEY, APP_RENDER_OBSERVATION_KEY, APP_ROOT_LAYOUT_KEY, APP_ROUTE_KEY, APP_SLOT_BINDINGS_KEY, APP_STATIC_SIBLINGS_KEY, APP_UNMATCHED_SLOT_WIRE_VALUE, AppElementValue, AppElements, AppElementsInterception, AppElementsSlotBinding, AppElementsSlotBindingState, AppElementsWire, AppOutgoingElements, AppWireElements, LayoutFlags, UNMATCHED_SLOT, buildOutgoingAppPayload, compareAppElementsSlotIds, isAppElementsRecord, normalizeAppElements, normalizeAppElementsSlotBindings, readAppElementsMetadata, withLayoutFlags };
-//# sourceMappingURL=app-elements-wire.d.ts.map
+export { APP_ARTIFACT_COMPATIBILITY_KEY, APP_CACHE_ENTRY_REUSE_PROOF_KEY, APP_INTERCEPTION_CONTEXT_KEY, APP_INTERCEPTION_KEY, APP_LAYOUT_FLAGS_KEY, APP_LAYOUT_IDS_KEY, APP_RENDER_OBSERVATION_KEY, APP_ROOT_LAYOUT_KEY, APP_ROUTE_KEY, APP_SKIPPED_LAYOUT_IDS_KEY, APP_SLOT_BINDINGS_KEY, APP_STATIC_SIBLINGS_KEY, APP_UNMATCHED_SLOT_WIRE_VALUE, AppElementValue, AppElements, AppElementsInterception, AppElementsSlotBinding, AppElementsWire, AppOutgoingElements, AppWireElements, LayoutFlags, UNMATCHED_SLOT, buildOutgoingAppPayload, compareAppElementsSlotIds, isAppElementsRecord, normalizeAppElements, normalizeAppElementsSlotBindings, readAppElementsMetadata, withLayoutFlags };