@seams/wallet 0.7.1 → 0.8.0

package/dist/esm/sdk/NonceCoordinator-4XWPhYww.js

@@ -1,2253 +0,0 @@
-import { E as isImplicitNearAccountId, p as isString, u as isObject } from "./validation-gat4LEKm.js";
-import { t as errorMessage } from "./errors-93h9uAW9.js";
-import { t as toAccountId } from "./accountIds-DhIPGOSN.js";
-import { r as SigningSessionIds } from "./types-Dx9fczU7.js";
-import { _ as NonceCoordinatorDegradationReason, a as createRuntimeId, b as NonceDurableLeaseState, d as nonceLaneNetworkKey, f as nonceLaneSubjectId, g as NearNonceReconcileReason, h as NONCE_LEASE_STATES, i as createNonceLeaseId, m as EvmNonceOutcomeReason, n as assertOperationMatches, o as evmLaneToReserveNonceInput, r as createNonceBatchId, t as assertEvmLease, u as nonceLaneKey, v as NonceCoordinatorFallback, x as NonceLeaseState, y as NonceCoordinatorTraceEventName } from "./nonceLaneKeys-C3c9lG6u.js";
-//#region src/core/signingEngine/nonce/nonceLeaseState.ts
-function reduceNonceLeaseState(current, transition) {
-	const result = tryReduceNonceLeaseState(current, transition);
-	if (result.ok) return result.state;
-	throw createIllegalNonceTransitionError(result.current, result.transition);
-}
-function tryReduceNonceLeaseState(current, transition) {
-	switch (transition) {
-		case "release": return reduceReleaseNonceLeaseState(current);
-		case "expire": return reduceExpireNonceLeaseState(current);
-		case "mark_signed": return reduceMarkSignedNonceLeaseState(current);
-		case "broadcast_accepted": return reduceBroadcastAcceptedNonceLeaseState(current);
-		case "broadcast_rejected": return reduceBroadcastRejectedNonceLeaseState(current);
-		case "finalize": return reduceFinalizeNonceLeaseState(current);
-		case "drop": return reduceDropNonceLeaseState(current);
-		case "replace": return reduceReplaceNonceLeaseState(current);
-		case "reconcile": return reduceReconcileNonceLeaseState(current);
-		default: return assertNeverNonceLeaseTransition(transition);
-	}
-}
-function reduceReleaseNonceLeaseState(current) {
-	switch (current) {
-		case NonceLeaseState.Released: return acceptedNonceTransition(current);
-		case NonceLeaseState.Reserved: return acceptedNonceTransition(NonceLeaseState.Released);
-		default: return rejectedNonceTransition(current, "release");
-	}
-}
-function reduceExpireNonceLeaseState(current) {
-	switch (current) {
-		case NonceLeaseState.Reserved: return acceptedNonceTransition(NonceLeaseState.Expired);
-		case NonceLeaseState.Signed: return acceptedNonceTransition(NonceLeaseState.SignedLeaseExpired);
-		case NonceLeaseState.Expired:
-		case NonceLeaseState.SignedLeaseExpired: return acceptedNonceTransition(current);
-		default: return rejectedNonceTransition(current, "expire");
-	}
-}
-function reduceMarkSignedNonceLeaseState(current) {
-	switch (current) {
-		case NonceLeaseState.Reserved:
-		case NonceLeaseState.Signed: return acceptedNonceTransition(NonceLeaseState.Signed);
-		default: return rejectedNonceTransition(current, "mark_signed");
-	}
-}
-function reduceBroadcastAcceptedNonceLeaseState(current) {
-	switch (current) {
-		case NonceLeaseState.Signed:
-		case NonceLeaseState.BroadcastAccepted: return acceptedNonceTransition(NonceLeaseState.BroadcastAccepted);
-		default: return rejectedNonceTransition(current, "broadcast_accepted");
-	}
-}
-function reduceBroadcastRejectedNonceLeaseState(current) {
-	switch (current) {
-		case NonceLeaseState.Signed:
-		case NonceLeaseState.BroadcastRejected: return acceptedNonceTransition(NonceLeaseState.BroadcastRejected);
-		default: return rejectedNonceTransition(current, "broadcast_rejected");
-	}
-}
-function reduceFinalizeNonceLeaseState(current) {
-	switch (current) {
-		case NonceLeaseState.BroadcastAccepted:
-		case NonceLeaseState.Finalized: return acceptedNonceTransition(NonceLeaseState.Finalized);
-		default: return rejectedNonceTransition(current, "finalize");
-	}
-}
-function reduceDropNonceLeaseState(current) {
-	switch (current) {
-		case NonceLeaseState.BroadcastAccepted:
-		case NonceLeaseState.Dropped: return acceptedNonceTransition(NonceLeaseState.Dropped);
-		default: return rejectedNonceTransition(current, "drop");
-	}
-}
-function reduceReplaceNonceLeaseState(current) {
-	switch (current) {
-		case NonceLeaseState.BroadcastAccepted:
-		case NonceLeaseState.Replaced: return acceptedNonceTransition(NonceLeaseState.Replaced);
-		default: return rejectedNonceTransition(current, "replace");
-	}
-}
-function reduceReconcileNonceLeaseState(current) {
-	switch (current) {
-		case NonceLeaseState.Released:
-		case NonceLeaseState.Expired:
-		case NonceLeaseState.SignedLeaseExpired:
-		case NonceLeaseState.BroadcastRejected:
-		case NonceLeaseState.Dropped:
-		case NonceLeaseState.Replaced:
-		case NonceLeaseState.Reconciled: return acceptedNonceTransition(NonceLeaseState.Reconciled);
-		default: return rejectedNonceTransition(current, "reconcile");
-	}
-}
-function acceptedNonceTransition(state) {
-	return {
-		ok: true,
-		state
-	};
-}
-function rejectedNonceTransition(current, transition) {
-	return {
-		ok: false,
-		current,
-		transition,
-		reason: "illegal_transition"
-	};
-}
-function assertNeverNonceLeaseTransition(value) {
-	throw new Error(`[NonceCoordinator] unhandled nonce lease transition: ${String(value)}`);
-}
-function isInFlightNonceLeaseState(state) {
-	return state === NonceLeaseState.Reserved || state === NonceLeaseState.Signed;
-}
-function isActiveEvmLeaseState(state) {
-	return state === NonceLeaseState.Reserved || state === NonceLeaseState.Signed || state === NonceLeaseState.BroadcastAccepted;
-}
-function isActiveNearLeaseState(state) {
-	return state === NonceLeaseState.Reserved || state === NonceLeaseState.Signed || state === NonceLeaseState.BroadcastAccepted;
-}
-function isActiveCoordinationLeaseRecord(record, nowMs) {
-	if (record.state === NonceDurableLeaseState.BroadcastAccepted) return true;
-	return (record.state === NonceDurableLeaseState.Reserved || record.state === NonceDurableLeaseState.Signed) && record.expiresAtMs > nowMs;
-}
-function createIllegalNonceTransitionError(current, transition) {
-	return /* @__PURE__ */ new Error(`[NonceCoordinator] illegal nonce lease transition: ${current} -> ${transition}`);
-}
-//#endregion
-//#region src/core/signingEngine/nonce/nonceUtils.ts
-function normalizeSessionStatusRequiredString(value, label) {
-	const normalized = String(value || "").trim();
-	if (!normalized) throw new Error(`[NonceCoordinator] ${label} is required`);
-	return normalized;
-}
-function normalizeBigint(value, label) {
-	try {
-		if (typeof value === "bigint") return value;
-		if (typeof value === "number" && Number.isSafeInteger(value)) return BigInt(value);
-		const normalized = String(value || "").trim();
-		if (/^\d+$/.test(normalized)) return BigInt(normalized);
-	} catch {}
-	throw new Error(`[NonceCoordinator] invalid ${label}`);
-}
-function normalizePositiveInteger(value, fallback) {
-	const parsed = Math.floor(Number(value));
-	return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
-}
-function normalizeMetricReason(value, fallback) {
-	return String(value || "").trim().toLowerCase().replace(/[^a-z0-9_]+/g, "_").replace(/^_+|_+$/g, "") || fallback;
-}
-function maxBigint(...values) {
-	if (values.length === 0) return 0n;
-	return values.reduce((max, value) => max > value ? max : value);
-}
-function minBigint(a, b) {
-	return a < b ? a : b;
-}
-//#endregion
-//#region src/core/signingEngine/nonce/evmNonceLane.ts
-function createEvmNonceLaneState() {
-	return {
-		chainNonce: null,
-		nextCandidate: null,
-		inFlight: /* @__PURE__ */ new Map(),
-		lastRefreshMs: null,
-		inflightRefresh: null
-	};
-}
-function getOrCreateEvmNonceLaneState(states, laneKey) {
-	const existing = states.get(laneKey);
-	if (existing) return existing;
-	const created = createEvmNonceLaneState();
-	states.set(laneKey, created);
-	return created;
-}
-function indexEvmNonceLaneBySubject(input) {
-	const accountId = String(input.lane.subjectId || "").trim();
-	if (!accountId) return;
-	const keys = input.accountLaneKeys.get(accountId);
-	if (!keys) {
-		input.accountLaneKeys.set(accountId, new Set([input.laneKey]));
-		return;
-	}
-	keys.add(input.laneKey);
-}
-async function refreshEvmLaneFromChainLocked(input) {
-	const { state } = input;
-	if (state.inflightRefresh) return await state.inflightRefresh;
-	const refreshTask = (async () => {
-		const chainNextNonceRaw = await input.fetchChainNonce(input.lane);
-		const chainNextNonce = chainNextNonceRaw >= 0n ? chainNextNonceRaw : 0n;
-		const activeLeaseNonces = await input.readActiveLeaseNonces({
-			chainNextNonce,
-			lane: input.lane
-		});
-		let highestActiveLease = 0n;
-		for (const nonce of activeLeaseNonces) {
-			const value = BigInt(nonce);
-			if (value > highestActiveLease) highestActiveLease = value;
-		}
-		let highestInFlight = 0n;
-		const prunedInFlight = /* @__PURE__ */ new Map();
-		for (const [key, record] of state.inFlight.entries()) {
-			if (record.nonce < chainNextNonce) continue;
-			prunedInFlight.set(key, record);
-			if (record.nonce > highestInFlight) highestInFlight = record.nonce;
-		}
-		state.inFlight = prunedInFlight;
-		state.nextCandidate = maxBigint(0n, chainNextNonce, activeLeaseNonces.size > 0 || prunedInFlight.size > 0 ? state.nextCandidate || 0n : 0n, highestActiveLease > 0n ? highestActiveLease + 1n : 0n, highestInFlight > 0n ? highestInFlight + 1n : 0n);
-		state.chainNonce = chainNextNonce;
-		state.lastRefreshMs = input.nowMs;
-		return chainNextNonce;
-	})();
-	state.inflightRefresh = refreshTask;
-	try {
-		return await refreshTask;
-	} finally {
-		if (state.inflightRefresh === refreshTask) state.inflightRefresh = null;
-	}
-}
-async function shouldRefreshEvmLane(input) {
-	if (input.state.nextCandidate == null) return true;
-	if (input.state.lastRefreshMs == null) return true;
-	if (input.state.inFlight.size > 0) return true;
-	if ((await input.readActiveLeaseNonces({ lane: input.lane })).size > 0) return false;
-	return input.nowMs - input.state.lastRefreshMs >= input.refreshTtlMs;
-}
-async function releaseEvmNonceReservationState(input) {
-	await input.removeCoordinationLease(input.lease);
-	if (!input.state) return;
-	const nonce = input.lease.nonce;
-	input.state.inFlight.delete(nonce.toString());
-	if (!((await input.readActiveLeaseNonces({
-		excludeLeaseId: input.lease.leaseId,
-		lane: input.lease.lane
-	})).size > 0) && input.state.inFlight.size === 0) input.state.lastRefreshMs = null;
-}
-async function markEvmBroadcastAcceptedState(input) {
-	const nonce = input.lease.nonce;
-	const txHash = requireEvmTransactionHash(input.txHash);
-	input.state.inFlight.set(nonce.toString(), {
-		nonce,
-		txHash,
-		status: "accepted",
-		acceptedAtMs: input.nowMs,
-		updatedAtMs: input.nowMs
-	});
-	const minNext = nonce + 1n;
-	if (input.state.nextCandidate == null || input.state.nextCandidate < minNext) input.state.nextCandidate = minNext;
-	await input.persistCoordinationLease(input.lease, {
-		state: NonceDurableLeaseState.BroadcastAccepted,
-		txHash
-	}, input.nowMs + input.staleInFlightThresholdMs);
-}
-function requireEvmTransactionHash(value) {
-	const normalized = String(value || "").trim().toLowerCase();
-	if (!/^0x[0-9a-f]{64}$/.test(normalized)) throw new Error("[NonceCoordinator] EVM broadcast acceptance requires txHash");
-	return normalized;
-}
-async function markEvmFinalizedState(input) {
-	const nonce = input.lease.nonce;
-	input.state.inFlight.delete(nonce.toString());
-	const minNext = nonce + 1n;
-	input.state.chainNonce = input.state.chainNonce == null ? minNext : maxBigint(input.state.chainNonce, minNext);
-	if (input.state.nextCandidate == null || input.state.nextCandidate < minNext) input.state.nextCandidate = minNext;
-	input.state.lastRefreshMs = input.nowMs;
-	await input.removeCoordinationLease(input.lease);
-}
-async function markEvmDroppedOrReplacedState(input) {
-	const nonce = input.lease.nonce;
-	if (input.outcome.reason === EvmNonceOutcomeReason.Dropped) {
-		input.state.inFlight.delete(nonce.toString());
-		if (input.state.chainNonce == null || input.state.chainNonce <= nonce) input.state.nextCandidate = input.state.nextCandidate == null ? nonce : minBigint(input.state.nextCandidate, nonce);
-	} else {
-		const previous = input.state.inFlight.get(nonce.toString());
-		input.state.inFlight.set(nonce.toString(), {
-			nonce,
-			...input.outcome.txHash ? { txHash: input.outcome.txHash } : previous?.txHash ? { txHash: previous.txHash } : {},
-			status: "replaced",
-			acceptedAtMs: previous?.acceptedAtMs ?? input.nowMs,
-			updatedAtMs: input.nowMs
-		});
-	}
-	input.state.lastRefreshMs = null;
-	await input.removeCoordinationLease(input.lease);
-}
-async function reconcileEvmLaneState(input) {
-	const chainNextNonce = await input.refreshFromChain(input.lane, input.state);
-	const unresolvedInFlightNonces = Array.from(input.state.inFlight.values()).map((entry) => entry.nonce).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
-	const blockedState = readBlockedEvmInFlight({
-		state: input.state,
-		nowMs: input.nowMs,
-		staleInFlightThresholdMs: input.staleInFlightThresholdMs
-	});
-	return {
-		chainNextNonce,
-		unresolvedInFlightNonces,
-		blocked: !!blockedState,
-		...blockedState ? { blockedNonce: blockedState.blockedNonce } : {}
-	};
-}
-function readBlockedEvmInFlight(input) {
-	const { state } = input;
-	if (state.inFlight.size === 0) return null;
-	if (state.chainNonce == null) return null;
-	let oldestNonce = null;
-	let oldestUpdatedAtMs = null;
-	for (const record of state.inFlight.values()) if (oldestNonce == null || record.nonce < oldestNonce) {
-		oldestNonce = record.nonce;
-		oldestUpdatedAtMs = record.updatedAtMs;
-	}
-	if (oldestNonce == null || oldestUpdatedAtMs == null) return null;
-	if (state.chainNonce > oldestNonce) return null;
-	const ageMs = Math.max(0, input.nowMs - oldestUpdatedAtMs);
-	if (ageMs < input.staleInFlightThresholdMs) return null;
-	return {
-		blockedNonce: oldestNonce,
-		ageMs
-	};
-}
-function createEvmNonceLaneBlockedError(args) {
-	const error = /* @__PURE__ */ new Error(`[NonceCoordinator] nonce lane blocked on ${nonceLaneNetworkKey(args.lane)} (nonce=${args.blockedNonce.toString()}) for ${args.ageMs}ms; reconcile or replace/dropped report required`);
-	error.code = "nonce_lane_blocked";
-	error.retryable = true;
-	error.details = {
-		chain: args.lane.chainTarget.kind,
-		networkKey: nonceLaneNetworkKey(args.lane),
-		chainId: args.lane.chainTarget.chainId,
-		blockedNonce: args.blockedNonce.toString(),
-		ageMs: args.ageMs
-	};
-	return error;
-}
-//#endregion
-//#region src/core/signingEngine/nonce/nearNonceLane.ts
-function readinessNonceFromTransactionContext(transactionContext) {
-	const raw = String(transactionContext?.nextNonce ?? transactionContext?.accessKeyInfo?.nonce ?? "0").trim();
-	if (!raw) return 0n;
-	try {
-		return BigInt(raw);
-	} catch {
-		return 0n;
-	}
-}
-function classifyNearExecutionReadiness(input) {
-	const base = {
-		walletId: String(input.walletId || "").trim(),
-		nearAccountId: String(input.nearAccountId || "").trim(),
-		nearPublicKeyStr: String(input.nearPublicKeyStr || "").trim()
-	};
-	if (!input.accessKeyAvailable && isImplicitNearAccountId(base.nearAccountId)) return {
-		kind: "implicit_unfunded",
-		...base
-	};
-	const ready = {
-		...base,
-		nonce: readinessNonceFromTransactionContext(input.transactionContext),
-		accessKeyNonce: String(input.transactionContext?.accessKeyInfo?.nonce ?? "").trim(),
-		nextNonce: String(input.transactionContext?.nextNonce ?? "").trim(),
-		txBlockHeight: String(input.transactionContext?.txBlockHeight ?? "").trim(),
-		txBlockHash: String(input.transactionContext?.txBlockHash ?? "").trim()
-	};
-	if (isImplicitNearAccountId(base.nearAccountId)) return {
-		kind: "access_key_available",
-		...ready
-	};
-	return {
-		kind: "sponsored_named_ready",
-		...ready
-	};
-}
-function readNearAccessKeySubject(state) {
-	switch (state.lifecycle.kind) {
-		case "uninitialized": return null;
-		case "access_key_bound":
-		case "access_key_lookup_pending":
-		case "implicit_unfunded":
-		case "lookup_failed": return state.lifecycle.subject;
-		default: return assertNeverNearNonceLaneLifecycle(state.lifecycle);
-	}
-}
-function requireNearAccessKeySubject(state) {
-	const subject = readNearAccessKeySubject(state);
-	if (!subject) throw new Error("[NonceCoordinator] NEAR access key is not initialized");
-	return subject;
-}
-function readNearTransactionContext(state) {
-	return readNearReadyContext(state.lifecycle)?.transactionContext ?? null;
-}
-function hasNearTransactionContext(state) {
-	return readNearTransactionContext(state) !== null;
-}
-function hasNearInflightFetch(state) {
-	return readNearInflightFetch(state) !== null;
-}
-function readNearActiveAccountId(state) {
-	return readNearAccessKeySubject(state)?.nearAccountId ?? null;
-}
-function readNearActivePublicKey(state) {
-	return readNearAccessKeySubject(state)?.publicKey ?? null;
-}
-function readNearReadyContext(lifecycle) {
-	switch (lifecycle.kind) {
-		case "uninitialized":
-		case "implicit_unfunded":
-		case "lookup_failed": return null;
-		case "access_key_bound": return lifecycle.context.kind === "ready" ? lifecycle.context : null;
-		case "access_key_lookup_pending": return lifecycle.previousContext.kind === "ready" ? lifecycle.previousContext : null;
-		default: return assertNeverNearNonceLaneLifecycle(lifecycle);
-	}
-}
-function readNearPreviousContext(lifecycle) {
-	return readNearReadyContext(lifecycle) ?? { kind: "missing" };
-}
-function readNearInflightFetch(state) {
-	switch (state.lifecycle.kind) {
-		case "access_key_lookup_pending": return state.lifecycle.promise;
-		case "uninitialized":
-		case "access_key_bound":
-		case "implicit_unfunded":
-		case "lookup_failed": return null;
-		default: return assertNeverNearNonceLaneLifecycle(state.lifecycle);
-	}
-}
-function setNearAccessKeyReady(input) {
-	const previous = readNearReadyContext(input.state.lifecycle);
-	input.state.lifecycle = {
-		kind: "access_key_bound",
-		subject: input.subject,
-		context: {
-			kind: "ready",
-			transactionContext: input.transactionContext,
-			lastNonceUpdateMs: input.updateNonce ? input.nowMs : previous?.lastNonceUpdateMs ?? input.nowMs,
-			lastBlockHeightUpdateMs: input.updateBlock ? input.nowMs : previous?.lastBlockHeightUpdateMs ?? input.nowMs
-		}
-	};
-}
-function setNearAccessKeyLookupPending(input) {
-	input.state.lifecycle = {
-		kind: "access_key_lookup_pending",
-		subject: input.subject,
-		previousContext: readNearPreviousContext(input.state.lifecycle),
-		promise: input.promise
-	};
-}
-function setNearImplicitUnfunded(input) {
-	input.state.lifecycle = {
-		kind: "implicit_unfunded",
-		subject: input.subject,
-		readiness: {
-			kind: "implicit_unfunded",
-			walletId: input.subject.walletId,
-			nearAccountId: input.subject.nearAccountId,
-			nearPublicKeyStr: input.subject.publicKey
-		}
-	};
-}
-function setNearLookupFailed(input) {
-	input.state.lifecycle = {
-		kind: "lookup_failed",
-		subject: input.subject,
-		readiness: {
-			kind: "account_lookup_failed",
-			walletId: input.subject.walletId,
-			nearAccountId: input.subject.nearAccountId,
-			nearPublicKeyStr: input.subject.publicKey,
-			message: input.message
-		}
-	};
-}
-function assertNeverNearNonceLaneLifecycle(value) {
-	throw new Error(`[NonceCoordinator] unhandled NEAR nonce lane lifecycle: ${String(value)}`);
-}
-function createNearNonceLaneState() {
-	return {
-		lifecycle: { kind: "uninitialized" },
-		inflightId: 0,
-		refreshTimer: null,
-		prefetchTimer: null,
-		reservedNonces: /* @__PURE__ */ new Set(),
-		lastReservedNonce: null,
-		inFlight: /* @__PURE__ */ new Map()
-	};
-}
-function clearNearRefreshTimer(state) {
-	if (!state.refreshTimer) return;
-	clearTimeout(state.refreshTimer);
-	state.refreshTimer = null;
-}
-function clearNearPrefetchTimer(state) {
-	if (!state.prefetchTimer) return;
-	clearTimeout(state.prefetchTimer);
-	state.prefetchTimer = null;
-}
-function clearNearTransactionContext(state) {
-	const subject = readNearAccessKeySubject(state);
-	state.lifecycle = subject ? {
-		kind: "access_key_bound",
-		subject,
-		context: { kind: "missing" }
-	} : { kind: "uninitialized" };
-	state.reservedNonces.clear();
-	state.lastReservedNonce = null;
-	state.inFlight.clear();
-	clearNearRefreshTimer(state);
-	clearNearPrefetchTimer(state);
-}
-function clearNearAccessKeyState(state) {
-	state.lifecycle = { kind: "uninitialized" };
-	clearNearTransactionContext(state);
-}
-function initializeNearAccessKeyState(input) {
-	const nearAccountId = normalizeSessionStatusRequiredString(input.nearAccountId, "nearAccountId");
-	const publicKey = normalizeSessionStatusRequiredString(input.publicKey, "publicKey");
-	const walletId = normalizeSessionStatusRequiredString(input.walletId, "walletId");
-	if (!walletId) throw new Error("[NonceCoordinator] NEAR access key walletId is required");
-	const subject = {
-		walletId,
-		nearAccountId,
-		publicKey
-	};
-	const currentSubject = readNearAccessKeySubject(input.state);
-	if (currentSubject?.walletId === walletId && currentSubject.nearAccountId === nearAccountId && currentSubject.publicKey === publicKey) return;
-	input.state.lifecycle = {
-		kind: "access_key_bound",
-		subject,
-		context: { kind: "missing" }
-	};
-	clearNearTransactionContext(input.state);
-}
-function commitNearTransactionContextForState(input) {
-	initializeNearAccessKeyState({
-		state: input.state,
-		walletId: input.walletId,
-		nearAccountId: input.nearAccountId,
-		publicKey: input.publicKey
-	});
-	setNearAccessKeyReady({
-		state: input.state,
-		subject: requireNearAccessKeySubject(input.state),
-		transactionContext: input.transactionContext,
-		nowMs: input.nowMs,
-		updateNonce: true,
-		updateBlock: true
-	});
-}
-async function reserveNearNoncesFromState(input) {
-	const transactionContext = readNearTransactionContext(input.state);
-	if (!transactionContext) throw new Error("NEAR transaction context not available - call fetchNearContext() first");
-	const count = Math.max(0, Math.floor(Number(input.countInput || 0)));
-	if (count <= 0) return [];
-	const laneKey = nonceLaneKey(input.lane);
-	const activeDurableNonces = await input.readActiveLeaseNonces(laneKey, { lane: input.lane });
-	let highestDurable = 0n;
-	for (const nonce of activeDurableNonces) {
-		const value = BigInt(nonce);
-		if (value > highestDurable) highestDurable = value;
-	}
-	const start = maxBigint(input.state.lastReservedNonce ? BigInt(input.state.lastReservedNonce) + 1n : 0n, BigInt(transactionContext.nextNonce), highestDurable > 0n ? highestDurable + 1n : 0n);
-	const planned = [];
-	let candidateValue = start;
-	for (let index = 0; index < count; index += 1) {
-		while (input.state.reservedNonces.has(candidateValue.toString()) || activeDurableNonces.has(candidateValue.toString())) candidateValue += 1n;
-		const candidate = candidateValue.toString();
-		planned.push(candidate);
-		candidateValue += 1n;
-	}
-	for (const nonce of planned) input.state.reservedNonces.add(nonce);
-	input.state.lastReservedNonce = planned[planned.length - 1] || input.state.lastReservedNonce;
-	return planned;
-}
-function computeLastReservedNonce(reserved) {
-	let last = null;
-	for (const value of reserved) try {
-		const parsed = BigInt(value);
-		if (last === null || parsed > last) last = parsed;
-	} catch {}
-	return last === null ? null : last.toString();
-}
-function releaseNearNonceFromState(state, nonce) {
-	if (!state.reservedNonces.delete(String(nonce))) return;
-	state.lastReservedNonce = computeLastReservedNonce(state.reservedNonces);
-}
-async function markNearBroadcastAcceptedState(input) {
-	const nonce = BigInt(input.lease.nonce);
-	input.state.inFlight.set(nonce.toString(), {
-		nonce,
-		txHash: input.txHash,
-		acceptedAtMs: input.nowMs,
-		updatedAtMs: input.nowMs
-	});
-	await input.persistCoordinationLease(input.lease, {
-		state: NonceDurableLeaseState.BroadcastAccepted,
-		txHash: input.txHash
-	});
-}
-async function reconcileNearLaneState(input) {
-	initializeNearAccessKeyState({
-		state: input.state,
-		walletId: input.lane.walletId,
-		nearAccountId: input.lane.nearAccountId,
-		publicKey: input.lane.publicKey
-	});
-	const accessKeyInfoRaw = await input.nearClient.viewAccessKey(input.lane.nearAccountId, input.lane.publicKey);
-	if (!isAccessKeyViewLike(accessKeyInfoRaw)) throw new Error(`Access key not found or invalid for account ${input.lane.nearAccountId}`);
-	const accessKeyInfo = normalizeAccessKeyView(accessKeyInfoRaw);
-	const chainNonce = BigInt(accessKeyInfo.nonce);
-	const chainNextNonce = chainNonce + 1n;
-	const unresolvedInFlightNonces = [];
-	for (const lease of input.activeLeases) {
-		const leaseNonce = BigInt(lease.nonce);
-		const inFlight = input.state.inFlight.get(leaseNonce.toString());
-		if (leaseNonce > chainNonce) {
-			if (inFlight) unresolvedInFlightNonces.push(leaseNonce);
-			continue;
-		}
-		if (!inFlight?.txHash) continue;
-		const txOutcome = await readNearTxOutcome({
-			nearClient: input.nearClient,
-			txHash: inFlight.txHash,
-			accountId: input.lane.nearAccountId
-		});
-		if (txOutcome === "finalized") {
-			input.transitionLease({
-				lease,
-				transition: "finalize",
-				reason: "near_tx_status_finalized",
-				txHash: inFlight.txHash
-			});
-			await input.removeCoordinationLease(lease);
-			input.state.inFlight.delete(leaseNonce.toString());
-			releaseNearNonceFromState(input.state, leaseNonce.toString());
-			continue;
-		}
-		if (txOutcome === "missing") {
-			input.transitionLease({
-				lease,
-				transition: "drop",
-				reason: NearNonceReconcileReason.NonceAdvancedHashMissing,
-				txHash: inFlight.txHash
-			});
-			await input.removeCoordinationLease(lease);
-			input.state.inFlight.delete(leaseNonce.toString());
-			releaseNearNonceFromState(input.state, leaseNonce.toString());
-			continue;
-		}
-		unresolvedInFlightNonces.push(leaseNonce);
-	}
-	const previousContext = readNearTransactionContext(input.state);
-	const candidateNext = maxBigint(chainNextNonce, previousContext?.nextNonce ? BigInt(previousContext.nextNonce) : 0n, input.state.lastReservedNonce ? BigInt(input.state.lastReservedNonce) + 1n : 0n);
-	setNearAccessKeyReady({
-		state: input.state,
-		subject: {
-			walletId: input.lane.walletId,
-			nearAccountId: input.lane.nearAccountId,
-			publicKey: input.lane.publicKey
-		},
-		transactionContext: {
-			...previousContext || {
-				nearPublicKeyStr: input.lane.publicKey,
-				txBlockHeight: "0",
-				txBlockHash: ""
-			},
-			accessKeyInfo,
-			nextNonce: candidateNext.toString()
-		},
-		nowMs: input.now(),
-		updateNonce: true,
-		updateBlock: false
-	});
-	if (input.state.reservedNonces.size > 0) {
-		const pruned = pruneReservedNearNonces(chainNonce, input.state.reservedNonces);
-		input.state.reservedNonces = pruned.set;
-		input.state.lastReservedNonce = pruned.lastReserved;
-	}
-	return {
-		chainNextNonce,
-		unresolvedInFlightNonces: unresolvedInFlightNonces.sort((a, b) => a < b ? -1 : a > b ? 1 : 0),
-		blocked: false
-	};
-}
-async function readNearTxOutcome(input) {
-	try {
-		await input.nearClient.txStatus(input.txHash, input.accountId);
-		return "finalized";
-	} catch (error) {
-		const message = errorMessage(error);
-		if (/unknown transaction|does not exist|not found|not found in storage/i.test(message)) return "missing";
-		return "unknown";
-	}
-}
-function pruneReservedNearNonces(chainNonce, reserved) {
-	const next = /* @__PURE__ */ new Set();
-	let last = null;
-	for (const nonce of reserved) try {
-		const parsed = BigInt(nonce);
-		if (parsed <= chainNonce) continue;
-		next.add(nonce);
-		if (last === null || parsed > last) last = parsed;
-	} catch {}
-	return {
-		set: next,
-		lastReserved: last === null ? null : last.toString()
-	};
-}
-function isMissingNearAccessKeyError(message) {
-	const normalized = String(message || "").toLowerCase();
-	return normalized.includes("does not exist while viewing") || normalized.includes("access key not found") || normalized.includes("unknown public key") || normalized.includes("unknown_account") || normalized.includes("unknown account") || normalized.includes("unknown_access_key") || normalized.includes("does not exist") || normalized.includes("doesn't exist");
-}
-var NearImplicitAccountFundingRequiredError = class extends Error {
-	constructor(args) {
-		super(`NEAR account ${args.nearAccountId} needs funding before direct NEAR signing.`);
-		this.code = "near_implicit_account_unfunded";
-		this.name = "NearImplicitAccountFundingRequiredError";
-		this.nearAccountId = args.nearAccountId;
-		this.readiness = classifyNearExecutionReadiness({
-			walletId: args.walletId,
-			nearAccountId: args.nearAccountId,
-			nearPublicKeyStr: args.nearPublicKeyStr,
-			accessKeyAvailable: false
-		});
-	}
-};
-var NearAccountLookupFailedError = class extends Error {
-	constructor(args) {
-		super(args.message || `NEAR account ${args.nearAccountId} access key lookup failed.`);
-		this.code = "near_account_lookup_failed";
-		this.name = "NearAccountLookupFailedError";
-		this.nearAccountId = args.nearAccountId;
-		this.readiness = {
-			kind: "account_lookup_failed",
-			walletId: args.walletId,
-			nearAccountId: args.nearAccountId,
-			nearPublicKeyStr: args.nearPublicKeyStr,
-			message: this.message
-		};
-	}
-};
-async function fetchNearFreshDataForState(input) {
-	const { state } = input;
-	const inflightFetch = readNearInflightFetch(state);
-	if (inflightFetch && !input.force) return inflightFetch;
-	const capturedSubject = requireNearAccessKeySubject(state);
-	const requestId = ++state.inflightId;
-	const fetchPromise = (async () => {
-		try {
-			const nowMs = input.now();
-			const readyContext = readNearReadyContext(state.lifecycle);
-			const previousTransactionContext = readyContext?.transactionContext ?? null;
-			const isNonceStale = input.force || !readyContext || nowMs - readyContext.lastNonceUpdateMs >= input.nonceFreshnessThresholdMs;
-			const isBlockStale = input.force || !readyContext || nowMs - readyContext.lastBlockHeightUpdateMs >= input.blockFreshnessThresholdMs;
-			let accessKeyInfo = previousTransactionContext?.accessKeyInfo;
-			let txBlockHeight = previousTransactionContext?.txBlockHeight;
-			let txBlockHash = previousTransactionContext?.txBlockHash;
-			const fetchAccessKey = isNonceStale || !accessKeyInfo;
-			const fetchBlock = isBlockStale || !txBlockHeight || !txBlockHash;
-			let maybeAccessKey = accessKeyInfo ?? null;
-			let maybeBlock = null;
-			let accessKeyError = null;
-			let blockError = null;
-			const tasks = [];
-			if (fetchAccessKey) tasks.push((async () => {
-				try {
-					maybeAccessKey = await input.nearClient.viewAccessKey(capturedSubject.nearAccountId, capturedSubject.publicKey);
-				} catch (error) {
-					const message = errorMessage(error);
-					if (isMissingNearAccessKeyError(message)) {
-						if (isImplicitNearAccountId(capturedSubject.nearAccountId)) {
-							accessKeyError = new NearImplicitAccountFundingRequiredError({
-								walletId: capturedSubject.walletId,
-								nearAccountId: capturedSubject.nearAccountId,
-								nearPublicKeyStr: capturedSubject.publicKey
-							});
-							return;
-						}
-						accessKeyError = new NearAccountLookupFailedError({
-							walletId: capturedSubject.walletId,
-							nearAccountId: capturedSubject.nearAccountId,
-							nearPublicKeyStr: capturedSubject.publicKey,
-							message
-						});
-						return;
-					}
-					accessKeyError = error;
-				}
-			})());
-			if (fetchBlock) tasks.push((async () => {
-				try {
-					maybeBlock = await input.nearClient.viewBlock({ finality: "final" });
-				} catch (error) {
-					blockError = error;
-				}
-			})());
-			if (tasks.length > 0) await Promise.all(tasks);
-			if (accessKeyError) {
-				if (accessKeyError instanceof NearImplicitAccountFundingRequiredError) setNearImplicitUnfunded({
-					state,
-					subject: capturedSubject
-				});
-				else if (accessKeyError instanceof NearAccountLookupFailedError) setNearLookupFailed({
-					state,
-					subject: capturedSubject,
-					message: accessKeyError.message
-				});
-				throw accessKeyError;
-			}
-			if (blockError) throw blockError;
-			if (fetchAccessKey) accessKeyInfo = isAccessKeyViewLike(maybeAccessKey) ? normalizeAccessKeyView(maybeAccessKey) : previousTransactionContext?.accessKeyInfo || makePlaceholderAccessKey();
-			if (fetchBlock) {
-				if (!isBlockResultLike(maybeBlock)) throw new Error("[NonceCoordinator] failed to fetch NEAR block info");
-				txBlockHeight = String(maybeBlock.header.height);
-				txBlockHash = maybeBlock.header.hash;
-			}
-			const nextCandidate = maxBigint(accessKeyInfo?.nonce !== void 0 ? BigInt(accessKeyInfo.nonce) + 1n : 0n, previousTransactionContext?.nextNonce ? BigInt(previousTransactionContext.nextNonce) : 0n, state.lastReservedNonce ? BigInt(state.lastReservedNonce) + 1n : 0n, 1n);
-			const transactionContext = {
-				nearPublicKeyStr: capturedSubject.publicKey,
-				accessKeyInfo,
-				nextNonce: nextCandidate.toString(),
-				txBlockHeight,
-				txBlockHash
-			};
-			if (nearAccessKeySubjectsMatch(readNearAccessKeySubject(state), capturedSubject) && requestId === state.inflightId) setNearAccessKeyReady({
-				state,
-				subject: capturedSubject,
-				transactionContext,
-				nowMs: input.now(),
-				updateNonce: fetchAccessKey,
-				updateBlock: fetchBlock
-			});
-			return transactionContext;
-		} finally {
-			if (requestId === state.inflightId) {
-				const subject = readNearAccessKeySubject(state);
-				if (state.lifecycle.kind === "access_key_lookup_pending" && nearAccessKeySubjectsMatch(subject, capturedSubject)) state.lifecycle = {
-					kind: "access_key_bound",
-					subject: capturedSubject,
-					context: state.lifecycle.previousContext
-				};
-			}
-		}
-	})();
-	setNearAccessKeyLookupPending({
-		state,
-		subject: capturedSubject,
-		promise: fetchPromise
-	});
-	return fetchPromise;
-}
-async function updateNearNonceFromBlockchainState(input) {
-	const { state } = input;
-	const subject = requireNearAccessKeySubject(state);
-	try {
-		const accessKeyInfoRaw = await input.nearClient.viewAccessKey(subject.nearAccountId, subject.publicKey);
-		if (!isAccessKeyViewLike(accessKeyInfoRaw)) throw new Error(`Access key not found or invalid for account ${subject.nearAccountId}`);
-		const accessKeyInfo = normalizeAccessKeyView(accessKeyInfoRaw);
-		const chainNonce = BigInt(accessKeyInfo.nonce);
-		const actual = BigInt(input.actualNonce);
-		const previousContext = readNearTransactionContext(state);
-		const candidateNext = maxBigint(chainNonce + 1n, actual + 1n, previousContext?.nextNonce ? BigInt(previousContext.nextNonce) : 0n, state.lastReservedNonce ? BigInt(state.lastReservedNonce) + 1n : 0n);
-		setNearAccessKeyReady({
-			state,
-			subject,
-			transactionContext: previousContext ? {
-				...previousContext,
-				accessKeyInfo,
-				nextNonce: candidateNext.toString()
-			} : {
-				nearPublicKeyStr: subject.publicKey,
-				accessKeyInfo,
-				nextNonce: candidateNext.toString(),
-				txBlockHeight: "0",
-				txBlockHash: ""
-			},
-			nowMs: input.now(),
-			updateNonce: true,
-			updateBlock: false
-		});
-		state.inFlight.delete(input.actualNonce);
-		releaseNearNonceFromState(state, input.actualNonce);
-		if (state.reservedNonces.size > 0) {
-			const pruned = pruneReservedNearNonces(chainNonce, state.reservedNonces);
-			state.reservedNonces = pruned.set;
-			state.lastReservedNonce = pruned.lastReserved;
-		}
-	} catch (error) {
-		if (isMissingNearAccessKeyError(errorMessage(error))) {
-			const actual = BigInt(input.actualNonce);
-			const previousContext = readNearTransactionContext(state);
-			const candidateNext = maxBigint(actual + 1n, previousContext?.nextNonce ? BigInt(previousContext.nextNonce) : 0n, state.lastReservedNonce ? BigInt(state.lastReservedNonce) + 1n : 0n);
-			setNearAccessKeyReady({
-				state,
-				subject,
-				transactionContext: previousContext ? {
-					...previousContext,
-					nextNonce: candidateNext.toString()
-				} : {
-					nearPublicKeyStr: subject.publicKey,
-					accessKeyInfo: makePlaceholderAccessKey(),
-					txBlockHeight: "0",
-					txBlockHash: "",
-					nextNonce: candidateNext.toString()
-				},
-				nowMs: input.now(),
-				updateNonce: true,
-				updateBlock: false
-			});
-		}
-	}
-}
-async function refreshNearNonceAfterBroadcastRejectedState(input) {
-	const { state } = input;
-	const subject = requireNearAccessKeySubject(state);
-	const accessKeyInfoRaw = await input.nearClient.viewAccessKey(subject.nearAccountId, subject.publicKey);
-	if (!isAccessKeyViewLike(accessKeyInfoRaw)) throw new Error(`Access key not found or invalid for account ${subject.nearAccountId}`);
-	const accessKeyInfo = normalizeAccessKeyView(accessKeyInfoRaw);
-	const chainNonce = BigInt(accessKeyInfo.nonce);
-	const candidateNext = maxBigint(chainNonce + 1n, state.lastReservedNonce ? BigInt(state.lastReservedNonce) + 1n : 0n, 1n);
-	const previousContext = readNearTransactionContext(state);
-	setNearAccessKeyReady({
-		state,
-		subject,
-		transactionContext: previousContext ? {
-			...previousContext,
-			accessKeyInfo,
-			nextNonce: candidateNext.toString()
-		} : {
-			nearPublicKeyStr: subject.publicKey,
-			accessKeyInfo,
-			nextNonce: candidateNext.toString(),
-			txBlockHeight: "0",
-			txBlockHash: ""
-		},
-		nowMs: input.now(),
-		updateNonce: true,
-		updateBlock: false
-	});
-	if (state.reservedNonces.size > 0) {
-		const pruned = pruneReservedNearNonces(chainNonce, state.reservedNonces);
-		state.reservedNonces = pruned.set;
-		state.lastReservedNonce = pruned.lastReserved;
-	}
-}
-function shouldPrefetchNearContext(input) {
-	const readyContext = readNearReadyContext(input.state.lifecycle);
-	return !readyContext || input.nowMs - readyContext.lastBlockHeightUpdateMs >= input.blockFreshnessThresholdMs || !readyContext;
-}
-function isAccessKeyViewLike(value) {
-	if (!isObject(value)) return false;
-	try {
-		normalizeBigint(value.nonce, "near access-key nonce");
-		return true;
-	} catch {
-		return false;
-	}
-}
-function normalizeAccessKeyView(value) {
-	const record = value;
-	return {
-		nonce: normalizeBigint(record.nonce, "near access-key nonce"),
-		permission: normalizeAccessKeyPermission(record.permission),
-		block_hash: isString(record.block_hash) ? record.block_hash : "",
-		block_height: typeof record.block_height === "number" ? record.block_height : 0
-	};
-}
-function normalizeAccessKeyPermission(value) {
-	if (value === "FullAccess") return "FullAccess";
-	if (!isObject(value)) return "FullAccess";
-	const functionCall = value.FunctionCall;
-	if (!isObject(functionCall)) return "FullAccess";
-	const methodNames = Array.isArray(functionCall.method_names) ? functionCall.method_names.filter(isString) : [];
-	return { FunctionCall: {
-		allowance: isString(functionCall.allowance) ? functionCall.allowance : "",
-		receiver_id: isString(functionCall.receiver_id) ? functionCall.receiver_id : "",
-		method_names: methodNames
-	} };
-}
-function isBlockResultLike(value) {
-	const record = value;
-	if (!record || typeof record !== "object") return false;
-	const header = record.header;
-	return !!header && typeof header.hash === "string" && header.height !== void 0;
-}
-function makePlaceholderAccessKey() {
-	return {
-		nonce: 0n,
-		permission: "FullAccess",
-		block_height: 0,
-		block_hash: ""
-	};
-}
-function nearAccessKeySubjectsMatch(left, right) {
-	return left?.walletId === right.walletId && left.nearAccountId === right.nearAccountId && left.publicKey === right.publicKey;
-}
-//#endregion
-//#region src/core/signingEngine/nonce/nonceDiagnostics.ts
-function recordCoordinationDegradationOnce(input) {
-	const lane = input.lane;
-	const fallback = input.fallback || NonceCoordinatorFallback.InRuntimeLock;
-	const networkKey = lane ? nonceLaneNetworkKey(lane) : String(input.networkKey || "").trim();
-	const accountId = lane ? nonceLaneSubjectId(lane) : String(input.accountId || "").trim();
-	const laneFamily = lane?.family || input.laneFamily;
-	const key = [
-		input.reason,
-		laneFamily || "",
-		networkKey,
-		accountId,
-		fallback
-	].join("|");
-	if (input.observed.has(key)) return null;
-	const degradation = {
-		reason: input.reason,
-		...laneFamily ? { laneFamily } : {},
-		...networkKey ? { networkKey } : {},
-		...accountId ? { accountId } : {},
-		fallback
-	};
-	input.observed.set(key, degradation);
-	return {
-		...lane ? { lane } : {},
-		degradation
-	};
-}
-function recordDroppedReplacedAlertWindow(input) {
-	const key = [nonceLaneKey(input.lane), input.reason].join("|");
-	const existing = input.alerts.get(key);
-	const windowState = existing && input.nowMs - existing.firstSeenAtMs <= input.windowMs ? {
-		count: existing.count + 1,
-		firstSeenAtMs: existing.firstSeenAtMs,
-		lastSeenAtMs: input.nowMs
-	} : {
-		count: 1,
-		firstSeenAtMs: input.nowMs,
-		lastSeenAtMs: input.nowMs
-	};
-	input.alerts.set(key, windowState);
-	if (windowState.count < input.threshold) return null;
-	return {
-		alert: {
-			kind: "repeated_dropped_or_replaced",
-			severity: "warning",
-			lane: input.lane,
-			reason: input.reason,
-			count: windowState.count,
-			windowMs: input.windowMs,
-			firstSeenAtMs: windowState.firstSeenAtMs,
-			lastSeenAtMs: windowState.lastSeenAtMs
-		},
-		warning: {
-			chainTarget: input.lane.chainTarget,
-			networkKey: nonceLaneNetworkKey(input.lane),
-			chainId: input.lane.chainTarget.chainId,
-			sender: input.lane.sender,
-			nonceKey: input.lane.nonceKey?.toString(),
-			subjectId: input.lane.subjectId,
-			reason: input.reason,
-			count: windowState.count,
-			windowMs: input.windowMs
-		}
-	};
-}
-function createEmptyLeaseStateCounts() {
-	const counts = {};
-	for (const state of NONCE_LEASE_STATES) counts[state] = 0;
-	return counts;
-}
-function appendOutcomeMetricEvent(sink, event) {
-	const accountId = (event.lease?.lane ? nonceLaneSubjectId(event.lease.lane) : "") || (event.lane ? nonceLaneSubjectId(event.lane) : "") || event.accountId;
-	const push = (kind, reason) => {
-		sink.push({
-			...accountId ? { accountId } : {},
-			kind,
-			reason
-		});
-	};
-	if (event.event === NonceCoordinatorTraceEventName.LeaseDropped) {
-		push(EvmNonceOutcomeReason.Dropped, EvmNonceOutcomeReason.Dropped);
-		return;
-	}
-	if (event.event === NonceCoordinatorTraceEventName.LeaseReplaced) {
-		push(EvmNonceOutcomeReason.Replaced, EvmNonceOutcomeReason.Replaced);
-		return;
-	}
-	if (event.event === NonceCoordinatorTraceEventName.LaneReconciled) {
-		push("reconciled", normalizeMetricReason(event.reason, "manual"));
-		return;
-	}
-	if (event.event === NonceCoordinatorTraceEventName.LeaseReleased) {
-		push("released", normalizeMetricReason(event.reason, "unspecified"));
-		return;
-	}
-	if (event.event === NonceCoordinatorTraceEventName.LeaseExpired) {
-		push("expired", normalizeMetricReason(event.reason, "lease_ttl_elapsed"));
-		return;
-	}
-	if (event.event === NonceCoordinatorTraceEventName.LeaseBroadcastRejected) push(NonceLeaseState.BroadcastRejected, NonceLeaseState.BroadcastRejected);
-}
-function readOutcomeMetrics(events, accountId) {
-	const metrics = {
-		droppedCount: 0,
-		replacedCount: 0,
-		reconciledCount: 0,
-		releasedCount: 0,
-		expiredCount: 0,
-		broadcastRejectedCount: 0,
-		releaseReasons: {},
-		reconcileReasons: {},
-		expiryReasons: {}
-	};
-	for (const event of events) {
-		if (accountId && event.accountId !== accountId) continue;
-		if (event.kind === EvmNonceOutcomeReason.Dropped) {
-			metrics.droppedCount += 1;
-			continue;
-		}
-		if (event.kind === EvmNonceOutcomeReason.Replaced) {
-			metrics.replacedCount += 1;
-			continue;
-		}
-		if (event.kind === "broadcast_rejected") {
-			metrics.broadcastRejectedCount += 1;
-			continue;
-		}
-		if (event.kind === "reconciled") {
-			metrics.reconciledCount += 1;
-			metrics.reconcileReasons[event.reason] = (metrics.reconcileReasons[event.reason] || 0) + 1;
-			continue;
-		}
-		if (event.kind === "released") {
-			metrics.releasedCount += 1;
-			metrics.releaseReasons[event.reason] = (metrics.releaseReasons[event.reason] || 0) + 1;
-			continue;
-		}
-		if (event.kind === "expired") {
-			metrics.expiredCount += 1;
-			metrics.expiryReasons[event.reason] = (metrics.expiryReasons[event.reason] || 0) + 1;
-		}
-	}
-	return metrics;
-}
-function createNonceCoordinatorDiagnostics(input) {
-	const accountId = input.options?.accountId ? String(input.options.accountId).trim() : "";
-	const leasesByState = createEmptyLeaseStateCounts();
-	const lanes = /* @__PURE__ */ new Map();
-	const staleInFlightLaneKeys = /* @__PURE__ */ new Set();
-	let leaseCount = 0;
-	let oldestLeaseAgeMs = 0;
-	let oldestInFlightLeaseAgeMs = 0;
-	let staleInFlightLeaseCount = 0;
-	for (const lease of input.leases) {
-		if (accountId && nonceLaneSubjectId(lease.lane) !== accountId) continue;
-		leaseCount += 1;
-		leasesByState[lease.state] += 1;
-		const laneKey = nonceLaneKey(lease.lane);
-		const leaseAgeMs = Math.max(0, input.nowMs - lease.reservedAtMs);
-		oldestLeaseAgeMs = Math.max(oldestLeaseAgeMs, leaseAgeMs);
-		if (isInFlightNonceLeaseState(lease.state)) {
-			oldestInFlightLeaseAgeMs = Math.max(oldestInFlightLeaseAgeMs, leaseAgeMs);
-			if (lease.expiresAtMs <= input.nowMs) {
-				staleInFlightLeaseCount += 1;
-				staleInFlightLaneKeys.add(laneKey);
-			}
-		}
-		const existing = lanes.get(laneKey) || {
-			lane: lease.lane,
-			leaseCount: 0,
-			states: {}
-		};
-		existing.leaseCount += 1;
-		existing.states[lease.state] = (existing.states[lease.state] || 0) + 1;
-		lanes.set(laneKey, existing);
-	}
-	const metrics = {
-		atMs: input.nowMs,
-		...accountId ? { accountId } : {},
-		leaseCount,
-		laneCount: lanes.size,
-		oldestLeaseAgeMs,
-		oldestInFlightLeaseAgeMs,
-		staleInFlightLeaseCount,
-		staleInFlightLaneCount: staleInFlightLaneKeys.size,
-		reservedLeaseCount: leasesByState[NonceLeaseState.Reserved],
-		signedLeaseCount: leasesByState[NonceLeaseState.Signed],
-		broadcastAcceptedLeaseCount: leasesByState[NonceLeaseState.BroadcastAccepted],
-		droppedLeaseCount: leasesByState[NonceLeaseState.Dropped],
-		replacedLeaseCount: leasesByState[NonceLeaseState.Replaced],
-		reconciledLeaseCount: leasesByState[NonceLeaseState.Reconciled],
-		releasedLeaseCount: leasesByState[NonceLeaseState.Released],
-		outcomes: readOutcomeMetrics(input.outcomeMetricEvents, accountId)
-	};
-	const nearActiveAccountId = readNearActiveAccountId(input.nearState);
-	const nearActivePublicKey = readNearActivePublicKey(input.nearState);
-	return {
-		leaseCount,
-		leasesByState,
-		laneCount: lanes.size,
-		metrics,
-		coordinationWarnings: Array.from(input.observedCoordinationDegradations).filter((degradation) => !accountId || !degradation.accountId || degradation.accountId === accountId),
-		lanes: Array.from(lanes.values()).map((entry) => ({
-			family: entry.lane.family,
-			accountId: nonceLaneSubjectId(entry.lane),
-			networkKey: nonceLaneNetworkKey(entry.lane),
-			...entry.lane.family === "evm" ? {
-				chain: entry.lane.chainTarget.kind,
-				chainId: entry.lane.chainTarget.chainId
-			} : {},
-			leaseCount: entry.leaseCount,
-			states: { ...entry.states }
-		})),
-		near: {
-			...nearActiveAccountId ? { activeAccountId: nearActiveAccountId } : {},
-			...nearActivePublicKey ? { activePublicKey: nearActivePublicKey } : {},
-			hasContext: hasNearTransactionContext(input.nearState),
-			reservedNonceCount: input.nearState.reservedNonces.size,
-			...input.nearState.lastReservedNonce ? { lastReservedNonce: input.nearState.lastReservedNonce } : {}
-		}
-	};
-}
-//#endregion
-//#region src/core/signingEngine/nonce/nearNonceLaneIdentity.ts
-function requiredNearNonceLaneString(value, field) {
-	const normalized = value.trim();
-	if (!normalized) throw new Error(`[NonceCoordinator][near] ${field} is required`);
-	return normalized;
-}
-function resolveNearNonceNetworkKey(chains) {
-	const nearChain = chains?.find((chain) => String(chain.network || "").startsWith("near-"));
-	return String(nearChain?.network || "near");
-}
-function buildNearNonceLane(args) {
-	return {
-		family: "near",
-		networkKey: resolveNearNonceNetworkKey(args.chains),
-		walletId: requiredNearNonceLaneString(args.walletId, "walletId"),
-		nearAccountId: toAccountId(args.nearAccountId),
-		publicKey: requiredNearNonceLaneString(args.nearPublicKeyStr, "nearPublicKeyStr")
-	};
-}
-//#endregion
-//#region src/core/signingEngine/nonce/NonceCoordinator.ts
-const DEFAULT_NONCE_LEASE_TTL_MS = 12e4;
-const DEFAULT_SIGNED_NONCE_LEASE_TTL_MS = 3e4;
-const DEFAULT_EVM_REFRESH_TTL_MS = 5e3;
-const DEFAULT_EVM_STALE_INFLIGHT_THRESHOLD_MS = 45e3;
-const DEFAULT_DROPPED_REPLACED_ALERT_THRESHOLD = 3;
-const DEFAULT_DROPPED_REPLACED_ALERT_WINDOW_MS = 5 * 6e4;
-const DEFAULT_DURABLE_LOCK_TTL_MS = 5e3;
-const DEFAULT_DURABLE_LOCK_WAIT_TIMEOUT_MS = 3e3;
-const NEAR_NONCE_FRESHNESS_THRESHOLD_MS = 5e3;
-const NEAR_BLOCK_FRESHNESS_THRESHOLD_MS = 2e4;
-const NEAR_PREFETCH_DEBOUNCE_MS = 400;
-function createNonceCoordinator(deps) {
-	const leases = /* @__PURE__ */ new Map();
-	const evmStates = /* @__PURE__ */ new Map();
-	const evmAccountLaneKeys = /* @__PURE__ */ new Map();
-	const droppedReplacedAlerts = /* @__PURE__ */ new Map();
-	const outcomeMetricEvents = [];
-	const laneLocks = /* @__PURE__ */ new Map();
-	const now = deps.now || Date.now;
-	const leaseTtlMs = normalizePositiveInteger(deps.leaseTtlMs, DEFAULT_NONCE_LEASE_TTL_MS);
-	const signedLeaseTtlMs = normalizePositiveInteger(deps.signedLeaseTtlMs, DEFAULT_SIGNED_NONCE_LEASE_TTL_MS);
-	const evmRefreshTtlMs = normalizePositiveInteger(deps.evmRefreshTtlMs, DEFAULT_EVM_REFRESH_TTL_MS);
-	const evmStaleInFlightThresholdMs = normalizePositiveInteger(deps.evmStaleInFlightThresholdMs, DEFAULT_EVM_STALE_INFLIGHT_THRESHOLD_MS);
-	const droppedReplacedAlertThreshold = normalizePositiveInteger(deps.droppedReplacedAlertThreshold, DEFAULT_DROPPED_REPLACED_ALERT_THRESHOLD);
-	const droppedReplacedAlertWindowMs = normalizePositiveInteger(deps.droppedReplacedAlertWindowMs, DEFAULT_DROPPED_REPLACED_ALERT_WINDOW_MS);
-	const sameOriginLock = deps.sameOriginLock === void 0 ? createDefaultSameOriginLock() : deps.sameOriginLock;
-	const nonceLaneCoordinationStore = deps.nonceLaneCoordinationStore ?? null;
-	const shouldWarnOnMissingCoordinationStore = deps.nonceLaneCoordinationStore !== void 0;
-	const runtimeId = createRuntimeId();
-	const observedCoordinationDegradations = /* @__PURE__ */ new Map();
-	const emit = (event) => {
-		appendOutcomeMetricEvent(outcomeMetricEvents, event);
-		try {
-			deps.onTrace?.(event);
-		} catch {}
-	};
-	const emitCoordinationDegradedOnce = (reason, input) => {
-		const degradationEvent = recordCoordinationDegradationOnce({
-			observed: observedCoordinationDegradations,
-			reason,
-			...input
-		});
-		if (!degradationEvent) return;
-		emit({
-			event: NonceCoordinatorTraceEventName.CoordinationDegraded,
-			...degradationEvent
-		});
-		console.warn("[NonceCoordinator] nonce coordination degraded", degradationEvent.degradation);
-	};
-	const normalizeLeaseOperationInput = (input) => ({
-		leaseId: normalizeSessionStatusRequiredString(input.leaseId, "leaseId"),
-		operationId: SigningSessionIds.signingOperation(input.operationId),
-		operationFingerprint: SigningSessionIds.signingOperationFingerprint(input.operationFingerprint)
-	});
-	const readLease = (input) => {
-		const leaseId = normalizeSessionStatusRequiredString(input.leaseId, "leaseId");
-		const lease = leases.get(leaseId);
-		if (!lease) throw new Error("[NonceCoordinator] nonce lease not found");
-		assertOperationMatches(lease, input.operationId, input.operationFingerprint);
-		return lease;
-	};
-	const transitionLease = (args) => {
-		const previousState = args.lease.state;
-		const nextState = reduceNonceLeaseState(previousState, args.transition);
-		args.lease.state = nextState;
-		const expiresAtMs = args.expiresAtMs;
-		if (typeof expiresAtMs === "number" && Number.isSafeInteger(expiresAtMs)) args.lease.expiresAtMs = expiresAtMs;
-		emit({
-			event: args.event,
-			lease: args.lease,
-			previousState,
-			nextState,
-			...args.reason ? { reason: args.reason } : {},
-			...args.txHash ? { txHash: args.txHash } : {}
-		});
-	};
-	const preflightLeaseTransition = (lease, transition) => {
-		reduceNonceLeaseState(lease.state, transition);
-	};
-	const getOrCreateEvmState = (laneKey) => {
-		return getOrCreateEvmNonceLaneState(evmStates, laneKey);
-	};
-	const indexEvmLaneByAccount = (lane, laneKey) => {
-		indexEvmNonceLaneBySubject({
-			accountLaneKeys: evmAccountLaneKeys,
-			lane,
-			laneKey
-		});
-	};
-	const readCoordinationLaneRecords = async (laneKey, lane) => {
-		if (!nonceLaneCoordinationStore) {
-			if (shouldWarnOnMissingCoordinationStore) emitCoordinationDegradedOnce(NonceCoordinatorDegradationReason.IndexedDBUnavailable, { lane });
-			return [];
-		}
-		try {
-			await nonceLaneCoordinationStore.pruneExpired(now());
-		} catch {
-			emitCoordinationDegradedOnce(NonceCoordinatorDegradationReason.DurableStoreError, { lane });
-		}
-		try {
-			return await nonceLaneCoordinationStore.readLane(laneKey);
-		} catch {
-			emitCoordinationDegradedOnce(NonceCoordinatorDegradationReason.DurableStoreError, { lane });
-			return [];
-		}
-	};
-	const readActiveEvmLeaseNonces = async (laneKey, input) => {
-		const active = /* @__PURE__ */ new Set();
-		for (const lease of leases.values()) {
-			if (input?.excludeLeaseId && lease.leaseId === input.excludeLeaseId) continue;
-			if (!isEvmNonceLease(lease)) continue;
-			if (nonceLaneKey(lease.lane) !== laneKey) continue;
-			if (!isActiveEvmLeaseState(lease.state)) continue;
-			const nonce = lease.nonce;
-			if (input?.chainNextNonce != null && nonce < input.chainNextNonce) continue;
-			active.add(nonce.toString());
-		}
-		for (const parsed of await readCoordinationLaneRecords(laneKey, input?.lane)) {
-			if (parsed.record.family !== "evm") continue;
-			if (input?.excludeLeaseId && parsed.record.leaseId === input.excludeLeaseId) continue;
-			if (!isActiveCoordinationLeaseRecord(parsed.record, now())) continue;
-			if (input?.chainNextNonce != null && parsed.nonce < input.chainNextNonce) continue;
-			active.add(parsed.nonce.toString());
-		}
-		return active;
-	};
-	const readActiveNearLeaseNonces = async (laneKey, input) => {
-		const active = /* @__PURE__ */ new Set();
-		for (const lease of leases.values()) {
-			if (input?.excludeLeaseId && lease.leaseId === input.excludeLeaseId) continue;
-			if (!isNearNonceLease(lease)) continue;
-			if (nonceLaneKey(lease.lane) !== laneKey) continue;
-			if (!isActiveNearLeaseState(lease.state)) continue;
-			const nonce = BigInt(lease.nonce);
-			if (input?.chainNextNonce != null && nonce < input.chainNextNonce) continue;
-			active.add(nonce.toString());
-		}
-		for (const parsed of await readCoordinationLaneRecords(laneKey, input?.lane)) {
-			if (parsed.record.family !== "near") continue;
-			if (input?.excludeLeaseId && parsed.record.leaseId === input.excludeLeaseId) continue;
-			if (!isActiveCoordinationLeaseRecord(parsed.record, now())) continue;
-			if (input?.chainNextNonce != null && parsed.nonce < input.chainNextNonce) continue;
-			active.add(parsed.nonce.toString());
-		}
-		return active;
-	};
-	const persistCoordinationLease = async (lease, lifecycle, expiresAtMs = lease.expiresAtMs) => {
-		const coordinationStore = nonceLaneCoordinationStore;
-		if (!coordinationStore) {
-			if (shouldWarnOnMissingCoordinationStore) emitCoordinationDegradedOnce(NonceCoordinatorDegradationReason.IndexedDBUnavailable, { lane: lease.lane });
-			return;
-		}
-		if (isEvmNonceLease(lease)) await persistCoordinationRecord(coordinationStore, buildEvmCoordinationRecord({
-			lease,
-			lifecycle,
-			expiresAtMs,
-			updatedAtMs: now(),
-			runtimeId
-		}), lease.lane);
-		else if (isNearNonceLease(lease)) await persistCoordinationRecord(coordinationStore, buildNearCoordinationRecord({
-			lease,
-			lifecycle,
-			expiresAtMs,
-			updatedAtMs: now(),
-			runtimeId
-		}), lease.lane);
-		else assertNever(lease);
-	};
-	const persistCoordinationRecord = async (coordinationStore, record, lane) => {
-		try {
-			await coordinationStore.upsert(record);
-		} catch {
-			emitCoordinationDegradedOnce(NonceCoordinatorDegradationReason.DurableStoreError, { lane });
-		}
-	};
-	const removeCoordinationLease = async (lease) => {
-		if (!nonceLaneCoordinationStore) return;
-		try {
-			await nonceLaneCoordinationStore.remove({
-				laneKey: nonceLaneKey(lease.lane),
-				leaseId: lease.leaseId
-			});
-		} catch {
-			emitCoordinationDegradedOnce(NonceCoordinatorDegradationReason.DurableStoreError, { lane: lease.lane });
-		}
-	};
-	const refreshEvmLaneFromChainLocked$1 = async (lane, state) => {
-		const laneKey = nonceLaneKey(lane);
-		return await refreshEvmLaneFromChainLocked({
-			lane,
-			state,
-			nowMs: now(),
-			fetchChainNonce: async (targetLane) => await deps.evmNonceBackend.fetchChainNonce(evmLaneToReserveNonceInput(targetLane)),
-			readActiveLeaseNonces: async (input) => await readActiveEvmLeaseNonces(laneKey, input)
-		});
-	};
-	const shouldRefreshEvmLaneLocked = async (laneKey, state, lane) => {
-		return await shouldRefreshEvmLane({
-			state,
-			lane,
-			nowMs: now(),
-			refreshTtlMs: evmRefreshTtlMs,
-			readActiveLeaseNonces: async (input) => await readActiveEvmLeaseNonces(laneKey, input)
-		});
-	};
-	const reserveEvmNonceLeaseUnlocked = async (input) => {
-		await expireDueLeasesForLockedLane(input.lane);
-		const laneKey = nonceLaneKey(input.lane);
-		const state = getOrCreateEvmState(laneKey);
-		indexEvmLaneByAccount(input.lane, laneKey);
-		if (await shouldRefreshEvmLaneLocked(laneKey, state, input.lane)) await refreshEvmLaneFromChainLocked$1(input.lane, state);
-		const blocked = readBlockedEvmInFlight({
-			state,
-			nowMs: now(),
-			staleInFlightThresholdMs: evmStaleInFlightThresholdMs
-		});
-		if (blocked) throw createEvmNonceLaneBlockedError({
-			lane: input.lane,
-			blockedNonce: blocked.blockedNonce,
-			ageMs: blocked.ageMs
-		});
-		let candidate = state.chainNonce ?? state.nextCandidate ?? 0n;
-		const activeLeaseNonces = await readActiveEvmLeaseNonces(laneKey, { lane: input.lane });
-		while (activeLeaseNonces.has(candidate.toString()) || state.inFlight.has(candidate.toString())) candidate += 1n;
-		state.nextCandidate = candidate + 1n;
-		const reservedAtMs = now();
-		const lease = {
-			leaseId: createNonceLeaseId({
-				operationId: input.operation.operationId,
-				chain: input.lane.chainTarget.kind,
-				nonce: candidate
-			}),
-			lane: input.lane,
-			operationId: input.operation.operationId,
-			operationFingerprint: input.operation.operationFingerprint,
-			nonce: candidate,
-			state: NonceLeaseState.Reserved,
-			reservedAtMs,
-			expiresAtMs: reservedAtMs + leaseTtlMs
-		};
-		leases.set(lease.leaseId, lease);
-		await persistCoordinationLease(lease, { state: NonceDurableLeaseState.Reserved });
-		emit({
-			event: NonceCoordinatorTraceEventName.LeaseReserved,
-			lease
-		});
-		return { ...lease };
-	};
-	const releaseEvmNonceReservation = async (lease) => {
-		const laneKey = nonceLaneKey(lease.lane);
-		await releaseEvmNonceReservationState({
-			lease,
-			state: evmStates.get(laneKey),
-			removeCoordinationLease,
-			readActiveLeaseNonces: async (input) => await readActiveEvmLeaseNonces(laneKey, input)
-		});
-	};
-	const markEvmBroadcastAccepted = async (lease, txHash) => {
-		await markEvmBroadcastAcceptedState({
-			lease,
-			state: getOrCreateEvmState(nonceLaneKey(lease.lane)),
-			txHash,
-			nowMs: now(),
-			staleInFlightThresholdMs: evmStaleInFlightThresholdMs,
-			persistCoordinationLease
-		});
-	};
-	const markEvmFinalized = async (lease) => {
-		await markEvmFinalizedState({
-			lease,
-			state: getOrCreateEvmState(nonceLaneKey(lease.lane)),
-			nowMs: now(),
-			removeCoordinationLease
-		});
-	};
-	const markEvmDroppedOrReplaced = async (lease, input) => {
-		await markEvmDroppedOrReplacedState({
-			lease,
-			state: getOrCreateEvmState(nonceLaneKey(lease.lane)),
-			outcome: input,
-			nowMs: now(),
-			removeCoordinationLease
-		});
-	};
-	const reconcileEvmLaneLocked = async (lane) => {
-		const laneKey = nonceLaneKey(lane);
-		const state = getOrCreateEvmState(laneKey);
-		indexEvmLaneByAccount(lane, laneKey);
-		return await reconcileEvmLaneState({
-			lane,
-			state,
-			nowMs: now(),
-			staleInFlightThresholdMs: evmStaleInFlightThresholdMs,
-			refreshFromChain: refreshEvmLaneFromChainLocked$1
-		});
-	};
-	const recordDroppedReplacedAlert = (args) => {
-		const result = recordDroppedReplacedAlertWindow({
-			alerts: droppedReplacedAlerts,
-			lane: args.lane,
-			reason: args.reason,
-			nowMs: now(),
-			threshold: droppedReplacedAlertThreshold,
-			windowMs: droppedReplacedAlertWindowMs
-		});
-		if (!result) return;
-		emit({
-			event: NonceCoordinatorTraceEventName.LaneAlert,
-			lane: args.lane,
-			alert: result.alert
-		});
-		console.warn("[NonceCoordinator] repeated EVM-family dropped/replaced nonce outcomes", result.warning);
-	};
-	const nearState = createNearNonceLaneState();
-	const clearNearAccessKeyState$1 = () => {
-		clearNearAccessKeyState(nearState);
-	};
-	const requireNearClient = (nearClient) => {
-		const resolved = nearClient || deps.nearClient;
-		if (!resolved) throw new Error("[NonceCoordinator] NEAR client is not configured");
-		return resolved;
-	};
-	const initializeNearAccessKey = (input) => {
-		initializeNearAccessKeyState({
-			state: nearState,
-			...input
-		});
-	};
-	const reserveNearNonces = async (lane, countInput) => {
-		return await reserveNearNoncesFromState({
-			state: nearState,
-			lane,
-			countInput,
-			readActiveLeaseNonces: readActiveNearLeaseNonces
-		});
-	};
-	const releaseNearNonce = (nonce) => {
-		releaseNearNonceFromState(nearState, nonce);
-	};
-	const fetchNearFreshData = async (nearClient, force = false) => {
-		return await fetchNearFreshDataForState({
-			state: nearState,
-			nearClient,
-			force,
-			now,
-			nonceFreshnessThresholdMs: NEAR_NONCE_FRESHNESS_THRESHOLD_MS,
-			blockFreshnessThresholdMs: NEAR_BLOCK_FRESHNESS_THRESHOLD_MS
-		});
-	};
-	const fetchNearContextForLane = async (input) => {
-		initializeNearAccessKey({
-			walletId: input.lane.walletId,
-			nearAccountId: input.lane.nearAccountId,
-			publicKey: input.lane.publicKey
-		});
-		return { ...await fetchNearFreshData(requireNearClient(input.nearClient), input.force === true) };
-	};
-	const updateNearNonceFromBlockchain = async (nearClient, actualNonce) => {
-		await updateNearNonceFromBlockchainState({
-			state: nearState,
-			nearClient,
-			actualNonce,
-			now
-		});
-	};
-	const refreshNearNonceAfterBroadcastRejected = async (nearClient) => {
-		await refreshNearNonceAfterBroadcastRejectedState({
-			state: nearState,
-			nearClient,
-			now
-		});
-	};
-	const reconcileNearLaneLocked = async (lane) => {
-		const laneKey = nonceLaneKey(lane);
-		return await reconcileNearLaneState({
-			lane,
-			state: nearState,
-			nearClient: requireNearClient(),
-			now,
-			activeLeases: Array.from(leases.values()).filter((lease) => lease.lane.family === "near" && nonceLaneKey(lease.lane) === laneKey && lease.state === NonceLeaseState.BroadcastAccepted),
-			removeCoordinationLease,
-			transitionLease: ({ lease, transition, reason, txHash }) => {
-				transitionLease({
-					lease,
-					transition,
-					event: transition === "finalize" ? NonceCoordinatorTraceEventName.LeaseFinalized : NonceCoordinatorTraceEventName.LeaseDropped,
-					reason,
-					...txHash ? { txHash } : {}
-				});
-			}
-		});
-	};
-	const releaseBackendReservation = async (lease) => {
-		if (isEvmNonceLease(lease)) {
-			await releaseEvmNonceReservation(lease);
-			return;
-		}
-		releaseNearNonce(String(lease.nonce));
-		await removeCoordinationLease(lease);
-	};
-	const reconcileAfterSignedLeaseExpiry = async (lease) => {
-		await releaseBackendReservation(lease);
-		if (lease.lane.family !== "evm") return;
-		await reconcileEvmLaneLocked(lease.lane);
-		emit({
-			event: NonceCoordinatorTraceEventName.LaneReconciled,
-			lane: lease.lane
-		});
-	};
-	const withLocalLaneLock = async (laneKey, fn) => {
-		const previous = laneLocks.get(laneKey) ?? Promise.resolve();
-		let releaseCurrent;
-		const current = new Promise((resolve) => {
-			releaseCurrent = resolve;
-		});
-		const next = previous.catch(() => void 0).then(() => current);
-		laneLocks.set(laneKey, next);
-		await previous.catch(() => void 0);
-		try {
-			return await fn();
-		} finally {
-			releaseCurrent();
-			if (laneLocks.get(laneKey) === next) laneLocks.delete(laneKey);
-		}
-	};
-	const withLaneLock = async (lane, fn) => {
-		const laneKey = nonceLaneKey(lane);
-		const runLocal = async () => await withLocalLaneLock(laneKey, fn);
-		const lockKey = `nonce-coordinator:${laneKey}`;
-		if (sameOriginLock) return await sameOriginLock.withLock(lockKey, runLocal);
-		if (nonceLaneCoordinationStore?.withLock) {
-			let taskError = null;
-			const runLockedTask = async () => {
-				try {
-					return await runLocal();
-				} catch (error) {
-					taskError = error;
-					throw error;
-				}
-			};
-			try {
-				return await nonceLaneCoordinationStore.withLock({
-					lockKey,
-					ownerId: runtimeId,
-					ttlMs: DEFAULT_DURABLE_LOCK_TTL_MS,
-					waitTimeoutMs: DEFAULT_DURABLE_LOCK_WAIT_TIMEOUT_MS
-				}, runLockedTask);
-			} catch (error) {
-				if (taskError === error) throw error;
-				emitCoordinationDegradedOnce((isObject(error) ? String(error.code || "") : "") === NonceCoordinatorDegradationReason.DurableLockTimeout ? NonceCoordinatorDegradationReason.DurableLockTimeout : NonceCoordinatorDegradationReason.DurableStoreError, {
-					lane,
-					fallback: NonceCoordinatorFallback.None
-				});
-				throw error;
-			}
-		}
-		if (shouldWarnOnMissingCoordinationStore) emitCoordinationDegradedOnce(NonceCoordinatorDegradationReason.WebLocksUnavailable, { lane });
-		return await runLocal();
-	};
-	const expireLeaseLocked = async (lease, nowMs) => {
-		if (lease.expiresAtMs > nowMs) return null;
-		if (lease.state !== NonceLeaseState.Reserved && lease.state !== NonceLeaseState.Signed) return null;
-		const expiringFromState = lease.state;
-		if (lease.state === NonceLeaseState.Signed) await reconcileAfterSignedLeaseExpiry(lease);
-		else await releaseBackendReservation(lease);
-		transitionLease({
-			lease,
-			transition: "expire",
-			event: NonceCoordinatorTraceEventName.LeaseExpired,
-			reason: expiringFromState === NonceLeaseState.Signed ? "signed_lease_ttl_elapsed" : "lease_ttl_elapsed"
-		});
-		return { ...lease };
-	};
-	const expireDueLeasesForLockedLane = async (lane) => {
-		const nowMs = now();
-		const laneKey = nonceLaneKey(lane);
-		const expired = [];
-		for (const lease of Array.from(leases.values())) {
-			if (nonceLaneKey(lease.lane) !== laneKey) continue;
-			const expiredLease = await expireLeaseLocked(lease, nowMs);
-			if (expiredLease) expired.push(expiredLease);
-		}
-		return expired;
-	};
-	const expireDueLeasesForWallet = async (input) => {
-		const walletId = input?.walletId ? String(input.walletId).trim() : "";
-		const laneByKey = /* @__PURE__ */ new Map();
-		for (const lease of Array.from(leases.values())) {
-			if (walletId && nonceLaneSubjectId(lease.lane) !== walletId) continue;
-			laneByKey.set(nonceLaneKey(lease.lane), lease.lane);
-		}
-		const expired = [];
-		for (const lane of laneByKey.values()) expired.push(...await withLaneLock(lane, async () => expireDueLeasesForLockedLane(lane)));
-		return expired;
-	};
-	const recoverDurableLeases = async (input) => {
-		if (!nonceLaneCoordinationStore) {
-			if (shouldWarnOnMissingCoordinationStore) emitCoordinationDegradedOnce(NonceCoordinatorDegradationReason.IndexedDBUnavailable);
-			return;
-		}
-		let readResults = [];
-		try {
-			readResults = await nonceLaneCoordinationStore.readAllForRecovery(input);
-		} catch {
-			emitCoordinationDegradedOnce(NonceCoordinatorDegradationReason.DurableStoreError);
-			return;
-		}
-		for (const readResult of readResults) {
-			if (!readResult.ok) {
-				if (readResult.leaseId) await nonceLaneCoordinationStore.remove({
-					laneKey: readResult.laneKey,
-					leaseId: readResult.leaseId
-				});
-				emitCoordinationDegradedOnce(readResult.degradation.reason, {
-					accountId: readResult.degradation.accountId,
-					networkKey: readResult.degradation.networkKey,
-					laneFamily: readResult.degradation.laneFamily,
-					fallback: readResult.degradation.fallback
-				});
-				continue;
-			}
-			const { record, lane, canonicalLaneKey, nonce: recordNonce } = readResult.parsed;
-			await withLaneLock(lane, async () => {
-				if (record.laneKey !== canonicalLaneKey) {
-					await nonceLaneCoordinationStore.remove({
-						laneKey: record.laneKey,
-						leaseId: record.leaseId
-					});
-					emitCoordinationDegradedOnce(NonceCoordinatorDegradationReason.MalformedDurableRecord, {
-						accountId: nonceLaneSubjectId(lane),
-						networkKey: record.networkKey,
-						laneFamily: record.family,
-						fallback: NonceCoordinatorFallback.None
-					});
-					return;
-				}
-				const isExpired = record.expiresAtMs <= now();
-				if (isExpired && record.state !== NonceDurableLeaseState.BroadcastAccepted) {
-					await nonceLaneCoordinationStore.remove({
-						laneKey: record.laneKey,
-						leaseId: record.leaseId
-					});
-					if (record.family === "evm") await reconcileEvmLaneLocked(lane).catch(() => null);
-					emit({
-						event: NonceCoordinatorTraceEventName.LaneReconciled,
-						lane,
-						reason: "startup_recovery_expired_lease"
-					});
-					return;
-				}
-				if (record.family === "evm") {
-					const evmLane = lane;
-					const state = getOrCreateEvmState(record.laneKey);
-					let broadcastStatus = null;
-					if (record.state === NonceDurableLeaseState.BroadcastAccepted) {
-						const txHash = requireRecoveredEvmTxHash(record.txHash);
-						state.inFlight.set(record.nonce.toString(), {
-							nonce: recordNonce,
-							txHash,
-							status: "accepted",
-							acceptedAtMs: record.reservedAtMs,
-							updatedAtMs: record.updatedAtMs
-						});
-						broadcastStatus = await deps.evmNonceBackend.fetchBroadcastTransactionStatus({
-							...evmLaneToReserveNonceInput(evmLane),
-							txHash
-						}).catch(() => null);
-						if (broadcastStatus?.kind === "finalized") {
-							state.inFlight.delete(record.nonce.toString());
-							await nonceLaneCoordinationStore.remove({
-								laneKey: record.laneKey,
-								leaseId: record.leaseId
-							});
-							await reconcileEvmLaneLocked(evmLane).catch(() => null);
-							emit({
-								event: NonceCoordinatorTraceEventName.LaneReconciled,
-								lane: evmLane,
-								reason: "startup_recovery_finalized_transaction",
-								txHash: record.txHash
-							});
-							return;
-						}
-					}
-					const status = await reconcileEvmLaneLocked(evmLane).catch(() => null);
-					const chainAdvanced = !!status && status.chainNextNonce > recordNonce;
-					const staleMissingBroadcast = record.state === NonceDurableLeaseState.BroadcastAccepted && broadcastStatus?.kind === "missing" && isExpired;
-					if (chainAdvanced || staleMissingBroadcast) {
-						state.inFlight.delete(record.nonce.toString());
-						await nonceLaneCoordinationStore.remove({
-							laneKey: record.laneKey,
-							leaseId: record.leaseId
-						});
-					}
-					emit({
-						event: NonceCoordinatorTraceEventName.LaneReconciled,
-						lane: evmLane,
-						reason: staleMissingBroadcast ? "startup_recovery_dropped_transaction" : "startup_recovery",
-						...staleMissingBroadcast && record.state === NonceDurableLeaseState.BroadcastAccepted ? { txHash: record.txHash } : {}
-					});
-					return;
-				}
-				if (record.family === "near" && deps.nearClient) try {
-					const accessKey = await deps.nearClient.viewAccessKey(record.nearAccountId, record.publicKey);
-					if (isAccessKeyViewLike(accessKey) && BigInt(accessKey.nonce) >= recordNonce) await nonceLaneCoordinationStore.remove({
-						laneKey: record.laneKey,
-						leaseId: record.leaseId
-					});
-				} catch {}
-			});
-		}
-	};
-	const reserveNearNonceBatchUnlocked = async (input) => {
-		await expireDueLeasesForLockedLane(input.lane);
-		const count = Math.max(1, Math.floor(Number(input.count || 1)));
-		const nonces = await reserveNearNonces(input.lane, count);
-		if (nonces.length !== count) throw new Error("[NonceCoordinator] NEAR nonce reservation returned an incomplete batch");
-		const reservedAtMs = now();
-		const batchId = createNonceBatchId({
-			operationId: input.operation.operationId,
-			chain: "near",
-			firstNonce: nonces[0],
-			count
-		});
-		const batchLeases = nonces.map((nonce, txIndex) => ({
-			leaseId: createNonceLeaseId({
-				operationId: input.operation.operationId,
-				chain: "near",
-				nonce
-			}),
-			lane: input.lane,
-			operationId: input.operation.operationId,
-			operationFingerprint: input.operation.operationFingerprint,
-			nonce,
-			state: NonceLeaseState.Reserved,
-			reservedAtMs,
-			expiresAtMs: reservedAtMs + leaseTtlMs,
-			batchId,
-			txIndex
-		}));
-		for (const lease of batchLeases) {
-			leases.set(lease.leaseId, lease);
-			await persistCoordinationLease(lease, { state: NonceDurableLeaseState.Reserved });
-			emit({
-				event: NonceCoordinatorTraceEventName.LeaseReserved,
-				lease
-			});
-		}
-		return batchLeases.map((lease) => ({ ...lease }));
-	};
-	const readDiagnostics = (input) => {
-		const accountId = input?.accountId ? String(input.accountId).trim() : "";
-		const diagnostics = createNonceCoordinatorDiagnostics({
-			options: input,
-			leases: leases.values(),
-			nearState,
-			observedCoordinationDegradations: observedCoordinationDegradations.values(),
-			outcomeMetricEvents,
-			nowMs: now()
-		});
-		if (input?.emitMetrics) emit({
-			event: NonceCoordinatorTraceEventName.Metrics,
-			metrics: diagnostics.metrics,
-			...accountId ? { accountId } : {}
-		});
-		return diagnostics;
-	};
-	return {
-		async reserve(input) {
-			if (input.lane.family === "near") {
-				const nearLane = input.lane;
-				return await withLaneLock(nearLane, async () => {
-					return (await reserveNearNonceBatchUnlocked({
-						lane: nearLane,
-						operation: input.operation,
-						count: 1
-					}))[0];
-				});
-			}
-			const evmLane = input.lane;
-			return await withLaneLock(evmLane, async () => {
-				return await reserveEvmNonceLeaseUnlocked({
-					lane: evmLane,
-					operation: input.operation
-				});
-			});
-		},
-		async reserveBatch(input) {
-			return await withLaneLock(input.lane, async () => {
-				return await reserveNearNonceBatchUnlocked(input);
-			});
-		},
-		async reserveNearContext(input) {
-			return await withLaneLock(input.lane, async () => {
-				initializeNearAccessKey({
-					walletId: input.lane.walletId,
-					nearAccountId: input.lane.nearAccountId,
-					publicKey: input.lane.publicKey
-				});
-				const context = { ...input.fetchContext ? await input.fetchContext() : await fetchNearContextForLane({
-					lane: input.lane,
-					nearClient: input.nearClient,
-					force: input.force === false ? false : true
-				}) };
-				commitNearTransactionContextForState({
-					state: nearState,
-					walletId: input.lane.walletId,
-					nearAccountId: input.lane.nearAccountId,
-					publicKey: input.lane.publicKey,
-					transactionContext: context,
-					nowMs: now()
-				});
-				const leases = await reserveNearNonceBatchUnlocked({
-					lane: input.lane,
-					operation: input.operation,
-					count: input.count
-				});
-				if (leases[0]) context.nextNonce = String(leases[0].nonce);
-				return {
-					context,
-					leases
-				};
-			});
-		},
-		initializeNearAccessKey,
-		getActiveNearPublicKey() {
-			return readNearActivePublicKey(nearState);
-		},
-		async fetchNearContext(input) {
-			return await withLaneLock(input.lane, async () => fetchNearContextForLane(input));
-		},
-		async prefetchNearContext(input) {
-			if (input?.kind === "access_key_subject") initializeNearAccessKey({
-				walletId: input.walletId,
-				nearAccountId: input.nearAccountId,
-				publicKey: input.publicKey
-			});
-			if (!readNearAccessKeySubject(nearState)) return;
-			clearNearPrefetchTimer(nearState);
-			const nearClient = requireNearClient(input?.nearClient);
-			nearState.prefetchTimer = setTimeout(() => {
-				nearState.prefetchTimer = null;
-				if (hasNearInflightFetch(nearState)) return;
-				if (!shouldPrefetchNearContext({
-					state: nearState,
-					nowMs: now(),
-					blockFreshnessThresholdMs: NEAR_BLOCK_FRESHNESS_THRESHOLD_MS
-				})) return;
-				fetchNearFreshData(nearClient).catch(() => void 0);
-			}, NEAR_PREFETCH_DEBOUNCE_MS);
-		},
-		clearNearAccessKey() {
-			clearNearAccessKeyState$1();
-			for (const [leaseId, lease] of leases.entries()) if (lease.lane.family === "near") leases.delete(leaseId);
-		},
-		async markSigned(input) {
-			const operationInput = normalizeLeaseOperationInput(input);
-			return await withLaneLock(readLease(operationInput).lane, async () => {
-				const lockedLease = readLease(operationInput);
-				const expiresAtMs = now() + signedLeaseTtlMs;
-				transitionLease({
-					lease: lockedLease,
-					transition: "mark_signed",
-					event: NonceCoordinatorTraceEventName.LeaseSigned,
-					expiresAtMs,
-					...input.signedTxHash ? { txHash: input.signedTxHash } : {}
-				});
-				await persistCoordinationLease(lockedLease, { state: NonceDurableLeaseState.Signed }, expiresAtMs);
-			});
-		},
-		async markBroadcastAccepted(input) {
-			const operationInput = normalizeLeaseOperationInput(input);
-			return await withLaneLock(readLease(operationInput).lane, async () => {
-				const lockedLease = readLease(operationInput);
-				preflightLeaseTransition(lockedLease, "broadcast_accepted");
-				if (isEvmNonceLease(lockedLease)) await markEvmBroadcastAccepted(lockedLease, String(input.txHash));
-				else if (isNearNonceLease(lockedLease)) await markNearBroadcastAcceptedState({
-					lease: lockedLease,
-					state: nearState,
-					txHash: String(input.txHash),
-					nowMs: now(),
-					persistCoordinationLease
-				});
-				else assertNever(lockedLease);
-				transitionLease({
-					lease: lockedLease,
-					transition: "broadcast_accepted",
-					event: NonceCoordinatorTraceEventName.LeaseBroadcastAccepted,
-					txHash: String(input.txHash)
-				});
-			});
-		},
-		async markBroadcastRejected(input) {
-			const operationInput = normalizeLeaseOperationInput(input);
-			return await withLaneLock(readLease(operationInput).lane, async () => {
-				const lockedLease = readLease(operationInput);
-				preflightLeaseTransition(lockedLease, "broadcast_rejected");
-				await releaseBackendReservation(lockedLease);
-				if (isNearNonceLease(lockedLease) && deps.nearClient) try {
-					await refreshNearNonceAfterBroadcastRejected(deps.nearClient);
-				} catch {}
-				transitionLease({
-					lease: lockedLease,
-					transition: "broadcast_rejected",
-					event: NonceCoordinatorTraceEventName.LeaseBroadcastRejected,
-					reason: input.error instanceof Error ? input.error.message : String(input.error || "")
-				});
-			});
-		},
-		async markFinalized(input) {
-			const operationInput = normalizeLeaseOperationInput(input);
-			return await withLaneLock(readLease(operationInput).lane, async () => {
-				const lockedLease = readLease(operationInput);
-				preflightLeaseTransition(lockedLease, "finalize");
-				if (isEvmNonceLease(lockedLease)) await markEvmFinalized(lockedLease);
-				else if (isNearNonceLease(lockedLease)) {
-					if (deps.nearClient) await updateNearNonceFromBlockchain(deps.nearClient, String(lockedLease.nonce));
-					else await releaseBackendReservation(lockedLease);
-					await removeCoordinationLease(lockedLease);
-				} else assertNever(lockedLease);
-				transitionLease({
-					lease: lockedLease,
-					transition: "finalize",
-					event: NonceCoordinatorTraceEventName.LeaseFinalized,
-					...input.txHash ? { txHash: String(input.txHash) } : {}
-				});
-			});
-		},
-		async markDroppedOrReplaced(input) {
-			const operationInput = normalizeLeaseOperationInput(input);
-			const lease = readLease(operationInput);
-			assertEvmLease(lease);
-			return await withLaneLock(lease.lane, async () => {
-				const lockedLease = readLease(operationInput);
-				assertEvmLease(lockedLease);
-				preflightLeaseTransition(lockedLease, input.reason === EvmNonceOutcomeReason.Replaced ? "replace" : "drop");
-				await markEvmDroppedOrReplaced(lockedLease, {
-					reason: input.reason,
-					...input.txHash ? { txHash: String(input.txHash) } : {}
-				});
-				transitionLease({
-					lease: lockedLease,
-					transition: input.reason === EvmNonceOutcomeReason.Replaced ? "replace" : "drop",
-					event: input.reason === EvmNonceOutcomeReason.Replaced ? NonceCoordinatorTraceEventName.LeaseReplaced : NonceCoordinatorTraceEventName.LeaseDropped,
-					reason: input.reason,
-					...input.txHash ? { txHash: String(input.txHash) } : {}
-				});
-				recordDroppedReplacedAlert({
-					lane: lockedLease.lane,
-					reason: input.reason
-				});
-			});
-		},
-		async release(input) {
-			const operationInput = normalizeLeaseOperationInput(input);
-			return await withLaneLock(readLease(operationInput).lane, async () => {
-				const lockedLease = readLease(operationInput);
-				preflightLeaseTransition(lockedLease, "release");
-				await releaseBackendReservation(lockedLease);
-				transitionLease({
-					lease: lockedLease,
-					transition: "release",
-					event: NonceCoordinatorTraceEventName.LeaseReleased,
-					reason: input.reason
-				});
-			});
-		},
-		async expireLeases(input) {
-			return await expireDueLeasesForWallet(input);
-		},
-		async recoverDurableLeases(input) {
-			await recoverDurableLeases(input);
-		},
-		async reconcile(input) {
-			return await withLaneLock(input.lane, async () => {
-				const status = input.lane.family === "evm" ? await reconcileEvmLaneLocked(input.lane) : await reconcileNearLaneLocked(input.lane);
-				emit({
-					event: NonceCoordinatorTraceEventName.LaneReconciled,
-					lane: input.lane
-				});
-				return status;
-			});
-		},
-		clearForWallet(walletId) {
-			const normalizedWalletId = String(walletId || "").trim();
-			if (!normalizedWalletId) return;
-			nonceLaneCoordinationStore?.clearForWallet(normalizedWalletId).catch(() => emitCoordinationDegradedOnce(NonceCoordinatorDegradationReason.DurableStoreError));
-			const evmLaneKeys = evmAccountLaneKeys.get(normalizedWalletId);
-			if (evmLaneKeys) {
-				for (const key of evmLaneKeys) evmStates.delete(key);
-				evmAccountLaneKeys.delete(normalizedWalletId);
-			}
-			if (readNearAccessKeySubject(nearState)?.walletId === normalizedWalletId) clearNearAccessKeyState$1();
-			for (const [leaseId, lease] of leases.entries()) if (nonceLaneSubjectId(lease.lane) === normalizedWalletId) leases.delete(leaseId);
-			emit({
-				event: NonceCoordinatorTraceEventName.LanesCleared,
-				accountId: normalizedWalletId,
-				reason: "clear_for_account"
-			});
-		},
-		clearAll() {
-			evmStates.clear();
-			evmAccountLaneKeys.clear();
-			droppedReplacedAlerts.clear();
-			nonceLaneCoordinationStore?.clearAll().catch(() => emitCoordinationDegradedOnce(NonceCoordinatorDegradationReason.DurableStoreError));
-			clearNearAccessKeyState$1();
-			leases.clear();
-			laneLocks.clear();
-			emit({
-				event: NonceCoordinatorTraceEventName.LanesCleared,
-				reason: "clear_all"
-			});
-		},
-		getDiagnostics(input) {
-			return readDiagnostics(input);
-		}
-	};
-}
-function requireRecoveredEvmTxHash(value) {
-	const normalized = value.trim().toLowerCase();
-	if (!/^0x[0-9a-f]{64}$/.test(normalized)) throw new Error("[NonceCoordinator] recovered EVM broadcast record has invalid txHash");
-	return normalized;
-}
-function isEvmNonceLease(lease) {
-	return lease.lane.family === "evm";
-}
-function isNearNonceLease(lease) {
-	return lease.lane.family === "near";
-}
-function assertNever(value) {
-	throw new Error(`Unexpected nonce lease variant: ${String(value)}`);
-}
-function buildEvmCoordinationRecord(args) {
-	const lease = args.lease;
-	const common = {
-		v: 1,
-		laneKey: nonceLaneKey(lease.lane),
-		leaseId: lease.leaseId,
-		networkKey: nonceLaneNetworkKey(lease.lane),
-		nonce: lease.nonce,
-		operationId: String(lease.operationId),
-		operationFingerprint: String(lease.operationFingerprint),
-		reservedAtMs: lease.reservedAtMs,
-		expiresAtMs: args.expiresAtMs,
-		updatedAtMs: args.updatedAtMs,
-		runtimeId: args.runtimeId,
-		family: "evm",
-		chainTarget: lease.lane.chainTarget,
-		accountId: lease.lane.subjectId,
-		sender: lease.lane.sender,
-		...lease.lane.nonceKey != null ? { nonceKey: lease.lane.nonceKey } : {},
-		...buildLeaseRecordMetadata(lease)
-	};
-	switch (args.lifecycle.state) {
-		case NonceDurableLeaseState.Reserved:
-		case NonceDurableLeaseState.Signed: return {
-			...common,
-			state: args.lifecycle.state
-		};
-		case NonceDurableLeaseState.BroadcastAccepted: return {
-			...common,
-			state: NonceDurableLeaseState.BroadcastAccepted,
-			txHash: requireRecoveredEvmTxHash(args.lifecycle.txHash)
-		};
-	}
-}
-function buildNearCoordinationRecord(args) {
-	const lease = args.lease;
-	const common = {
-		v: 1,
-		laneKey: nonceLaneKey(lease.lane),
-		leaseId: lease.leaseId,
-		networkKey: nonceLaneNetworkKey(lease.lane),
-		nonce: BigInt(lease.nonce),
-		operationId: String(lease.operationId),
-		operationFingerprint: String(lease.operationFingerprint),
-		reservedAtMs: lease.reservedAtMs,
-		expiresAtMs: args.expiresAtMs,
-		updatedAtMs: args.updatedAtMs,
-		runtimeId: args.runtimeId,
-		family: "near",
-		walletId: lease.lane.walletId,
-		nearAccountId: lease.lane.nearAccountId,
-		publicKey: lease.lane.publicKey,
-		...buildLeaseRecordMetadata(lease)
-	};
-	switch (args.lifecycle.state) {
-		case NonceDurableLeaseState.Reserved:
-		case NonceDurableLeaseState.Signed: return {
-			...common,
-			state: args.lifecycle.state
-		};
-		case NonceDurableLeaseState.BroadcastAccepted: return {
-			...common,
-			state: NonceDurableLeaseState.BroadcastAccepted,
-			txHash: args.lifecycle.txHash
-		};
-	}
-}
-function buildLeaseRecordMetadata(lease) {
-	return {
-		...lease.batchId ? { batchId: lease.batchId } : {},
-		...Number.isSafeInteger(lease.txIndex) ? { txIndex: lease.txIndex } : {}
-	};
-}
-function createDefaultSameOriginLock() {
-	const locks = globalThis.navigator?.locks;
-	if (typeof locks?.request !== "function") return null;
-	return { async withLock(key, task) {
-		return await locks.request(key, { mode: "exclusive" }, task);
-	} };
-}
-//#endregion
-export { buildNearNonceLane as n, createNonceCoordinator as t };