@qzsy/vinext 0.1.7

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

@@ -0,0 +1,315 @@
+import { normalizePathnameForRouteMatch } 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 { createRscRequestHeaders } from "./app-rsc-cache-busting.js";
+import { createCacheEntryReuseProof } from "./cache-proof.js";
+import { createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, isHistoryStateBfcacheVersionCurrent, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, 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 { createBfcacheSegmentStateKeyMap, createInitialBfcacheIdMap, createNextBfcacheIdMap, preserveBfcacheIdsForMergedElements } from "./app-bfcache-identity.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" };
+function createOperationRecord(options) {
+	return {
+		id: options.id,
+		lane: options.lane,
+		startedVisibleCommitVersion: options.startedVisibleCommitVersion,
+		state: "pending"
+	};
+}
+function isCacheRestorableAppPayloadMetadata(metadata) {
+	return metadata.cacheEntryReuseProof !== void 0 && metadata.skippedLayoutIds.length === 0;
+}
+function requiresCacheEntryReuseProof(origin) {
+	switch (origin.origin) {
+		case "fresh": return false;
+		case "visited-cache": return true;
+		default: throw new Error("[vinext] Unknown App Router payload origin: " + String(origin));
+	}
+}
+function normalizeNavigationSnapshotMatchedUrl(pathname) {
+	return normalizePath(normalizePathnameForRouteMatch(pathname));
+}
+function createRouteSnapshotRouteId(options) {
+	if (options.interception !== null) return options.routeId;
+	const parsed = AppElementsWire.parseElementKey(options.routeId);
+	if (parsed?.kind !== "route" || parsed.interceptionContext === null) return options.routeId;
+	return AppElementsWire.encodeRouteId(parsed.path, null);
+}
+function resolveInterceptionContextFromPreviousNextUrl(previousNextUrl, basePath = "") {
+	if (previousNextUrl === null) return null;
+	return stripBasePath(new URL(previousNextUrl, "http://localhost").pathname, basePath);
+}
+/**
+* Pure: builds the fetch Headers for a server-action POST. Carries the same
+* interception-context and mounted-slots headers the refresh path already
+* sends, so the server-action re-render can rebuild the intercepted tree
+* instead of replacing it with the direct route.
+*
+* Next.js sends `Next-URL: state.previousNextUrl || state.nextUrl` on action
+* POSTs when `hasInterceptionRouteInCurrentTree(state.tree)`. Vinext's
+* X-Vinext-Interception-Context is the equivalent signal for the server-side
+* `findIntercept` lookup.
+*/
+function resolveServerActionRequestState(options) {
+	const headers = createRscRequestHeaders();
+	headers.set(RSC_ACTION_HEADER, options.actionId);
+	headers.set(NEXT_ACTION_HEADER, options.actionId);
+	const interceptionContext = resolveInterceptionContextFromPreviousNextUrl(options.previousNextUrl, options.basePath);
+	if (interceptionContext !== null) headers.set(VINEXT_INTERCEPTION_CONTEXT_HEADER, interceptionContext);
+	const mountedSlotsHeader = getMountedSlotIdsHeader(options.elements);
+	if (mountedSlotsHeader !== null) headers.set(VINEXT_MOUNTED_SLOTS_HEADER, mountedSlotsHeader);
+	return { headers };
+}
+function resolvePendingNavigationCommitDispositionDecision(options) {
+	const traceFields = createPendingNavigationTraceFields(options);
+	const targetSnapshot = createPendingRouteSnapshot(options.pending);
+	const verdict = verifyOperationTokenForCommit(createPendingNavigationOperationToken({
+		pending: options.pending,
+		routeManifest: options.routeManifest ?? null,
+		startedNavigationId: options.startedNavigationId,
+		targetSnapshot
+	}), {
+		activeNavigationId: options.activeNavigationId,
+		visibleCommitVersion: options.currentState.visibleCommitVersion
+	});
+	if (!verdict.authorized) return {
+		disposition: "skip",
+		preserveElementIds: [],
+		trace: createNavigationTrace(NavigationTraceReasonCodes.staleOperation, traceFields)
+	};
+	const decision = mapNavigationDecisionToPendingDisposition(planPendingRootBoundaryFlightResponse({
+		currentState: options.currentState,
+		pending: options.pending,
+		routeManifest: options.routeManifest ?? null,
+		targetHref: options.targetHref,
+		targetSnapshot,
+		token: verdict.token,
+		traceFields
+	}));
+	return mergeSkippedLayoutPreservation({
+		currentState: options.currentState,
+		decision,
+		pending: options.pending
+	});
+}
+function createPendingNavigationTraceFields(options) {
+	return {
+		...createNavigationLifecycleTraceFields({
+			activeNavigationId: options.activeNavigationId,
+			currentRootLayoutTreePath: options.currentState.rootLayoutTreePath,
+			currentVisibleCommitVersion: options.currentState.visibleCommitVersion,
+			nextRootLayoutTreePath: options.pending.rootLayoutTreePath,
+			startedNavigationId: options.startedNavigationId,
+			startedVisibleCommitVersion: options.pending.action.operation.startedVisibleCommitVersion
+		}),
+		...options.targetHref !== void 0 ? { targetHref: options.targetHref } : {}
+	};
+}
+function createMountedParallelSlotSnapshots(elements) {
+	const snapshots = [];
+	for (const slotId of getMountedSlotIds(elements)) {
+		const parsed = AppElementsWire.parseElementKey(slotId);
+		if (parsed?.kind !== "slot") continue;
+		snapshots.push({
+			ownerLayoutId: AppElementsWire.encodeLayoutId(parsed.treePath),
+			slotId
+		});
+	}
+	return snapshots;
+}
+function createVisibleRouteSnapshot(state) {
+	const displayUrl = createSnapshotPathAndSearch(state.navigationSnapshot);
+	const matchedUrl = normalizeNavigationSnapshotMatchedUrl(state.navigationSnapshot.pathname);
+	return {
+		displayUrl,
+		interception: state.interception,
+		interceptionContext: state.interceptionContext,
+		layoutIds: state.layoutIds,
+		matchedUrl,
+		mountedParallelSlots: createMountedParallelSlotSnapshots(state.elements),
+		rootBoundaryId: state.rootLayoutTreePath,
+		routeId: createRouteSnapshotRouteId({
+			interception: state.interception,
+			routeId: state.routeId
+		}),
+		slotBindings: state.slotBindings
+	};
+}
+function createPendingRouteSnapshot(pending) {
+	const displayUrl = createSnapshotPathAndSearch(pending.action.navigationSnapshot);
+	const matchedUrl = normalizeNavigationSnapshotMatchedUrl(pending.action.navigationSnapshot.pathname);
+	return {
+		displayUrl,
+		interception: pending.action.interception,
+		interceptionContext: pending.action.interceptionContext,
+		layoutIds: pending.action.layoutIds,
+		matchedUrl,
+		mountedParallelSlots: createMountedParallelSlotSnapshots(pending.action.elements),
+		rootBoundaryId: pending.rootLayoutTreePath,
+		routeId: createRouteSnapshotRouteId({
+			interception: pending.action.interception,
+			routeId: pending.routeId
+		}),
+		slotBindings: pending.action.slotBindings
+	};
+}
+function createPendingNavigationOperationToken(options) {
+	return {
+		baseVisibleCommitVersion: options.pending.action.operation.startedVisibleCommitVersion,
+		deploymentVersion: null,
+		graphVersion: options.routeManifest?.graphVersion ?? null,
+		lane: options.pending.action.operation.lane,
+		navigationId: options.startedNavigationId,
+		operationId: options.pending.action.operation.id,
+		targetSnapshotFingerprint: createRootBoundarySnapshotFingerprint(options.targetSnapshot)
+	};
+}
+function createRootBoundarySnapshotFingerprint(snapshot) {
+	return `${snapshot.routeId}|root:${snapshot.rootBoundaryId ?? "unknown"}`;
+}
+function planPendingRootBoundaryFlightResponse(options) {
+	const cacheEntryReuseProof = options.pending.cacheEntryReuseProof;
+	return navigationPlanner.plan({
+		routeManifest: options.routeManifest,
+		state: {
+			nextOperationToken: options.token,
+			traceFields: options.traceFields,
+			visibleCommitVersion: options.currentState.visibleCommitVersion,
+			visibleSnapshot: createVisibleRouteSnapshot(options.currentState)
+		},
+		event: {
+			kind: "flightResponseArrived",
+			result: {
+				...cacheEntryReuseProof ? { cacheEntryReuseProof } : {},
+				href: options.targetHref ?? options.targetSnapshot.displayUrl,
+				targetSnapshot: options.targetSnapshot
+			},
+			token: options.token
+		}
+	});
+}
+function mapNavigationDecisionToPendingDisposition(decision) {
+	switch (decision.kind) {
+		case "proposeCommit": return {
+			disposition: "dispatch",
+			preserveAbsentSlots: decision.proposal.preserveAbsentSlots,
+			preserveElementIds: decision.proposal.preserveElementIds,
+			preservePreviousSlotIds: decision.proposal.preservePreviousSlotIds,
+			trace: decision.trace
+		};
+		case "hardNavigate": return {
+			disposition: "hard-navigate",
+			preserveElementIds: [],
+			trace: decision.trace
+		};
+		case "noCommit": return {
+			disposition: "skip",
+			preserveElementIds: [],
+			trace: decision.trace
+		};
+		case "requestWork": throw new Error(`[vinext] Root-boundary commit planning returned requestWork (${decision.work.kind}); flightResponseArrived should never request work`);
+		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);
+	const cacheEntryReuseProof = metadata.cacheEntryReuseProof ?? (requiresCacheEntryReuseProof(options.payloadOrigin) ? createCacheEntryReuseProof(null) : void 0);
+	const requestedPreviousNextUrl = options.previousNextUrl !== void 0 ? options.previousNextUrl : options.currentState.previousNextUrl;
+	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,
+			interceptionContext: metadata.interceptionContext,
+			layoutIds: metadata.layoutIds,
+			layoutFlags: metadata.layoutFlags,
+			slotBindings: metadata.slotBindings,
+			navigationSnapshot: options.navigationSnapshot,
+			operation: createOperationRecord({
+				id: options.renderId,
+				lane: options.operationLane,
+				startedVisibleCommitVersion: options.currentState.visibleCommitVersion
+			}),
+			previousNextUrl,
+			renderId: options.renderId,
+			rootLayoutTreePath: metadata.rootLayoutTreePath,
+			reuseCurrentBfcacheIds: options.reuseCurrentBfcacheIds ?? true,
+			routeId: metadata.routeId,
+			skippedLayoutIds: metadata.skippedLayoutIds,
+			type: options.type
+		},
+		...cacheEntryReuseProof ? { cacheEntryReuseProof } : {},
+		interception: metadata.interception,
+		interceptionContext: metadata.interceptionContext,
+		previousNextUrl,
+		rootLayoutTreePath: metadata.rootLayoutTreePath,
+		routeId: metadata.routeId,
+		skippedLayoutIds: metadata.skippedLayoutIds
+	};
+}
+//#endregion
+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

