vinext 0.0.55 → 0.1.1

package/dist/server/app-elements-wire.js

@@ -1,5 +1,8 @@
 import { isInterceptionMatchedUrlPath } from "./normalize-path.js";
+import { compareStrings } from "../utils/compare.js";
+import { isUnknownRecord } from "../utils/record.js";
 import { createArtifactCompatibilityEnvelope, parseArtifactCompatibilityEnvelope } from "./artifact-compatibility.js";
+import { releaseAppElementRenderDependency } from "./app-render-dependency.js";
 import { isValidElement } from "react";
 //#region src/server/app-elements-wire.ts
 const APP_INTERCEPTION_SEPARATOR = "\0";
@@ -12,6 +15,7 @@ const APP_LAYOUT_FLAGS_KEY = "__layoutFlags";
 const APP_RENDER_OBSERVATION_KEY = "__renderObservation";
 const APP_ROUTE_KEY = "__route";
 const APP_ROOT_LAYOUT_KEY = "__rootLayout";
+const APP_SKIPPED_LAYOUT_IDS_KEY = "__skippedLayoutIds";
 const APP_SLOT_BINDINGS_KEY = "__slotBindings";
 /**
 * Static sibling segment names for the matched route, surfaced so the client
@@ -24,6 +28,7 @@ const APP_SLOT_BINDINGS_KEY = "__slotBindings";
 const APP_STATIC_SIBLINGS_KEY = "__staticSiblings";
 const APP_UNMATCHED_SLOT_WIRE_VALUE = "__VINEXT_UNMATCHED_SLOT__";
 const UNMATCHED_SLOT = Symbol.for("vinext.unmatchedSlot");
+const EMPTY_SKIPPED_LAYOUT_IDS = /* @__PURE__ */ new Set();
 function createCacheProofRejectionCodeSet(codes) {
 	return new Set(codes);
 }
@@ -58,11 +63,7 @@ const CACHE_PROOF_REJECTION_CODES = createCacheProofRejectionCodeSet([
 	"CP_STATIC_LAYOUT_ROOT_BOUNDARY_UNKNOWN",
 	"CP_STATIC_LAYOUT_VARIANT_DIMENSION_UNPROVEN"
 ]);
-function compareAppElementsSlotIds(left, right) {
-	if (left < right) return -1;
-	if (left > right) return 1;
-	return 0;
-}
+const compareAppElementsSlotIds = compareStrings;
 function compareAppElementsSlotBindingsBySlotId(left, right) {
 	return compareAppElementsSlotIds(left.slotId, right.slotId);
 }
@@ -202,24 +203,27 @@ function isLayoutFlagsRecord(value) {
 	for (const v of Object.values(value)) if (v !== "s" && v !== "d") return false;
 	return true;
 }
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function parseLayoutFlags(value) {
 	if (isLayoutFlagsRecord(value)) return value;
 	return {};
 }