@@ -0,0 +1,28 @@
+import { NavigationRuntimeSnapshot } from "../client/navigation-runtime.js";
+import { RSC_FORM_STATE_GLOBAL } from "./app-browser-hydration.js";
+import { RscEmbeddedChunk } from "./app-rsc-embedded-chunks.js";
+import { ReactFormState } from "react-dom/client";
+
+//#region src/server/app-browser-stream.d.ts
+type VinextBrowserGlobals = {
+  __VINEXT_RSC_CHUNKS__?: RscEmbeddedChunk[];
+  __VINEXT_RSC_DONE__?: boolean;
+  [RSC_FORM_STATE_GLOBAL]?: ReactFormState;
+  __VINEXT_RSC_PARAMS__?: Record<string, string | string[]>;
+  __VINEXT_RSC_NAV__?: NavigationRuntimeSnapshot;
+};
+declare function getVinextBrowserGlobal(): typeof globalThis & VinextBrowserGlobals;
+/**
+ * Convert embedded chunks back to a ReadableStream of Uint8Array chunks.
+ */
+declare function chunksToReadableStream(chunks: readonly RscEmbeddedChunk[]): ReadableStream<Uint8Array>;
+/**
+ * Create a ReadableStream from progressively-embedded RSC chunks.
+ *
+ * The server pushes chunks into the typed navigation runtime via inline
+ * <script> tags. We monkey-patch `push()` so new chunks stream to React
+ * immediately instead of polling with setTimeout.
+ */
+declare function createProgressiveRscStream(): ReadableStream<Uint8Array>;
+//#endregion
+export { chunksToReadableStream, createProgressiveRscStream, getVinextBrowserGlobal };

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

@@ -0,0 +1,122 @@
+import { decodeRscEmbeddedChunk } from "./app-rsc-embedded-chunks.js";
+import { ensureNavigationRuntimeRscBootstrap, getNavigationRuntime } from "../client/navigation-runtime.js";
+//#region src/server/app-browser-stream.ts
+function getVinextBrowserGlobal() {
+	return globalThis;
+}
+function createUnexpectedRscStreamCloseError() {
+	return /* @__PURE__ */ new Error("The connection to the page was unexpectedly closed, possibly due to the stop button being clicked, loss of Wi-Fi, or an unstable internet connection.");
+}
+/**
+* Convert embedded chunks back to a ReadableStream of Uint8Array chunks.
+*/
+function chunksToReadableStream(chunks) {
+	return new ReadableStream({ start(controller) {
+		for (const chunk of chunks) controller.enqueue(decodeRscEmbeddedChunk(chunk));
+		controller.close();
+	} });
+}
+function getNavigationRuntimeRscBootstrap() {
+	return getNavigationRuntime()?.bootstrap.rsc ?? null;
+}
+/**
+* Create a ReadableStream from progressively-embedded RSC chunks.
+*
+* The server pushes chunks into the typed navigation runtime via inline
+* <script> tags. We monkey-patch `push()` so new chunks stream to React
+* immediately instead of polling with setTimeout.
+*/
+function createProgressiveRscStream() {
+	let cancelStream;
+	return new ReadableStream({
+		start(controller) {
+			const vinext = getVinextBrowserGlobal();
+			const runtimeRsc = getNavigationRuntimeRscBootstrap();
+			const initialChunks = runtimeRsc?.rsc ?? vinext.__VINEXT_RSC_CHUNKS__ ?? [];
+			for (const chunk of initialChunks) controller.enqueue(decodeRscEmbeddedChunk(chunk));
+			if (runtimeRsc?.done || vinext.__VINEXT_RSC_DONE__) {
+				controller.close();
+				return;
+			}
+			let closed = false;
+			let cancelDocumentCompletionCheck;
+			const cancelPendingDocumentCompletionCheck = () => {
+				const cancel = cancelDocumentCompletionCheck;
+				cancelDocumentCompletionCheck = void 0;
+				cancel?.();
+			};
+			const closeOnce = () => {
+				if (!closed) {
+					closed = true;
+					cancelPendingDocumentCompletionCheck();
+					controller.close();
+				}
+			};
+			const scheduleCloseOnce = () => {
+				if (typeof queueMicrotask === "function") queueMicrotask(closeOnce);
+				else Promise.resolve().then(closeOnce);
+			};
+			const errorOnce = () => {
+				if (!closed) {
+					closed = true;
+					cancelPendingDocumentCompletionCheck();
+					controller.error(createUnexpectedRscStreamCloseError());
+				}
+			};
+			cancelStream = () => {
+				if (!closed) {
+					closed = true;
+					cancelPendingDocumentCompletionCheck();
+				}
+			};
+			const liveRuntimeRsc = getNavigationRuntime() === null ? null : ensureNavigationRuntimeRscBootstrap();
+			const arr = liveRuntimeRsc?.rsc ?? (vinext.__VINEXT_RSC_CHUNKS__ ??= []);
+			arr.push = function(...chunks) {
+				const length = Array.prototype.push.apply(this, chunks);
+				if (closed) return length;
+				for (const chunk of chunks) controller.enqueue(decodeRscEmbeddedChunk(chunk));
+				if (liveRuntimeRsc?.done || vinext.__VINEXT_RSC_DONE__) closeOnce();
+				return length;
+			};
+			if (liveRuntimeRsc) {
+				let done = Boolean(liveRuntimeRsc.done);
+				Object.defineProperty(liveRuntimeRsc, "done", {
+					configurable: true,
+					enumerable: true,
+					get() {
+						return done;
+					},
+					set(value) {
+						done = Boolean(value);
+						if (done) scheduleCloseOnce();
+					}
+				});
+			} else {
+				let done = Boolean(vinext.__VINEXT_RSC_DONE__);
+				Object.defineProperty(vinext, "__VINEXT_RSC_DONE__", {
+					configurable: true,
+					enumerable: true,
+					get() {
+						return done;
+					},
+					set(value) {
+						done = Boolean(value);
+						if (done) scheduleCloseOnce();
+					}
+				});
+			}
+			if (typeof document !== "undefined") if (document.readyState === "loading") {
+				document.addEventListener("DOMContentLoaded", errorOnce);
+				cancelDocumentCompletionCheck = () => document.removeEventListener("DOMContentLoaded", errorOnce);
+			} else {
+				const timeoutId = setTimeout(errorOnce);
+				cancelDocumentCompletionCheck = () => clearTimeout(timeoutId);
+			}
+		},
+		cancel() {
+			cancelStream?.();
+		}
+	});
+}
+//#endregion
+export { chunksToReadableStream, createProgressiveRscStream, getVinextBrowserGlobal };

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