-function parseLayoutIds(value) {
+function parseLayoutIdList(value, fieldName) {
 	if (value === void 0) return [];
-	if (!Array.isArray(value)) throw new Error("[vinext] Invalid __layoutIds in App Router payload: expected layout id string[]");
+	if (!Array.isArray(value)) throw new Error(`[vinext] Invalid ${fieldName} in App Router payload: expected layout id string[]`);
 	const layoutIds = [];
 	for (const entry of value) {
-		if (typeof entry !== "string") throw new Error("[vinext] Invalid __layoutIds in App Router payload: expected layout id string[]");
-		if (parseAppElementsWireElementKey(entry)?.kind !== "layout") throw new Error("[vinext] Invalid __layoutIds in App Router payload: expected layout ids");
+		if (typeof entry !== "string") throw new Error(`[vinext] Invalid ${fieldName} in App Router payload: expected layout id string[]`);
+		if (parseAppElementsWireElementKey(entry)?.kind !== "layout") throw new Error(`[vinext] Invalid ${fieldName} in App Router payload: expected layout ids`);
 		layoutIds.push(entry);
 	}
 	return layoutIds;
 }
+function parseLayoutIds(value) {
+	return parseLayoutIdList(value, APP_LAYOUT_IDS_KEY);
+}
+function parseSkippedLayoutIds(value) {
+	return parseLayoutIdList(value, APP_SKIPPED_LAYOUT_IDS_KEY);
+}
 function isSlotBindingState(value) {
 	return value === "active" || value === "default" || value === "unmatched";
 }
@@ -228,14 +232,17 @@ function parseSlotBindings(value, options = {}) {
 	if (!Array.isArray(value)) throw new Error("[vinext] Invalid __slotBindings in App Router payload: expected array");
 	const slotBindings = [];
 	for (const entry of value) {
-		if (!isRecord(entry)) throw new Error("[vinext] Invalid __slotBindings in App Router payload: expected objects");
+		if (!isUnknownRecord(entry)) throw new Error("[vinext] Invalid __slotBindings in App Router payload: expected objects");
 		const slotId = entry.slotId;
 		if (typeof slotId !== "string" || parseAppElementsWireElementKey(slotId)?.kind !== "slot") throw new Error("[vinext] Invalid __slotBindings in App Router payload: expected slot ids");
 		const ownerLayoutId = entry.ownerLayoutId;
 		if (ownerLayoutId !== null && (typeof ownerLayoutId !== "string" || parseAppElementsWireElementKey(ownerLayoutId)?.kind !== "layout")) throw new Error("[vinext] Invalid __slotBindings in App Router payload: expected owner layout ids");
 		const state = entry.state;
 		if (!isSlotBindingState(state)) throw new Error("[vinext] Invalid __slotBindings in App Router payload: expected state");
+		const activeRouteId = entry.activeRouteId;
+		if (activeRouteId !== void 0 && activeRouteId !== null && (typeof activeRouteId !== "string" || parseAppElementsWireElementKey(activeRouteId)?.kind !== "route")) throw new Error("[vinext] Invalid __slotBindings in App Router payload: expected route ids");
 		slotBindings.push({
+			...activeRouteId !== void 0 ? { activeRouteId } : {},
 			ownerLayoutId,
 			slotId,
 			state
@@ -263,7 +270,7 @@ function parseInterceptionSlotId(value) {
 }
 function parseInterceptionMetadata(value) {
 	if (value === void 0 || value === null) return null;
-	if (!isRecord(value)) throw new Error("[vinext] Invalid __interception in App Router payload: expected object");
+	if (!isUnknownRecord(value)) throw new Error("[vinext] Invalid __interception in App Router payload: expected object");
 	const sourceMatchedUrl = parseInterceptionMatchedUrl(readRequiredInterceptionString(value, "sourceMatchedUrl"));
 	const targetMatchedUrl = parseInterceptionMatchedUrl(readRequiredInterceptionString(value, "targetMatchedUrl"));
 	return {
@@ -297,15 +304,28 @@ function withLayoutFlags(elements, layoutFlags) {
 }
 function buildOutgoingAppPayload(input) {
 	if (!isAppElementsRecord(input.element)) return input.element;
-	const payload = {
-		...input.element,
-		[APP_LAYOUT_FLAGS_KEY]: input.layoutFlags,
-		[APP_ARTIFACT_COMPATIBILITY_KEY]: input.artifactCompatibility ?? createArtifactCompatibilityEnvelope()
-	};
+	const skippedLayoutIds = createSkippedLayoutIds(input.skipDisposition);
+	const payload = {};
+	for (const [key, value] of Object.entries(input.element)) {
+		if (skippedLayoutIds.has(key)) {
+			releaseAppElementRenderDependency(input.element, key);
+			continue;
+		}
+		payload[key] = value === UNMATCHED_SLOT ? APP_UNMATCHED_SLOT_WIRE_VALUE : value;
+	}
+	payload[APP_LAYOUT_FLAGS_KEY] = input.layoutFlags;
+	if (skippedLayoutIds.size > 0) payload[APP_SKIPPED_LAYOUT_IDS_KEY] = [...skippedLayoutIds];
+	payload[APP_ARTIFACT_COMPATIBILITY_KEY] = input.artifactCompatibility ?? createArtifactCompatibilityEnvelope();
 	if (input.cacheEntryReuseProof) payload[APP_CACHE_ENTRY_REUSE_PROOF_KEY] = input.cacheEntryReuseProof;
 	if (input.renderObservation) payload[APP_RENDER_OBSERVATION_KEY] = input.renderObservation;
 	return payload;
 }
+function createSkippedLayoutIds(skipDisposition) {
+	if (skipDisposition?.enabled !== true) return EMPTY_SKIPPED_LAYOUT_IDS;
+	const skippedLayoutIds = /* @__PURE__ */ new Set();
+	for (const id of skipDisposition.skippedEntryIds) if (parseAppElementsWireElementKey(id)?.kind === "layout") skippedLayoutIds.add(id);
+	return skippedLayoutIds;
+}
 function readArtifactCompatibilityMetadata(value) {
 	if (value === void 0) return createArtifactCompatibilityEnvelope();
 	return parseArtifactCompatibilityEnvelope(value) ?? createArtifactCompatibilityEnvelope();
@@ -327,10 +347,10 @@ function isCacheProofFallbackScope(value) {
 }
 function parseCacheEntryReuseProofMetadata(value) {
 	if (value === void 0) return null;
-	if (!isRecord(value) || value.kind !== "runtime-cache-entry") return createMissingCacheEntryReuseProof();
+	if (!isUnknownRecord(value) || value.kind !== "runtime-cache-entry") return createMissingCacheEntryReuseProof();
 	const decision = value.decision;
 	if (decision === null) return createMissingCacheEntryReuseProof();
-	if (!isRecord(decision)) return createMissingCacheEntryReuseProof();
+	if (!isUnknownRecord(decision)) return createMissingCacheEntryReuseProof();
 	if (decision.kind === "reuse" && decision.canReuse === true && decision.code === "CP_STATIC_LAYOUT_REUSE_PROVEN" && decision.reuseClass === "static-layout") return {
 		kind: "runtime-cache-entry",
 		decision: {
@@ -362,6 +382,7 @@ function readAppElementsMetadata(elements) {
 	if (rootLayoutTreePath !== null && typeof rootLayoutTreePath !== "string") throw new Error("[vinext] Invalid __rootLayout in App Router payload: expected string or null");
 	const layoutFlags = parseLayoutFlags(elements[APP_LAYOUT_FLAGS_KEY]);
 	const layoutIds = parseLayoutIds(elements[APP_LAYOUT_IDS_KEY]);
+	const skippedLayoutIds = parseSkippedLayoutIds(elements[APP_SKIPPED_LAYOUT_IDS_KEY]);
 	const slotBindings = parseSlotBindings(elements[APP_SLOT_BINDINGS_KEY], { layoutIds });
 	const interception = parseInterceptionMetadata(elements[APP_INTERCEPTION_KEY]);
 	const artifactCompatibility = readArtifactCompatibilityMetadata(elements[APP_ARTIFACT_COMPATIBILITY_KEY]);
@@ -375,6 +396,7 @@ function readAppElementsMetadata(elements) {
 		layoutFlags,
 		routeId,
 		rootLayoutTreePath,
+		skippedLayoutIds,
 		slotBindings
 	};
 }
@@ -389,6 +411,7 @@ const AppElementsWire = {
 		renderObservation: APP_RENDER_OBSERVATION_KEY,
 		rootLayout: APP_ROOT_LAYOUT_KEY,
 		route: APP_ROUTE_KEY,
+		skippedLayoutIds: APP_SKIPPED_LAYOUT_IDS_KEY,
 		slotBindings: APP_SLOT_BINDINGS_KEY
 	},
 	unmatchedSlotValue: APP_UNMATCHED_SLOT_WIRE_VALUE,
@@ -407,6 +430,4 @@ const AppElementsWire = {
 	withLayoutFlags
 };
 //#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, AppElementsWire, UNMATCHED_SLOT, buildOutgoingAppPayload, compareAppElementsSlotIds, isAppElementsRecord, normalizeAppElements, normalizeAppElementsSlotBindings, readAppElementsMetadata, withLayoutFlags };
-
-//# sourceMappingURL=app-elements-wire.js.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, AppElementsWire, UNMATCHED_SLOT, buildOutgoingAppPayload, compareAppElementsSlotIds, isAppElementsRecord, normalizeAppElements, normalizeAppElementsSlotBindings, readAppElementsMetadata, withLayoutFlags };

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

@@ -1,4 +1,4 @@
-import { 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, AppElementsWire, AppOutgoingElements, AppWireElements, LayoutFlags, UNMATCHED_SLOT, buildOutgoingAppPayload, compareAppElementsSlotIds, isAppElementsRecord, normalizeAppElements, normalizeAppElementsSlotBindings, readAppElementsMetadata, withLayoutFlags } from "./app-elements-wire.js";
+import { 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 } from "./app-elements-wire.js";
 
 //#region src/server/app-elements.d.ts
 declare const APP_PREFETCH_LOADING_SHELL_MARKER_KEY = "__prefetchLoadingShell";
@@ -6,5 +6,4 @@ declare function getMountedSlotIds(elements: AppElements): string[];
 declare function getMountedSlotIdsHeader(elements: AppElements): string | null;
 declare function resolveVisitedResponseInterceptionContext(requestInterceptionContext: string | null, payloadInterceptionContext: string | null): string | null;
 //#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_PREFETCH_LOADING_SHELL_MARKER_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, type AppElementValue, type AppElements, type AppElementsInterception, type AppElementsSlotBinding, AppElementsWire, type AppOutgoingElements, type AppWireElements, type LayoutFlags, UNMATCHED_SLOT, buildOutgoingAppPayload, compareAppElementsSlotIds, getMountedSlotIds, getMountedSlotIdsHeader, isAppElementsRecord, normalizeAppElements, normalizeAppElementsSlotBindings, readAppElementsMetadata, resolveVisitedResponseInterceptionContext, withLayoutFlags };
-//# sourceMappingURL=app-elements.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_PREFETCH_LOADING_SHELL_MARKER_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, type AppElementValue, type AppElements, type AppElementsInterception, type AppElementsSlotBinding, AppElementsWire, type AppOutgoingElements, type AppWireElements, type LayoutFlags, UNMATCHED_SLOT, buildOutgoingAppPayload, compareAppElementsSlotIds, getMountedSlotIds, getMountedSlotIdsHeader, isAppElementsRecord, normalizeAppElements, normalizeAppElementsSlotBindings, readAppElementsMetadata, resolveVisitedResponseInterceptionContext, withLayoutFlags };

package/dist/server/app-elements.js

@@ -1,4 +1,4 @@
-import { 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, AppElementsWire, UNMATCHED_SLOT, buildOutgoingAppPayload, compareAppElementsSlotIds, isAppElementsRecord, normalizeAppElements, normalizeAppElementsSlotBindings, readAppElementsMetadata, withLayoutFlags } from "./app-elements-wire.js";
+import { 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, AppElementsWire, UNMATCHED_SLOT, buildOutgoingAppPayload, compareAppElementsSlotIds, isAppElementsRecord, normalizeAppElements, normalizeAppElementsSlotBindings, readAppElementsMetadata, withLayoutFlags } from "./app-elements-wire.js";
 import { normalizeMountedSlotsHeader } from "./app-mounted-slots-header.js";
 //#region src/server/app-elements.ts
 const APP_PREFETCH_LOADING_SHELL_MARKER_KEY = "__prefetchLoadingShell";
@@ -15,6 +15,4 @@ function resolveVisitedResponseInterceptionContext(requestInterceptionContext, p
 	return payloadInterceptionContext ?? requestInterceptionContext;
 }
 //#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_PREFETCH_LOADING_SHELL_MARKER_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, AppElementsWire, UNMATCHED_SLOT, buildOutgoingAppPayload, compareAppElementsSlotIds, getMountedSlotIds, getMountedSlotIdsHeader, isAppElementsRecord, normalizeAppElements, normalizeAppElementsSlotBindings, readAppElementsMetadata, resolveVisitedResponseInterceptionContext, withLayoutFlags };
-
-//# sourceMappingURL=app-elements.js.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_PREFETCH_LOADING_SHELL_MARKER_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, AppElementsWire, UNMATCHED_SLOT, buildOutgoingAppPayload, compareAppElementsSlotIds, getMountedSlotIds, getMountedSlotIdsHeader, isAppElementsRecord, normalizeAppElements, normalizeAppElementsSlotBindings, readAppElementsMetadata, resolveVisitedResponseInterceptionContext, withLayoutFlags };

package/dist/server/app-fallback-renderer.d.ts

@@ -1,15 +1,15 @@
 import { MetadataFileRoute } from "./metadata-routes.js";
 import { AppElements } from "./app-elements-wire.js";
+import { NavigationContext } from "../shims/navigation.js";
 import { AppPageParams } from "./app-page-boundary.js";
 import { AppPageFontPreload } from "./app-page-execution.js";
 import { AppPageMiddlewareContext } from "./app-page-response.js";
 import { AppPageSsrHandler } from "./app-page-stream.js";
 import { AppPageBoundaryRoute } from "./app-page-boundary-render.js";
-import * as _$react from "react";
 import { ReactNode } from "react";
 
 //#region src/server/app-fallback-renderer.d.ts
-type AppPageComponent = _$react.ComponentType<any>;
+type AppPageComponent = import("react").ComponentType<any>;
 type AppPageModule = Record<string, unknown> & {
   default?: AppPageComponent | null | undefined;
 };
@@ -30,7 +30,7 @@ type AppFallbackRendererOptions<TModule extends AppPageModule = AppPageModule> =
   clearRequestContext: () => void;
   createRscOnErrorHandler: (request: Request, pathname: string, routePath: string) => AppPageBoundaryOnError;
   fontProviders: AppFallbackRendererFontProviders;
-  getNavigationContext: () => unknown;
+  getNavigationContext: () => NavigationContext | null;
   globalErrorModule?: TModule | null;
   /**
    * Loader for the user's `app/global-not-found.tsx` module. When provided,
@@ -74,6 +74,7 @@ type AppFallbackRenderer<TModule extends AppPageModule = AppPageModule> = {
   renderErrorBoundary: (route: AppPageBoundaryRoute<TModule> | null, error: unknown, isRscRequest: boolean, request: Request, matchedParams: AppPageParams | undefined, scriptNonce: string | undefined, middlewareContext: AppPageMiddlewareContext, callContext?: AppFallbackRendererCallContext) => Promise<Response | null>;
   renderHttpAccessFallback: (route: AppPageBoundaryRoute<TModule> | null, statusCode: number, isRscRequest: boolean, request: Request, opts: {
     boundaryComponent?: AppPageComponent | null;
+    boundaryModule?: TModule | null;
     layouts?: readonly (TModule | null | undefined)[] | null;
     matchedParams?: AppPageParams;
   }, scriptNonce: string | undefined, middlewareContext: AppPageMiddlewareContext, callContext?: AppFallbackRendererCallContext) => Promise<Response | null>;
@@ -81,5 +82,4 @@ type AppFallbackRenderer<TModule extends AppPageModule = AppPageModule> = {
 };
 declare function createAppFallbackRenderer<TModule extends AppPageModule>(options: AppFallbackRendererOptions<TModule>): AppFallbackRenderer<TModule>;
 //#endregion
-export { createAppFallbackRenderer };
-//# sourceMappingURL=app-fallback-renderer.d.ts.map
+export { createAppFallbackRenderer };

package/dist/server/app-fallback-renderer.js

@@ -20,9 +20,11 @@ function createAppFallbackRenderer(options) {
 	return {
 		async renderHttpAccessFallback(route, statusCode, isRscRequest, request, opts, scriptNonce, middlewareContext, callContext) {
 			if (statusCode === 404 && !!loadGlobalNotFoundModule && !route && !opts?.boundaryComponent) {
-				const globalNotFoundComponent = (await resolveGlobalNotFoundModule())?.default ?? null;
+				const globalNotFoundModule = await resolveGlobalNotFoundModule();
+				const globalNotFoundComponent = globalNotFoundModule?.default ?? null;
 				if (globalNotFoundComponent) return renderAppPageHttpAccessFallback({
 					boundaryComponent: globalNotFoundComponent,
+					boundaryModule: globalNotFoundModule ?? null,
 					buildFontLinkHeader: fontProviders.buildFontLinkHeader,
 					clearRequestContext,
 					createRscOnErrorHandler(pathname, routePath) {
@@ -57,6 +59,7 @@ function createAppFallbackRenderer(options) {
 			return renderAppPageHttpAccessFallback({
 				basePath,
 				boundaryComponent: opts?.boundaryComponent ?? null,
+				boundaryModule: opts?.boundaryModule ?? null,
 				buildFontLinkHeader: fontProviders.buildFontLinkHeader,
 				clearRequestContext,
 				createRscOnErrorHandler(pathname, routePath) {
@@ -124,5 +127,3 @@ function createAppFallbackRenderer(options) {
 }
 //#endregion
 export { createAppFallbackRenderer };
-
-//# sourceMappingURL=app-fallback-renderer.js.map

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

@@ -4,23 +4,83 @@ import { TraverseDirection } from "./navigation-planner.js";
 type HistoryStateRecord = {
   [key: string]: unknown;
 };
+type BfcacheIdMap = Readonly<Record<string, string>>;
 type HistoryTraversalIntent = {
   direction: TraverseDirection;
   historyState: unknown;
   targetHistoryIndex: number | null;
 };
+type HistoryStateSnapshotRestoreDecision<TState> = {
+  kind: "restore";
+  state: TState;
+  targetHistoryIndex: number;
+} | {
+  kind: "skip";
+  reason: "guarded" | "missing-history-index" | "missing-snapshot" | "stale-bfcache-version";
+  targetHistoryIndex: number | null;
+};
+declare class HistoryStateSnapshotCache<TState> {
+  #private;
+  constructor(options: {
+    maxEntries: number;
+  });
+  clear(): void;
+  remember(options: {
+    bfcacheVersion: number;
+    historyIndex: number | null;
+    state: TState;
+  }): void;
+  resolveRestore(options: {
+    currentBfcacheVersion: number;
+    guarded: boolean;
+    historyState: unknown;
+  }): HistoryStateSnapshotRestoreDecision<TState>;
+}
+declare class RestorableClientStateController<TState> {
+  #private;
+  constructor(options: {
+    initialHistoryState: unknown;
+    maxHistoryStateSnapshots: number;
+  });
+  get currentBfcacheVersion(): number;
+  beginCacheInvalidationGuard(): () => void;
+  isCacheInvalidationGuarded(): boolean;
+  isCurrentBfcacheVersion(historyState: unknown): boolean;
+  readCurrentBfcacheVersionHistoryIds(historyState: unknown): BfcacheIdMap | null;
+  invalidateClientState(): void;
+  rememberHistoryStateSnapshot(options: {
+    historyIndex: number | null;
+    state: TState;
+  }): void;
+  resolveHistoryStateSnapshotRestore(historyState: unknown): HistoryStateSnapshotRestoreDecision<TState>;
+}
 declare function createHistoryStateWithPreviousNextUrl(state: unknown, previousNextUrl: string | null): HistoryStateRecord | null;
 declare function createHistoryStateWithNavigationMetadata(state: unknown, metadata: {
+  bfcacheIds?: BfcacheIdMap | null;
+  bfcacheVersion?: number | null;
   previousNextUrl: string | null;
   traversalIndex?: number | null;
 }): HistoryStateRecord | null;
 declare function createExternalHistoryStatePreservingMetadata(callerState: unknown, currentHistoryState: unknown): unknown;
 declare function readHistoryStatePreviousNextUrl(state: unknown): string | null;
+declare function isBfcacheSegmentId(id: string): boolean;
+declare function readHistoryStateBfcacheIds(state: unknown): BfcacheIdMap | null;
+declare function readHistoryStateBfcacheVersion(state: unknown): number | null;
+/**
+ * Whether a history entry's stored bfcache version matches the document's
+ * current version. A missing/invalid stored version (null) is NEVER current:
+ * coercing it to 0 would let un-versioned entries (older builds / external
+ * pushState) pass the gate on a fresh document whose current version is 0,
+ * defeating the document-scoped stale-id rejection. App-written entries always
+ * carry an explicit version, so the legitimate first-document path (0 === 0)
+ * still matches.
+ */
+declare function isHistoryStateBfcacheVersionCurrent(state: unknown, currentVersion: number): boolean;
+declare function createHashOnlyHistoryStatePreservingNavigationMetadata(state: unknown): unknown;
 declare function readHistoryStateTraversalIndex(state: unknown): number | null;
 declare function resolveHistoryTraversalIntent(options: {
   currentHistoryIndex: number | null;
   historyState: unknown;
 }): HistoryTraversalIntent;
 //#endregion
-export { HistoryTraversalIntent, createExternalHistoryStatePreservingMetadata, createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent };
-//# sourceMappingURL=app-history-state.d.ts.map
+export { BfcacheIdMap, HistoryStateSnapshotCache, HistoryTraversalIntent, RestorableClientStateController, createExternalHistoryStatePreservingMetadata, createHashOnlyHistoryStatePreservingNavigationMetadata, createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, isBfcacheSegmentId, isHistoryStateBfcacheVersionCurrent, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent };

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

@@ -1,42 +1,210 @@
+import { AppElementsWire } from "./app-elements-wire.js";
+import "./app-elements.js";
+import { isNonNegativeSafeInteger } from "../utils/number.js";
 //#region src/server/app-history-state.ts
 const VINEXT_PREVIOUS_NEXT_URL_HISTORY_STATE_KEY = "__vinext_previousNextUrl";
 const VINEXT_HISTORY_INDEX_HISTORY_STATE_KEY = "__vinext_historyIndex";
+const VINEXT_BFCACHE_IDS_HISTORY_STATE_KEY = "__vinext_bfcacheIds";
+const VINEXT_BFCACHE_VERSION_HISTORY_STATE_KEY = "__vinext_bfcacheVersion";
+var HistoryStateSnapshotCache = class {
+	#maxEntries;
+	#snapshots = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.#maxEntries = options.maxEntries;
+	}
+	clear() {
+		this.#snapshots.clear();
+	}
+	remember(options) {
+		if (options.historyIndex === null) return;
+		this.#snapshots.delete(options.historyIndex);
+		this.#snapshots.set(options.historyIndex, {
+			bfcacheVersion: options.bfcacheVersion,
+			state: options.state
+		});
+		if (this.#snapshots.size <= this.#maxEntries) return;
+		const oldestIndex = this.#snapshots.keys().next().value;
+		if (typeof oldestIndex === "number") this.#snapshots.delete(oldestIndex);
+	}
+	resolveRestore(options) {
+		const targetHistoryIndex = readHistoryStateTraversalIndex(options.historyState);
+		if (targetHistoryIndex === null) return {
+			kind: "skip",
+			reason: "missing-history-index",
+			targetHistoryIndex
+		};
+		const snapshot = this.#snapshots.get(targetHistoryIndex);
+		if (!snapshot) return {
+			kind: "skip",
+			reason: "missing-snapshot",
+			targetHistoryIndex
+		};
+		if (options.guarded) return {
+			kind: "skip",
+			reason: "guarded",
+			targetHistoryIndex
+		};
+		if (snapshot.bfcacheVersion !== options.currentBfcacheVersion) {
+			this.#snapshots.delete(targetHistoryIndex);
+			return {
+				kind: "skip",
+				reason: "stale-bfcache-version",
+				targetHistoryIndex
+			};
+		}
+		return {
+			kind: "restore",
+			state: snapshot.state,
+			targetHistoryIndex
+		};
+	}
+};
+var RestorableClientStateController = class {
+	#currentBfcacheVersion;
+	#pendingCacheInvalidationGuards = 0;
+	#snapshots;
+	constructor(options) {
+		const initialHistoryBfcacheVersion = readHistoryStateBfcacheVersion(options.initialHistoryState);
+		this.#currentBfcacheVersion = initialHistoryBfcacheVersion === null ? 0 : initialHistoryBfcacheVersion + 1;
+		this.#snapshots = new HistoryStateSnapshotCache({ maxEntries: options.maxHistoryStateSnapshots });
+	}
+	get currentBfcacheVersion() {
+		return this.#currentBfcacheVersion;
+	}
+	beginCacheInvalidationGuard() {
+		this.#pendingCacheInvalidationGuards += 1;
+		let released = false;
+		return () => {
+			if (released) return;
+			released = true;
+			this.#pendingCacheInvalidationGuards = Math.max(0, this.#pendingCacheInvalidationGuards - 1);
+		};
+	}
+	isCacheInvalidationGuarded() {
+		return this.#pendingCacheInvalidationGuards > 0;
+	}
+	isCurrentBfcacheVersion(historyState) {
+		return isHistoryStateBfcacheVersionCurrent(historyState, this.#currentBfcacheVersion);
+	}
+	readCurrentBfcacheVersionHistoryIds(historyState) {
+		if (this.isCacheInvalidationGuarded()) return null;
+		const ids = readHistoryStateBfcacheIds(historyState);
+		if (ids === null) return null;
+		return this.isCurrentBfcacheVersion(historyState) ? ids : null;
+	}
+	#invalidateBfcacheIds() {
+		this.#currentBfcacheVersion += 1;
+	}
+	invalidateClientState() {
+		this.#snapshots.clear();
+		this.#invalidateBfcacheIds();
+	}
+	rememberHistoryStateSnapshot(options) {
+		this.#snapshots.remember({
+			bfcacheVersion: this.#currentBfcacheVersion,
+			historyIndex: options.historyIndex,
+			state: options.state
+		});
+	}
+	resolveHistoryStateSnapshotRestore(historyState) {
+		return this.#snapshots.resolveRestore({
+			currentBfcacheVersion: this.#currentBfcacheVersion,
+			guarded: this.isCacheInvalidationGuarded(),
+			historyState
+		});
+	}
+};
 function cloneHistoryState(state) {
 	if (!state || typeof state !== "object") return {};
 	const nextState = {};
 	for (const [key, value] of Object.entries(state)) nextState[key] = value;
 	return nextState;
 }
+function readHistoryStateRecord(state) {
+	if (!state || typeof state !== "object" || Array.isArray(state)) return null;
+	return state;
+}
 function createHistoryStateWithPreviousNextUrl(state, previousNextUrl) {
 	return createHistoryStateWithNavigationMetadata(state, { previousNextUrl });
 }
 function createHistoryStateWithNavigationMetadata(state, metadata) {
 	const nextState = cloneHistoryState(state);
+	const bfcacheIdsWereCleared = metadata.bfcacheIds !== void 0 && (metadata.bfcacheIds === null || Object.keys(metadata.bfcacheIds).length === 0);
 	if (metadata.previousNextUrl === null) delete nextState[VINEXT_PREVIOUS_NEXT_URL_HISTORY_STATE_KEY];
 	else nextState[VINEXT_PREVIOUS_NEXT_URL_HISTORY_STATE_KEY] = metadata.previousNextUrl;
-	if (metadata.traversalIndex !== void 0) if (isValidHistoryTraversalIndex(metadata.traversalIndex)) nextState[VINEXT_HISTORY_INDEX_HISTORY_STATE_KEY] = metadata.traversalIndex;
+	if (metadata.traversalIndex !== void 0) if (isNonNegativeSafeInteger(metadata.traversalIndex)) nextState[VINEXT_HISTORY_INDEX_HISTORY_STATE_KEY] = metadata.traversalIndex;
 	else delete nextState[VINEXT_HISTORY_INDEX_HISTORY_STATE_KEY];
+	if (metadata.bfcacheIds !== void 0) if (bfcacheIdsWereCleared) {
+		delete nextState[VINEXT_BFCACHE_IDS_HISTORY_STATE_KEY];
+		delete nextState[VINEXT_BFCACHE_VERSION_HISTORY_STATE_KEY];
+	} else nextState[VINEXT_BFCACHE_IDS_HISTORY_STATE_KEY] = { ...metadata.bfcacheIds };
+	if (metadata.bfcacheVersion !== void 0) if (bfcacheIdsWereCleared) delete nextState[VINEXT_BFCACHE_VERSION_HISTORY_STATE_KEY];
+	else if (isNonNegativeSafeInteger(metadata.bfcacheVersion)) nextState[VINEXT_BFCACHE_VERSION_HISTORY_STATE_KEY] = metadata.bfcacheVersion;
+	else delete nextState[VINEXT_BFCACHE_VERSION_HISTORY_STATE_KEY];
 	return Object.keys(nextState).length > 0 ? nextState : null;
 }
 function createExternalHistoryStatePreservingMetadata(callerState, currentHistoryState) {
 	const previousNextUrl = readHistoryStatePreviousNextUrl(currentHistoryState);
 	const traversalIndex = readHistoryStateTraversalIndex(currentHistoryState);
-	if (previousNextUrl === null && traversalIndex === null) return callerState;
+	const bfcacheIds = readHistoryStateBfcacheIds(currentHistoryState);
+	const bfcacheVersion = readHistoryStateBfcacheVersion(currentHistoryState);
+	if (previousNextUrl === null && traversalIndex === null && bfcacheIds === null) return callerState;
 	return createHistoryStateWithNavigationMetadata(callerState, {
+		bfcacheIds,
+		bfcacheVersion: bfcacheIds === null ? void 0 : bfcacheVersion,
 		previousNextUrl,
 		traversalIndex
 	});
 }
 function readHistoryStatePreviousNextUrl(state) {
-	const value = cloneHistoryState(state)[VINEXT_PREVIOUS_NEXT_URL_HISTORY_STATE_KEY];
+	const value = readHistoryStateRecord(state)?.[VINEXT_PREVIOUS_NEXT_URL_HISTORY_STATE_KEY];
 	return typeof value === "string" ? value : null;
 }
-function isValidHistoryTraversalIndex(value) {
-	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+function isBfcacheSegmentId(id) {
+	const parsed = AppElementsWire.parseElementKey(id);
+	return parsed?.kind === "layout" || parsed?.kind === "page" || parsed?.kind === "slot" || parsed?.kind === "template";
+}
+function readHistoryStateBfcacheIds(state) {
+	const value = readHistoryStateRecord(state)?.[VINEXT_BFCACHE_IDS_HISTORY_STATE_KEY];
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	const ids = {};
+	for (const [key, id] of Object.entries(value)) {
+		if (!isBfcacheSegmentId(key) || typeof id !== "string") return null;
+		ids[key] = id;
+	}
+	return ids;
+}
+function readHistoryStateBfcacheVersion(state) {
+	const value = readHistoryStateRecord(state)?.[VINEXT_BFCACHE_VERSION_HISTORY_STATE_KEY];
+	return isNonNegativeSafeInteger(value) ? value : null;
+}
+/**
+* Whether a history entry's stored bfcache version matches the document's
+* current version. A missing/invalid stored version (null) is NEVER current:
+* coercing it to 0 would let un-versioned entries (older builds / external
+* pushState) pass the gate on a fresh document whose current version is 0,
+* defeating the document-scoped stale-id rejection. App-written entries always
+* carry an explicit version, so the legitimate first-document path (0 === 0)
+* still matches.
+*/
+function isHistoryStateBfcacheVersionCurrent(state, currentVersion) {
+	const version = readHistoryStateBfcacheVersion(state);
+	return version !== null && version === currentVersion;
+}
+function createHashOnlyHistoryStatePreservingNavigationMetadata(state) {
+	const previousNextUrl = readHistoryStatePreviousNextUrl(state);
+	const bfcacheIds = readHistoryStateBfcacheIds(state);
+	const bfcacheVersion = readHistoryStateBfcacheVersion(state);
+	if (previousNextUrl === null && bfcacheIds === null) return null;
+	return createHistoryStateWithNavigationMetadata(null, {
+		bfcacheIds,
+		bfcacheVersion: bfcacheIds === null ? void 0 : bfcacheVersion,
+		previousNextUrl
+	});
 }
 function readHistoryStateTraversalIndex(state) {
-	const value = cloneHistoryState(state)[VINEXT_HISTORY_INDEX_HISTORY_STATE_KEY];
-	return isValidHistoryTraversalIndex(value) ? value : null;
+	const value = readHistoryStateRecord(state)?.[VINEXT_HISTORY_INDEX_HISTORY_STATE_KEY];
+	return isNonNegativeSafeInteger(value) ? value : null;
 }
 function resolveHistoryTraversalIntent(options) {
 	const targetHistoryIndex = readHistoryStateTraversalIndex(options.historyState);
@@ -52,6 +220,4 @@ function resolveHistoryTraversalIntent(options) {
 	};
 }
 //#endregion
-export { createExternalHistoryStatePreservingMetadata, createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent };
-
-//# sourceMappingURL=app-history-state.js.map
+export { HistoryStateSnapshotCache, RestorableClientStateController, createExternalHistoryStatePreservingMetadata, createHashOnlyHistoryStatePreservingNavigationMetadata, createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, isBfcacheSegmentId, isHistoryStateBfcacheVersionCurrent, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent };

package/dist/server/app-hook-warning-suppression.d.ts

@@ -3,5 +3,4 @@ import { AsyncLocalStorage } from "node:async_hooks";
 //#region src/server/app-hook-warning-suppression.d.ts
 declare const suppressHookWarningAls: AsyncLocalStorage<boolean>;
 //#endregion
-export { suppressHookWarningAls };
-//# sourceMappingURL=app-hook-warning-suppression.d.ts.map
+export { suppressHookWarningAls };

package/dist/server/app-hook-warning-suppression.js

@@ -8,5 +8,3 @@ console.error = (...args) => {
 };
 //#endregion
 export { suppressHookWarningAls };
-
-//# sourceMappingURL=app-hook-warning-suppression.js.map

package/dist/server/app-inline-css-client.d.ts

@@ -3,5 +3,4 @@ type InlineCssStylesheetLinkElement = Pick<HTMLLinkElement, "getAttribute" | "ha
 declare function isInlineCssStylesheetLinkElement(link: InlineCssStylesheetLinkElement): boolean;
 declare function removeStylesheetLinksCoveredByInlineCss(): void;
 //#endregion
-export { isInlineCssStylesheetLinkElement, removeStylesheetLinksCoveredByInlineCss };
-//# sourceMappingURL=app-inline-css-client.d.ts.map
+export { isInlineCssStylesheetLinkElement, removeStylesheetLinksCoveredByInlineCss };

package/dist/server/app-inline-css-client.js

@@ -33,5 +33,3 @@ function removeStylesheetLinksCoveredByInlineCss() {
 }
 //#endregion
 export { isInlineCssStylesheetLinkElement, removeStylesheetLinksCoveredByInlineCss };
-
-//# sourceMappingURL=app-inline-css-client.js.map

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

@@ -29,5 +29,4 @@
  */
 declare function normalizeInterceptionContextHeader(raw: string | null | undefined): string | null;
 //#endregion
-export { normalizeInterceptionContextHeader };
-//# sourceMappingURL=app-interception-context-header.d.ts.map
+export { normalizeInterceptionContextHeader };

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

@@ -40,5 +40,3 @@ function normalizeInterceptionContextHeader(raw) {
 }
 //#endregion
 export { normalizeInterceptionContextHeader };
-
-//# sourceMappingURL=app-interception-context-header.js.map