@@ -0,0 +1,78 @@
+import { RouteManifest } from "../routing/app-route-graph.js";
+import { AppElements } from "./app-elements-wire.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 = {
+  disposition: "commit";
+  preserveAbsentSlots: boolean;
+  preserveElementIds: readonly string[];
+  preservePreviousSlotIds: readonly string[];
+  trace: NavigationTrace;
+};
+type HardNavigateCommitDecision = {
+  disposition: "hard-navigate";
+  trace: NavigationTrace;
+};
+type NoCommitDecision = {
+  disposition: "no-commit";
+  trace: NavigationTrace;
+};
+type CommitDecision = VisibleCommitDecision | HardNavigateCommitDecision | NoCommitDecision;
+declare const approvedVisibleCommitBrand: unique symbol;
+type ApprovedVisibleCommit = {
+  readonly [approvedVisibleCommitBrand]: true;
+  readonly action: AppRouterAction;
+  readonly decision: VisibleCommitDecision;
+  readonly interception: AppRouterAction["interception"];
+  readonly interceptionContext: string | null;
+  readonly previousNextUrl: string | null;
+  readonly rootLayoutTreePath: string | null;
+  readonly routeId: string;
+};
+type VisibleCommitApproval = {
+  approvedCommit: ApprovedVisibleCommit;
+  decision: VisibleCommitDecision;
+};
+type NonVisibleCommitApproval = {
+  approvedCommit: null;
+  decision: HardNavigateCommitDecision | NoCommitDecision;
+};
+type CommitApproval = VisibleCommitApproval | NonVisibleCommitApproval;
+type ClassifiedPendingNavigationCommit = {
+  approvedCommit: ApprovedVisibleCommit | null;
+  decision: CommitDecision;
+  pending: PendingNavigationCommit;
+  trace: NavigationTrace;
+};
+declare function applyApprovedVisibleCommit(state: AppRouterState, commit: ApprovedVisibleCommit): AppRouterState;
+declare function approveHmrVisibleCommit(pending: PendingNavigationCommit): ApprovedVisibleCommit;
+declare function approvePendingNavigationCommit(options: {
+  activeNavigationId: number;
+  currentState: AppRouterState;
+  pending: PendingNavigationCommit;
+  routeManifest?: RouteManifest | null;
+  startedNavigationId: number;
+  targetHref: string;
+}): CommitApproval;
+declare function resolveAndClassifyNavigationCommit(options: {
+  activeNavigationId: number;
+  currentState: AppRouterState;
+  getActiveNavigationId?: () => number;
+  getCurrentStateForApproval?: () => AppRouterState;
+  navigationSnapshot: ClientNavigationRenderSnapshot;
+  nextElements: Promise<AppElements>;
+  operationLane: OperationLane;
+  payloadOrigin: AppNavigationPayloadOrigin;
+  previousNextUrl?: string | null;
+  renderId: number;
+  routeManifest?: RouteManifest | null;
+  startedNavigationId: number;
+  targetHref: string;
+  type: "navigate" | "replace" | "traverse";
+}): Promise<ClassifiedPendingNavigationCommit>;
+//#endregion
+export { ApprovedVisibleCommit, applyApprovedVisibleCommit, approveHmrVisibleCommit, approvePendingNavigationCommit, resolveAndClassifyNavigationCommit };