@seams/wallet 0.7.1 → 0.8.0

package/dist/public/sdk/transactionState-DP9O8F6f.js

@@ -1,1885 +0,0 @@
-import { P as normalizeBoundedPositiveInteger, r as mpcMaterialActivationRefsEqual } from "./domainIds-lcrFg6Sa.js";
-import { nt as walletAuthAuthorityRef } from "./ecdsaPresignLifecycle-BFOTNYCK.js";
-import { c as toWalletId, o as thresholdEcdsaChainTargetKey, s as thresholdEcdsaChainTargetsEqual } from "./ecdsaChainTarget-Bl-JWyuw.js";
-import { t as toAccountId } from "./accountIds-DhIPGOSN.js";
-import { f as deriveEvmFamilyKeyFingerprintFromPublicFacts, x as toRpId } from "./evmFamilyEcdsaIdentity-Co5XDcEA.js";
-import { i as nearEd25519SigningKeyIdFromString } from "./registrationIds-DLSdEKSv.js";
-import { t as parseSignerSlot } from "./signerSlot-_ovonwVX.js";
-import { c as signingLaneAuthMethod, s as signingLaneAuthBindingKey } from "./types-Dx9fczU7.js";
-import { u as exactSigningLaneWalletId } from "./exactSigningLaneIdentity-DQeqPMST.js";
-import { S as selectedEd25519Lane, a as nearEd25519SessionMatchesMaterialActivation, x as selectedEcdsaLane, y as laneCandidateAuthMethod } from "./nearEd25519YaoSigningPreparation-BeD-SmbK.js";
-//#region src/core/signingEngine/threshold/commitQueueShared.ts
-const DEFAULT_MAX_QUEUE_LENGTH = 8;
-const DEFAULT_QUEUE_TIMEOUT_MS = 45e3;
-function normalizeQueueLimit(value, fallback) {
-	return normalizeBoundedPositiveInteger(value, {
-		fallback,
-		min: 1
-	});
-}
-function getOrCreateQueueState(queueByKey, queueKey) {
-	const existing = queueByKey.get(queueKey);
-	if (existing) return existing;
-	const created = {
-		running: false,
-		items: []
-	};
-	queueByKey.set(queueKey, created);
-	return created;
-}
-function clearQueueItemTimeout(item) {
-	if (!item.timeoutHandle) return;
-	clearTimeout(item.timeoutHandle);
-	item.timeoutHandle = null;
-}
-async function drainQueueForKey(queueByKey, queueKey) {
-	const state = queueByKey.get(queueKey);
-	if (!state || state.running) return;
-	state.running = true;
-	try {
-		while (state.items.length > 0) {
-			const item = state.items.shift();
-			if (!item) continue;
-			if (item.isSettled()) continue;
-			clearQueueItemTimeout(item);
-			if (item.shouldAbort?.()) {
-				item.reject(item.makeCancelledError("cancelled"));
-				continue;
-			}
-			if (Date.now() - item.enqueuedAtMs > item.timeoutMs) {
-				item.reject(item.makeTimeoutError(item.timeoutMs));
-				continue;
-			}
-			try {
-				await item.run();
-			} catch (error) {
-				item.reject(error);
-			}
-		}
-	} finally {
-		state.running = false;
-		if (state.items.length === 0 && queueByKey.get(queueKey) === state) queueByKey.delete(queueKey);
-		else if (state.items.length > 0) drainQueueForKey(queueByKey, queueKey);
-	}
-}
-function clearThresholdCommitQueue(queueByKey) {
-	for (const state of queueByKey.values()) {
-		for (const item of state.items) {
-			clearQueueItemTimeout(item);
-			item.reject(item.makeCancelledError("queue_cleared"));
-		}
-		state.items.length = 0;
-	}
-	queueByKey.clear();
-}
-async function withThresholdCommitQueue(args) {
-	if (!args.enabled) return await args.task();
-	const queueKey = String(args.queueKey || "").trim();
-	if (!queueKey) throw new Error("[SigningEngine] threshold commit queue requires non-empty queueKey");
-	const maxQueueLength = normalizeQueueLimit(args.maxQueueLength, DEFAULT_MAX_QUEUE_LENGTH);
-	const queueTimeoutMs = normalizeQueueLimit(args.queueTimeoutMs, DEFAULT_QUEUE_TIMEOUT_MS);
-	const state = getOrCreateQueueState(args.queueByKey, queueKey);
-	if (state.items.length + (state.running ? 1 : 0) >= maxQueueLength) throw args.errors.makeOverflowError(queueKey, maxQueueLength);
-	return await new Promise((resolve, reject) => {
-		let timeoutHandle = null;
-		let settled = false;
-		const clearTimeoutHandle = () => {
-			if (!timeoutHandle) return;
-			clearTimeout(timeoutHandle);
-			timeoutHandle = null;
-		};
-		const rejectOnce = (error) => {
-			if (settled) return;
-			settled = true;
-			clearTimeoutHandle();
-			reject(error);
-		};
-		const resolveOnce = (value) => {
-			if (settled) return;
-			settled = true;
-			clearTimeoutHandle();
-			resolve(value);
-		};
-		const makeCancelledError = (reason) => args.errors.makeCancelledError(queueKey, reason);
-		const makeTimeoutError = (timeoutMs) => args.errors.makeTimeoutError(queueKey, timeoutMs);
-		const item = {
-			enqueuedAtMs: Date.now(),
-			timeoutMs: queueTimeoutMs,
-			shouldAbort: args.shouldAbort,
-			timeoutHandle: null,
-			isSettled: () => settled,
-			reject: rejectOnce,
-			makeCancelledError,
-			makeTimeoutError,
-			run: async () => {
-				if (args.shouldAbort?.()) throw makeCancelledError("cancelled");
-				resolveOnce(await args.task());
-			}
-		};
-		timeoutHandle = setTimeout(() => {
-			if (item.isSettled()) return;
-			const idx = state.items.indexOf(item);
-			if (idx >= 0) state.items.splice(idx, 1);
-			rejectOnce(makeTimeoutError(queueTimeoutMs));
-			if (!state.running && state.items.length === 0 && args.queueByKey.get(queueKey) === state) args.queueByKey.delete(queueKey);
-		}, queueTimeoutMs);
-		item.timeoutHandle = timeoutHandle;
-		state.items.push(item);
-		drainQueueForKey(args.queueByKey, queueKey);
-	});
-}
-//#endregion
-//#region src/core/signingEngine/session/identity/clientSessionPersistenceState.ts
-function authorizationIdentity(source) {
-	const common = {
-		walletId: exactSigningLaneWalletId(source.laneIdentity),
-		authMethod: signingLaneAuthMethod(source.laneIdentity.auth),
-		laneIdentity: source.laneIdentity
-	};
-	if (source.kind === "ecdsa") return {
-		...common,
-		walletSessionId: source.authorization.operationCredential.walletSessionId,
-		quotaId: source.authorization.session.quotaId
-	};
-	return {
-		...common,
-		walletSessionId: source.laneIdentity.walletSessionId,
-		quotaId: source.laneIdentity.quotaId
-	};
-}
-function invalidAuthorization(args) {
-	return {
-		kind: "invalid",
-		...authorizationIdentity(args.source),
-		reason: args.reason
-	};
-}
-function parseBoundaryTime(value) {
-	const parsed = Number(value);
-	if (!Number.isSafeInteger(parsed) || parsed < 0) return null;
-	return parsed;
-}
-function requireAuthoritativeExpiredWalletSessionAuthorizationBoundary(args) {
-	const expiresAtMs = parseBoundaryTime(args.expiresAtMs);
-	const detectedAtMs = parseBoundaryTime(args.detectedAtMs);
-	if (expiresAtMs === null || expiresAtMs === 0) throw new Error("Authoritative expired Wallet Session expiresAtMs is invalid");
-	if (detectedAtMs === null || detectedAtMs === 0) throw new Error("Authoritative expired Wallet Session detectedAtMs is invalid");
-	if (expiresAtMs > detectedAtMs) throw new Error("Authoritative expired Wallet Session timeline is invalid");
-	return {
-		kind: "expired",
-		...authorizationIdentity(args.source),
-		expiresAtMs,
-		detectedAtMs
-	};
-}
-function parseFoundAuthorization(args) {
-	const expiresAtMs = parseBoundaryTime(args.observation.expiresAtMs);
-	if (expiresAtMs === null || expiresAtMs === 0) return invalidAuthorization({
-		source: args.observation.source,
-		reason: "malformed"
-	});
-	const identity = authorizationIdentity(args.observation.source);
-	if (expiresAtMs <= args.nowMs) return {
-		kind: "expired",
-		...identity,
-		expiresAtMs,
-		detectedAtMs: args.nowMs
-	};
-	return {
-		kind: "active",
-		...identity,
-		expiresAtMs
-	};
-}
-function parseWalletSessionAuthorizationBoundary(args) {
-	const nowMs = parseBoundaryTime(args.nowMs);
-	if (nowMs === null) return invalidAuthorization({
-		source: args.observation.source,
-		reason: "malformed"
-	});
-	switch (args.observation.kind) {
-		case "found": return parseFoundAuthorization({
-			observation: args.observation,
-			nowMs
-		});
-		case "missing": return {
-			kind: "missing",
-			...authorizationIdentity(args.observation.source)
-		};
-		case "unavailable": return {
-			kind: "unavailable",
-			...authorizationIdentity(args.observation.source),
-			reason: args.observation.reason
-		};
-		case "invalid": return invalidAuthorization({
-			source: args.observation.source,
-			reason: args.observation.reason
-		});
-		default: return args.observation;
-	}
-}
-//#endregion
-//#region src/core/signingEngine/session/availability/canonicalLaneInventory.ts
-function serverIssuedGenerationFromNumber(value) {
-	const normalized = Math.floor(Number(value));
-	if (!Number.isFinite(normalized) || normalized <= 0) return null;
-	return normalized.toString(10).padStart(20, "0");
-}
-function canonicalizeLaneFacts(facts, adapter) {
-	if (facts.length === 0) return {
-		kind: "no_current_lane",
-		unusableFacts: []
-	};
-	const groups = canonicalFactGroups(facts, adapter);
-	const conflicts = canonicalFactGroupConflicts(groups, adapter);
-	if (conflicts.length) return {
-		kind: "conflicting_key_material",
-		conflicts
-	};
-	if (groups.length !== 1) return {
-		kind: "ambiguous_material",
-		candidates: facts
-	};
-	const group = groups[0];
-	if (!group) return {
-		kind: "no_current_lane",
-		unusableFacts: []
-	};
-	return canonicalizeSingleLaneFactGroup(group, adapter.supersession);
-}
-function canonicalizeSingleLaneFactGroup(group, supersession) {
-	const usableFacts = group.facts.filter(supersession.isOperationUsable);
-	if (usableFacts.length === 0) return {
-		kind: "no_current_lane",
-		unusableFacts: group.facts
-	};
-	const selected = selectCanonicalFact(usableFacts, supersession);
-	if (selected.kind === "ambiguous") return {
-		kind: "ambiguous_material",
-		candidates: selected.candidates
-	};
-	return {
-		kind: "selected",
-		selectedFact: selected.fact,
-		supersededFacts: group.facts.filter((fact) => fact !== selected.fact)
-	};
-}
-function canonicalFactGroups(facts, adapter) {
-	const groupsByKey = /* @__PURE__ */ new Map();
-	for (const fact of facts) {
-		const groupKey = adapter.groupKey(fact);
-		const encodedGroupKey = adapter.groupKeyString(groupKey);
-		const existingGroup = groupsByKey.get(encodedGroupKey);
-		groupsByKey.set(encodedGroupKey, existingGroup ? {
-			groupKey: existingGroup.groupKey,
-			facts: [...existingGroup.facts, fact]
-		} : {
-			groupKey,
-			facts: [fact]
-		});
-	}
-	return [...groupsByKey.values()];
-}
-function canonicalFactGroupConflicts(groups, adapter) {
-	return groups.flatMap((group) => adapter.groupConflicts(group.facts));
-}
-function selectCanonicalFact(facts, supersession) {
-	const firstFact = facts[0];
-	if (firstFact === void 0) return {
-		kind: "ambiguous",
-		candidates: []
-	};
-	let selectedFact = firstFact;
-	for (const candidateFact of facts.slice(1)) {
-		const preference = canonicalFactPreference(selectedFact, candidateFact, supersession);
-		switch (preference.kind) {
-			case "left": break;
-			case "right":
-				selectedFact = candidateFact;
-				break;
-			case "ambiguous": return {
-				kind: "ambiguous",
-				candidates: preference.candidates
-			};
-			default: return preference;
-		}
-	}
-	return {
-		kind: "selected",
-		fact: selectedFact
-	};
-}
-function canonicalFactPreference(left, right, supersession) {
-	const generationPreference = canonicalGenerationPreference(left, right, supersession);
-	if (generationPreference.kind !== "equal") return generationPreference;
-	const exactnessPreference = canonicalExactnessPreference(left, right, supersession);
-	if (exactnessPreference.kind !== "equal") return exactnessPreference;
-	const tieBreakPreference = supersession.tieBreak(left, right);
-	switch (tieBreakPreference) {
-		case 1: return { kind: "left" };
-		case -1: return { kind: "right" };
-		case 0: return {
-			kind: "ambiguous",
-			candidates: [left, right]
-		};
-		default: return tieBreakPreference;
-	}
-}
-function canonicalGenerationPreference(left, right, supersession) {
-	const leftGeneration = supersession.generation(left);
-	const rightGeneration = supersession.generation(right);
-	if (!leftGeneration || !rightGeneration) return {
-		kind: "ambiguous",
-		candidates: [left, right]
-	};
-	if (leftGeneration > rightGeneration) return { kind: "left" };
-	if (rightGeneration > leftGeneration) return { kind: "right" };
-	return { kind: "equal" };
-}
-function canonicalExactnessPreference(left, right, supersession) {
-	const leftExactness = supersession.exactness(left);
-	if (leftExactness === supersession.exactness(right)) return { kind: "equal" };
-	if (leftExactness === "exact_target") return { kind: "left" };
-	return { kind: "right" };
-}
-//#endregion
-//#region src/core/signingEngine/session/availability/availableSigningLanes.ts
-function activeWalletAuthorityAvailableLaneFromProjection(projection) {
-	const base = {
-		source: projection.source,
-		runtime: projection.runtime,
-		key: projection.key,
-		materialActivation: projection.materialActivation,
-		publicFacts: projection.publicFacts,
-		curve: "ecdsa",
-		chainTarget: projection.chainTarget,
-		state: projection.state,
-		authorizationState: projection.authorizationState
-	};
-	if (projection.auth.kind === "passkey") {
-		if (!projection.resolvedKey) throw new Error("active Wallet Authority passkey lane is missing its resolved ECDSA key");
-		return {
-			...base,
-			auth: projection.auth,
-			resolvedKey: projection.resolvedKey
-		};
-	}
-	return {
-		...base,
-		auth: projection.auth
-	};
-}
-function ecdsaAuthorizationPolicyMatchesLane(lane) {
-	const authorization = lane.authorization;
-	if (!authorization) return true;
-	return lane.remainingUses === authorization.runtime.remainingUses && lane.expiresAtMs === authorization.runtime.expiresAtMs;
-}
-function materialActivationKey(activation) {
-	return [
-		activation.activationId,
-		activation.capability,
-		activation.materialOwner,
-		activation.keyBinding,
-		activation.lifecycleBinding,
-		activation.signingWorker
-	].map((part) => encodeURIComponent(String(part))).join(":");
-}
-function availableEcdsaSigningLaneAuthMethod(lane) {
-	return signingLaneAuthMethod(lane.auth);
-}
-function availableEd25519SigningLaneAuthMethod(lane) {
-	return signingLaneAuthMethod(lane.auth);
-}
-function durableEd25519AuthBinding(record) {
-	const restore = record.ed25519Restore;
-	if (record.authMethod === "passkey") {
-		if (!restore.credentialIdB64u) return null;
-		try {
-			return {
-				kind: "passkey",
-				rpId: toRpId(restore.rpId),
-				credentialIdB64u: restore.credentialIdB64u
-			};
-		} catch {
-			return null;
-		}
-	}
-	if (!restore.providerSubjectId) return null;
-	return {
-		kind: "email_otp",
-		providerSubjectId: restore.providerSubjectId
-	};
-}
-function activeAuthorizationMatchesEd25519Lane(input) {
-	const { authorization } = input;
-	if (String(authorization.session.walletId) !== input.walletId || authorization.selectedAuthMethod.kind !== input.auth.kind || authorization.operationCredential.walletSessionId.length === 0 || authorization.session.quotaId.length === 0 || !nearEd25519SessionMatchesMaterialActivation({
-		session: authorization.session,
-		materialActivation: input.materialActivation
-	})) return false;
-	if (input.auth.kind === "passkey") {
-		if (authorization.selectedAuthMethod.kind !== "passkey" || String(authorization.selectedAuthMethod.rpId) !== String(input.auth.rpId) || authorization.selectedAuthMethod.credentialIdB64u !== input.auth.credentialIdB64u) return false;
-	} else if (authorization.selectedAuthMethod.kind !== "email_otp" || authorization.selectedFactorAuthority.factor.kind !== "email_otp" || authorization.selectedFactorAuthority.factor.providerUserId !== input.auth.providerSubjectId) return false;
-	return Boolean(input.ownerScope && signingLaneAuthBindingKey(input.auth) === signingLaneAuthBindingKey(input.ownerScope.auth));
-}
-function recordToEd25519Lane(record, activeAuthorization, ownerScope) {
-	if (record.curve !== "ed25519") return null;
-	const thresholdSessionId = String(record.thresholdSessionIds.ed25519 || "").trim();
-	const walletId = String(record.walletId || "").trim();
-	const restore = record.ed25519Restore;
-	const signerSlot = parseSignerSlot(restore.signerSlot);
-	const auth = durableEd25519AuthBinding(record);
-	if (!thresholdSessionId || !walletId || signerSlot === null || !auth) return null;
-	const expiresAtMs = Math.floor(Number(record.expiresAtMs) || 0);
-	const remainingUses = Math.max(0, Math.floor(Number(record.remainingUses) || 0));
-	const state = expiresAtMs > 0 && expiresAtMs <= Date.now() ? "expired" : remainingUses === 0 ? "exhausted" : "restorable";
-	const authorization = activeAuthorization && activeAuthorizationMatchesEd25519Lane({
-		authorization: activeAuthorization,
-		auth,
-		walletId,
-		materialActivation: restore.materialActivation,
-		ownerScope
-	}) ? activeAuthorization : null;
-	try {
-		const base = {
-			auth,
-			curve: "ed25519",
-			chain: "near",
-			materialActivation: restore.materialActivation,
-			walletId: toWalletId(walletId),
-			nearAccountId: toAccountId(restore.nearAccountId),
-			nearEd25519SigningKeyId: nearEd25519SigningKeyIdFromString(restore.nearEd25519SigningKeyId),
-			signerSlot,
-			source: "durable_sealed_record",
-			thresholdSessionId,
-			remainingUses,
-			...expiresAtMs > 0 ? { expiresAtMs } : {},
-			updatedAtMs: Math.floor(Number(record.updatedAtMs) || 0),
-			...durablePolicyHint(record) ? { policyHint: durablePolicyHint(record) } : {}
-		};
-		return authorization ? {
-			...base,
-			state,
-			authorizationState: "authorized",
-			authorization
-		} : {
-			...base,
-			state: "deferred",
-			authorizationState: "authorization_required"
-		};
-	} catch {
-		return null;
-	}
-}
-function isEmailOtpPublicCapabilityLaneReference(reference) {
-	return reference.auth.kind === "email_otp";
-}
-function publicCapabilityReferenceToEd25519Lane(reference, activeAuthorization, ownerScope) {
-	const walletId = String(reference.walletId || "").trim();
-	const nearAccountId = String(reference.nearAccountId || "").trim();
-	const thresholdSessionId = String(reference.thresholdSessionId || "").trim();
-	if (!walletId || !nearAccountId || !thresholdSessionId) return null;
-	const authorization = activeAuthorization && activeAuthorizationMatchesEd25519Lane({
-		authorization: activeAuthorization,
-		auth: reference.auth,
-		walletId,
-		materialActivation: reference.materialActivation,
-		ownerScope
-	}) ? activeAuthorization : null;
-	try {
-		const base = {
-			auth: reference.auth,
-			curve: "ed25519",
-			chain: "near",
-			materialActivation: reference.materialActivation,
-			walletId: toWalletId(walletId),
-			nearAccountId: toAccountId(nearAccountId),
-			nearEd25519SigningKeyId: reference.nearEd25519SigningKeyId,
-			signerSlot: reference.signerSlot,
-			thresholdSessionId,
-			source: "public_capability_reference"
-		};
-		if (!authorization) return {
-			...base,
-			state: "deferred",
-			authorizationState: "authorization_required"
-		};
-		const authorizationExpiresAtMs = Math.floor(Number(authorization.status.expiresAtMs) || 0);
-		const emailOtpReference = isEmailOtpPublicCapabilityLaneReference(reference) ? reference : null;
-		const expiresAtMs = emailOtpReference ? Math.min(emailOtpReference.expiresAtMs, authorizationExpiresAtMs) : authorizationExpiresAtMs;
-		const state = expiresAtMs > 0 && expiresAtMs <= Date.now() ? "expired" : "ready";
-		return {
-			...base,
-			state,
-			authorizationState: "authorized",
-			authorization,
-			remainingUses: authorization.status.remainingUses,
-			...expiresAtMs > 0 ? { expiresAtMs } : {}
-		};
-	} catch {
-		return null;
-	}
-}
-function isConcreteAvailableSigningLane(lane) {
-	if (lane.state === "missing") return false;
-	if (lane.curve !== "ecdsa") {
-		const thresholdSessionId = String(lane.thresholdSessionId || "").trim();
-		if (lane.thresholdSessionId !== thresholdSessionId) return false;
-		if (!thresholdSessionId) return false;
-		if (lane.authorizationState === "authorization_required") return lane.state === "deferred";
-		if (!lane.authorization.operationCredential.walletSessionId || !lane.authorization.session.quotaId || lane.authorization.status.remainingUses <= 0 || lane.authorization.status.expiresAtMs <= Date.now()) return false;
-		return lane.auth.kind === "email_otp" || lane.auth.kind === "passkey";
-	}
-	if (lane.auth.kind !== "email_otp" && lane.auth.kind !== "passkey") return false;
-	if (lane.source === "active_wallet_authority") {
-		if (lane.state !== "deferred" || lane.authorizationState !== "authorization_required" || lane.runtime.kind !== "active_wallet_authority_ecdsa_runtime_v1" || String(lane.runtime.walletId) !== String(lane.key.walletId) || !mpcMaterialActivationRefsEqual(lane.runtime.materialActivation, lane.materialActivation) || lane.runtime.publicFacts !== lane.publicFacts) return false;
-	}
-	if (!Boolean(lane.key && String(lane.key.walletId || "").trim() && String(lane.key.ecdsaThresholdKeyId || "").trim() && String(lane.key.signingRootId || "").trim() && String(lane.key.signingRootVersion || "").trim() && Array.isArray(lane.key.participantIds) && lane.key.participantIds.length > 0 && String(lane.key.thresholdOwnerAddress || "").trim() && Boolean("publicFacts" in lane && lane.publicFacts && lane.publicFacts.keyHandle && String(lane.publicFacts.publicKeyB64u || "").trim() && Array.isArray(lane.publicFacts.participantIds) && lane.publicFacts.participantIds.length > 0 && String(lane.publicFacts.thresholdOwnerAddress || "").trim()))) return false;
-	if (lane.source === "canonical_capability" && !ecdsaAuthorizationPolicyMatchesLane(lane)) return false;
-	if (signingLaneAuthMethod(lane.auth) === "passkey") return lane.resolvedKey?.kind === "resolved_evm_family_ecdsa_key" && lane.resolvedKey.authBinding.kind === "passkey_ecdsa_auth_binding" && String(lane.resolvedKey.walletId) === String(lane.key.walletId) && lane.resolvedKey.publicFacts === lane.publicFacts;
-	return !("resolvedKey" in lane);
-}
-function laneCandidateStateFromAvailableLaneState(state) {
-	return state === "missing" ? null : state;
-}
-function laneCandidateSourceFromAvailableLaneSource(source) {
-	return source || "unknown";
-}
-function nullablePositiveInteger(value) {
-	const normalized = Math.floor(Number(value));
-	return Number.isFinite(normalized) && normalized > 0 ? normalized : null;
-}
-function nullableNonNegativeInteger(value) {
-	const normalized = Math.max(0, Math.floor(Number(value)));
-	return Number.isFinite(normalized) ? normalized : null;
-}
-function ed25519LaneCandidateFromAvailableLane(args) {
-	if (!isConcreteAvailableSigningLane(args.lane) || args.lane.curve !== "ed25519") return null;
-	const state = laneCandidateStateFromAvailableLaneState(args.lane.state);
-	if (!state) return null;
-	const base = {
-		kind: "lane_candidate",
-		walletId: args.lane.walletId,
-		nearAccountId: args.lane.nearAccountId,
-		nearEd25519SigningKeyId: args.lane.nearEd25519SigningKeyId,
-		signerSlot: args.lane.signerSlot,
-		materialActivation: args.lane.materialActivation,
-		auth: args.lane.auth,
-		curve: "ed25519",
-		chain: "near",
-		thresholdSessionId: args.lane.thresholdSessionId,
-		state,
-		remainingUses: nullableNonNegativeInteger(args.lane.remainingUses),
-		expiresAtMs: nullablePositiveInteger(args.lane.expiresAtMs),
-		updatedAtMs: nullablePositiveInteger(args.lane.updatedAtMs),
-		source: laneCandidateSourceFromAvailableLaneSource(args.lane.source)
-	};
-	if (args.lane.authorizationState === "authorization_required") return {
-		...base,
-		authorizationState: "authorization_required",
-		state: "deferred"
-	};
-	return {
-		...base,
-		authorizationState: "authorized",
-		authorization: args.lane.authorization
-	};
-}
-function ecdsaLaneCandidateFromAvailableLane(args) {
-	if (!isConcreteAvailableSigningLane(args.lane) || args.lane.curve !== "ecdsa") return null;
-	const state = laneCandidateStateFromAvailableLaneState(args.lane.state);
-	if (!state) return null;
-	const authMethod = signingLaneAuthMethod(args.lane.auth);
-	const base = {
-		kind: "lane_candidate",
-		walletId: toWalletId(args.walletId),
-		auth: args.lane.auth,
-		authMethod,
-		curve: "ecdsa",
-		chain: args.lane.chainTarget.kind,
-		key: args.lane.key,
-		materialActivation: args.lane.materialActivation,
-		...authMethod === "passkey" ? { resolvedKey: args.lane.resolvedKey } : {},
-		keyHandle: args.lane.publicFacts.keyHandle,
-		chainTarget: args.lane.chainTarget
-	};
-	switch (args.lane.source) {
-		case "active_wallet_authority": return {
-			...base,
-			source: "active_wallet_authority",
-			runtime: args.lane.runtime,
-			authorizationState: "authorization_required",
-			state: "deferred"
-		};
-		case "canonical_capability":
-			if (!args.lane.authorization) return {
-				...base,
-				source: "canonical_capability",
-				authorizationState: "authorization_required",
-				state: "deferred"
-			};
-			return {
-				...base,
-				source: "canonical_capability",
-				authorizationState: "authorized",
-				authorization: args.lane.authorization,
-				state
-			};
-		default: return args.lane;
-	}
-}
-function ecdsaAvailableLaneIdentityKey(lane) {
-	if (!lane || lane.curve !== "ecdsa") return null;
-	if (!lane.chainTarget) return null;
-	if (!("key" in lane) || !lane.key) return null;
-	if (!("auth" in lane) || !lane.auth) return null;
-	const authMethod = signingLaneAuthMethod(lane.auth);
-	try {
-		const authKey = signingLaneAuthBindingKey(lane.auth);
-		return [
-			authMethod,
-			"ecdsa",
-			thresholdEcdsaChainTargetKey(lane.chainTarget),
-			authKey,
-			deriveAvailableEcdsaLaneFingerprint(lane),
-			materialActivationKey(lane.materialActivation)
-		].join(":");
-	} catch {
-		return null;
-	}
-}
-function deriveAvailableEcdsaLaneFingerprint(args) {
-	return deriveEvmFamilyKeyFingerprintFromPublicFacts({
-		walletId: args.key.walletId,
-		publicFacts: args.publicFacts
-	});
-}
-function ed25519AvailableLaneIdentityKey(lane) {
-	if (!lane || lane.curve !== "ed25519" || lane.chain !== "near") return null;
-	if (lane.state === "missing") return null;
-	if (!lane.auth) return null;
-	const authMethod = signingLaneAuthMethod(lane.auth);
-	const walletId = String(lane.walletId || "").trim();
-	const nearAccountId = String(lane.nearAccountId || "").trim();
-	const nearEd25519SigningKeyId = String(lane.nearEd25519SigningKeyId || "").trim();
-	const signerSlot = String(lane.signerSlot || "").trim();
-	const thresholdSessionId = String(lane.thresholdSessionId || "").trim();
-	const activationKey = lane.materialActivation ? materialActivationKey(lane.materialActivation) : "";
-	if (!authMethod || !walletId || !nearAccountId || !nearEd25519SigningKeyId || !signerSlot || !thresholdSessionId || !activationKey) return null;
-	return [
-		walletId,
-		nearAccountId,
-		nearEd25519SigningKeyId,
-		signerSlot,
-		authMethod,
-		"ed25519",
-		"near",
-		thresholdSessionId,
-		activationKey
-	].join(":");
-}
-function emptyEcdsaLane(args) {
-	return {
-		curve: "ecdsa",
-		chainTarget: args.chainTarget,
-		state: "missing"
-	};
-}
-function ecdsaAvailableLaneForTarget(availableLanes, chainTarget) {
-	const targetKey = thresholdEcdsaChainTargetKey(chainTarget);
-	return availableLanes.ecdsa.lanesByTarget[targetKey] || emptyEcdsaLane({ chainTarget });
-}
-function ecdsaAvailableLaneCandidatesForTarget(availableLanes, chainTarget) {
-	const targetKey = thresholdEcdsaChainTargetKey(chainTarget);
-	return availableLanes.ecdsa.candidatesByTarget[targetKey] || [];
-}
-function emptyEd25519Lane() {
-	return {
-		curve: "ed25519",
-		chain: "near",
-		state: "missing"
-	};
-}
-function durablePolicyHint(record) {
-	const remainingUses = Math.floor(Number(record.remainingUses));
-	const expiresAtMs = Math.floor(Number(record.expiresAtMs));
-	const hint = {};
-	if (Number.isFinite(remainingUses) && remainingUses >= 0) hint.remainingUses = remainingUses;
-	if (Number.isFinite(expiresAtMs) && expiresAtMs > 0) hint.expiresAtMs = expiresAtMs;
-	return Object.keys(hint).length ? hint : void 0;
-}
-function availableLaneUpdatedAtMs(lane) {
-	return Math.floor(Number("updatedAtMs" in lane ? lane.updatedAtMs : 0) || 0);
-}
-function availableLaneServerIssuedGeneration(lane) {
-	return serverIssuedGenerationFromNumber(lane.expiresAtMs ?? lane.policyHint?.expiresAtMs);
-}
-function availableLaneStatePriority(lane) {
-	switch (lane.state) {
-		case "ready": return 5;
-		case "restorable": return 4;
-		case "deferred": return 3;
-		case "expired":
-		case "exhausted": return 2;
-		case "missing": return 1;
-	}
-}
-function availableLaneSourcePriority(lane) {
-	if (!isConcreteAvailableSigningLane(lane)) return 0;
-	if (lane.curve === "ecdsa") return 0;
-	return lane.source === "durable_sealed_record" ? 1 : 0;
-}
-function compareAvailableLanePriority(left, right) {
-	const stateDelta = availableLaneStatePriority(left) - availableLaneStatePriority(right);
-	if (stateDelta) return stateDelta;
-	const sourceDelta = availableLaneSourcePriority(left) - availableLaneSourcePriority(right);
-	if (sourceDelta) return sourceDelta;
-	return availableLaneUpdatedAtMs(left) - availableLaneUpdatedAtMs(right);
-}
-function compareEd25519AvailableLanePriority(left, right) {
-	return compareAvailableLanePriority(left, right);
-}
-function compareEd25519DuplicateLanePriority(left, right) {
-	const stateDelta = availableLaneStatePriority(left) - availableLaneStatePriority(right);
-	if (stateDelta) return stateDelta;
-	const sourceDelta = availableLaneSourcePriority(left) - availableLaneSourcePriority(right);
-	if (sourceDelta) return sourceDelta;
-	return availableLaneUpdatedAtMs(left) - availableLaneUpdatedAtMs(right);
-}
-function ed25519LaneGroupKey(lane) {
-	const authKey = signingLaneAuthBindingKey(lane.auth);
-	const walletId = String(lane.walletId || "").trim();
-	const nearAccountId = String(lane.nearAccountId || "").trim();
-	const nearEd25519SigningKeyId = String(lane.nearEd25519SigningKeyId || "").trim();
-	const signerSlot = String(lane.signerSlot || "").trim();
-	const materialActivationKeyValue = materialActivationKey(lane.materialActivation);
-	if (!authKey || !walletId || !nearAccountId || !nearEd25519SigningKeyId || !signerSlot || !materialActivationKeyValue) return null;
-	return {
-		walletId,
-		authKey,
-		nearAccountId,
-		nearEd25519SigningKeyId,
-		signerSlot,
-		materialActivationKey: materialActivationKeyValue
-	};
-}
-function ed25519LaneGroupKeyString(key) {
-	return [
-		key.walletId,
-		key.authKey,
-		key.nearAccountId,
-		key.nearEd25519SigningKeyId,
-		key.signerSlot,
-		key.materialActivationKey
-	].map((part) => encodeURIComponent(part)).join("|");
-}
-function ed25519LaneRecordFact(lane) {
-	if (!isConcreteAvailableSigningLane(lane) || lane.curve !== "ed25519") return null;
-	const groupKey = ed25519LaneGroupKey(lane);
-	if (!groupKey) return null;
-	return {
-		groupKey,
-		lane
-	};
-}
-function compareEd25519AvailableLanePriorityDescending(left, right) {
-	return compareEd25519AvailableLanePriority(right, left);
-}
-function canonicalTieBreakFromNumber(left, right) {
-	if (left > right) return 1;
-	if (right > left) return -1;
-	return 0;
-}
-function canonicalTieBreakFromString(left, right) {
-	const comparison = left.localeCompare(right);
-	if (comparison > 0) return 1;
-	if (comparison < 0) return -1;
-	return 0;
-}
-function firstCanonicalTieBreakResult(results) {
-	for (const result of results) if (result !== 0) return result;
-	return 0;
-}
-function ed25519LaneGroupConflicts(_facts) {
-	return [];
-}
-function isEd25519CanonicalFactOperationUsable(_fact) {
-	return true;
-}
-function ed25519CanonicalFactGeneration(fact) {
-	return availableLaneServerIssuedGeneration(fact.lane);
-}
-function ed25519CanonicalFactExactness() {
-	return "exact_target";
-}
-function ed25519CanonicalTieBreak(left, right) {
-	return firstCanonicalTieBreakResult([
-		canonicalTieBreakFromNumber(availableLaneStatePriority(left.lane), availableLaneStatePriority(right.lane)),
-		canonicalTieBreakFromNumber(availableLaneSourcePriority(left.lane), availableLaneSourcePriority(right.lane)),
-		canonicalTieBreakFromString(ed25519CanonicalStableTieBreakKey(left.lane), ed25519CanonicalStableTieBreakKey(right.lane))
-	]);
-}
-function ed25519CanonicalStableTieBreakKey(lane) {
-	return [
-		lane.thresholdSessionId,
-		lane.authorizationState === "authorized" ? lane.authorization.operationCredential.walletSessionId : "",
-		lane.authorizationState === "authorized" ? lane.authorization.session.quotaId : "",
-		lane.source || "durable_sealed_record"
-	].map((part) => String(part)).join("|");
-}
-const ed25519CanonicalLaneInventoryAdapter = {
-	groupKey: ed25519RecordFactGroupKey,
-	groupKeyString: ed25519LaneGroupKeyString,
-	groupConflicts: ed25519LaneGroupConflicts,
-	supersession: {
-		isOperationUsable: isEd25519CanonicalFactOperationUsable,
-		generation: ed25519CanonicalFactGeneration,
-		exactness: ed25519CanonicalFactExactness,
-		tieBreak: ed25519CanonicalTieBreak
-	}
-};
-function ed25519RecordFactGroupKey(fact) {
-	return fact.groupKey;
-}
-function ed25519FactsByGroup(facts) {
-	const groups = /* @__PURE__ */ new Map();
-	for (const fact of facts) {
-		const groupKey = ed25519LaneGroupKeyString(fact.groupKey);
-		groups.set(groupKey, [...groups.get(groupKey) || [], fact]);
-	}
-	return groups;
-}
-function canonicalizeEd25519FactGroup(facts, invalidLanes) {
-	const selection = canonicalizeLaneFacts(facts, ed25519CanonicalLaneInventoryAdapter);
-	switch (selection.kind) {
-		case "selected": return [selection.selectedFact.lane];
-		case "no_current_lane": return [];
-		case "conflicting_key_material":
-			invalidLanes.push({
-				curve: "ed25519",
-				source: "canonical_lane_inventory",
-				reason: "conflicting_key_material",
-				message: "Ed25519 canonical lane inventory has conflicting material facts"
-			});
-			return [];
-		case "ambiguous_material":
-			invalidLanes.push({
-				curve: "ed25519",
-				source: "canonical_lane_inventory",
-				reason: "ambiguous_material",
-				message: "Ed25519 canonical lane inventory has incomparable usable records"
-			});
-			return [];
-		default: return selection;
-	}
-}
-function canonicalizeEd25519AvailableLanes(candidates, invalidLanes) {
-	const facts = candidates.map(ed25519LaneRecordFact).filter((fact) => fact !== null);
-	const canonicalLanes = [];
-	for (const factGroup of ed25519FactsByGroup(facts).values()) canonicalLanes.push(...canonicalizeEd25519FactGroup(factGroup, invalidLanes));
-	return canonicalLanes.sort(compareEd25519AvailableLanePriorityDescending);
-}
-function ed25519CompanionIdentityKey(lane) {
-	if (!isConcreteAvailableSigningLane(lane) || lane.curve !== "ed25519") return null;
-	const thresholdSessionId = String(lane.thresholdSessionId || "").trim();
-	if (lane.authorizationState !== "authorized" || !thresholdSessionId) return null;
-	return `${lane.authorization.operationCredential.walletSessionId}:${lane.authorization.session.quotaId}:${thresholdSessionId}`;
-}
-function emailOtpPreferredEd25519PrimaryLane(args) {
-	if (!isConcreteAvailableSigningLane(args.primaryLane) || args.primaryLane.curve !== "ed25519" || availableEd25519SigningLaneAuthMethod(args.primaryLane) !== "passkey") return args.primaryLane;
-	const primaryKey = ed25519CompanionIdentityKey(args.primaryLane);
-	if (!primaryKey) return args.primaryLane;
-	return args.candidates.find((candidate) => isConcreteAvailableSigningLane(candidate) && candidate.curve === "ed25519" && availableEd25519SigningLaneAuthMethod(candidate) === "email_otp" && ed25519CompanionIdentityKey(candidate) === primaryKey) || args.primaryLane;
-}
-function isAvailableSigningLaneDiagnosticsEnabled() {
-	try {
-		return globalThis.localStorage?.getItem("seams:debug:signing-session") === "1";
-	} catch {
-		return false;
-	}
-}
-function summarizeEcdsaLaneForDiagnostics(lane) {
-	if (!lane) return { present: false };
-	if (!isConcreteAvailableSigningLane(lane)) return {
-		present: true,
-		curve: lane.curve,
-		chainTarget: lane.chainTarget,
-		state: lane.state
-	};
-	return {
-		present: true,
-		authMethod: signingLaneAuthMethod(lane.auth),
-		curve: lane.curve,
-		keyHandle: lane.publicFacts.keyHandle,
-		walletId: lane.key.walletId,
-		chainTarget: lane.chainTarget,
-		targetKey: thresholdEcdsaChainTargetKey(lane.chainTarget),
-		state: lane.state,
-		source: lane.source,
-		evmFamilyKeyFingerprint: deriveAvailableEcdsaLaneFingerprint(lane),
-		ecdsaThresholdKeyId: lane.key.ecdsaThresholdKeyId,
-		participantIds: lane.publicFacts.participantIds,
-		thresholdOwnerAddress: lane.publicFacts.thresholdOwnerAddress,
-		remainingUses: lane.remainingUses,
-		expiresAtMs: lane.expiresAtMs,
-		updatedAtMs: lane.updatedAtMs
-	};
-}
-function ecdsaLaneRecordFactSource(lane) {
-	switch (lane.source) {
-		case "canonical_capability": return "canonical_capability";
-		case "active_wallet_authority": return "active_wallet_authority";
-		default: return lane;
-	}
-}
-function ecdsaLaneGroupKey(lane) {
-	const authKey = signingLaneAuthBindingKey(lane.auth);
-	return {
-		walletId: String(lane.key.walletId),
-		authKey,
-		materialActivationKey: materialActivationKey(lane.materialActivation),
-		ecdsaThresholdKeyId: String(lane.key.ecdsaThresholdKeyId),
-		signingRootId: String(lane.key.signingRootId),
-		signingRootVersion: String(lane.key.signingRootVersion || "default")
-	};
-}
-function ecdsaLaneGroupKeyString(key) {
-	return [
-		key.walletId,
-		key.authKey,
-		key.materialActivationKey,
-		key.ecdsaThresholdKeyId,
-		key.signingRootId,
-		key.signingRootVersion
-	].map((part) => encodeURIComponent(part)).join("|");
-}
-function ecdsaLaneRecordFact(lane) {
-	const groupKey = ecdsaLaneGroupKey(lane);
-	if (!groupKey) return null;
-	return {
-		source: ecdsaLaneRecordFactSource(lane),
-		groupKey,
-		chainTargetKey: thresholdEcdsaChainTargetKey(lane.chainTarget),
-		lane
-	};
-}
-function ecdsaLaneFamilyGroupKeyString(lane) {
-	const authKey = signingLaneAuthBindingKey(lane.auth);
-	return [
-		String(lane.key.walletId),
-		authKey,
-		materialActivationKey(lane.materialActivation),
-		String(lane.key.signingRootId),
-		String(lane.key.signingRootVersion || "default")
-	].map((part) => encodeURIComponent(part)).join("|");
-}
-function ecdsaCanonicalPublicFactValues(facts, read) {
-	return [...new Set(facts.map((fact) => read(fact.lane)).filter(Boolean))].sort();
-}
-function ecdsaLaneGroupConflicts(group) {
-	return [
-		{
-			field: "ecdsaThresholdKeyId",
-			values: ecdsaCanonicalPublicFactValues(group.facts, (lane) => String(lane.key.ecdsaThresholdKeyId || ""))
-		},
-		{
-			field: "thresholdOwnerAddress",
-			values: ecdsaCanonicalPublicFactValues(group.facts, (lane) => String(lane.publicFacts.thresholdOwnerAddress || "").toLowerCase())
-		},
-		{
-			field: "keyHandle",
-			values: ecdsaCanonicalPublicFactValues(group.facts, (lane) => String(lane.publicFacts.keyHandle || ""))
-		},
-		{
-			field: "publicKeyB64u",
-			values: ecdsaCanonicalPublicFactValues(group.facts, (lane) => String(lane.publicFacts.publicKeyB64u || ""))
-		},
-		{
-			field: "participantIds",
-			values: ecdsaCanonicalPublicFactValues(group.facts, (lane) => lane.publicFacts.participantIds.map((participantId) => Number(participantId)).join(","))
-		}
-	].filter((entry) => entry.values.length > 1).map((entry) => ({
-		groupKey: group.key,
-		field: entry.field,
-		values: entry.values
-	}));
-}
-function ecdsaFamilyGroupConflicts(facts) {
-	const factsByFamilyGroup = /* @__PURE__ */ new Map();
-	for (const fact of facts) {
-		const familyGroupKey = ecdsaLaneFamilyGroupKeyString(fact.lane);
-		if (!familyGroupKey) continue;
-		factsByFamilyGroup.set(familyGroupKey, [...factsByFamilyGroup.get(familyGroupKey) || [], fact]);
-	}
-	const conflictsByFamilyGroup = /* @__PURE__ */ new Map();
-	for (const [familyGroupKey, groupFacts] of factsByFamilyGroup) {
-		const firstFact = groupFacts[0];
-		if (!firstFact) continue;
-		const conflicts = ecdsaLaneGroupConflicts({
-			key: firstFact.groupKey,
-			facts: groupFacts
-		});
-		if (conflicts.length) conflictsByFamilyGroup.set(familyGroupKey, conflicts);
-	}
-	return conflictsByFamilyGroup;
-}
-function ecdsaFactFamilyConflicts(args) {
-	const familyGroupKey = ecdsaLaneFamilyGroupKeyString(args.fact.lane);
-	if (!familyGroupKey) return [];
-	return args.conflictsByFamilyGroup.get(familyGroupKey) || [];
-}
-function ecdsaRecordFactsForCandidates(candidates) {
-	return candidates.filter((candidate) => isConcreteAvailableSigningLane(candidate) && candidate.curve === "ecdsa").map(ecdsaLaneRecordFact).filter((fact) => fact !== null);
-}
-function ecdsaCanonicalSourcePriority(_lane) {
-	return _lane.source === "active_wallet_authority" ? 2 : 1;
-}
-function ecdsaCanonicalFactGroupKey(fact) {
-	return fact.groupKey;
-}
-function ecdsaCanonicalGroupConflicts(facts) {
-	const firstFact = facts[0];
-	if (!firstFact) return [];
-	return ecdsaLaneGroupConflicts({
-		key: firstFact.groupKey,
-		facts
-	});
-}
-function isEcdsaCanonicalFactOperationUsable(fact) {
-	if (fact.lane.source === "active_wallet_authority") return true;
-	return fact.lane.state !== "deferred" || !fact.lane.authorization;
-}
-function ecdsaCanonicalFactGeneration(fact) {
-	return availableLaneServerIssuedGeneration(fact.lane);
-}
-function ecdsaCanonicalFactExactness(_fact) {
-	return "exact_target";
-}
-function ecdsaCanonicalStableTieBreakKey(lane) {
-	return [
-		materialActivationKey(lane.materialActivation),
-		lane.source,
-		thresholdEcdsaChainTargetKey(lane.chainTarget)
-	].map((part) => String(part)).join("|");
-}
-function ecdsaCanonicalTieBreak(left, right) {
-	return firstCanonicalTieBreakResult([
-		canonicalTieBreakFromNumber(availableLaneStatePriority(left.lane), availableLaneStatePriority(right.lane)),
-		canonicalTieBreakFromNumber(ecdsaCanonicalSourcePriority(left.lane), ecdsaCanonicalSourcePriority(right.lane)),
-		canonicalTieBreakFromString(ecdsaCanonicalStableTieBreakKey(left.lane), ecdsaCanonicalStableTieBreakKey(right.lane))
-	]);
-}
-const ecdsaCanonicalLaneInventoryAdapter = {
-	groupKey: ecdsaCanonicalFactGroupKey,
-	groupKeyString: ecdsaLaneGroupKeyString,
-	groupConflicts: ecdsaCanonicalGroupConflicts,
-	supersession: {
-		isOperationUsable: isEcdsaCanonicalFactOperationUsable,
-		generation: ecdsaCanonicalFactGeneration,
-		exactness: ecdsaCanonicalFactExactness,
-		tieBreak: ecdsaCanonicalTieBreak
-	}
-};
-function ecdsaGroupKeysForFacts(facts) {
-	const groupKeysByEncodedKey = /* @__PURE__ */ new Map();
-	for (const fact of facts) groupKeysByEncodedKey.set(ecdsaLaneGroupKeyString(fact.groupKey), fact.groupKey);
-	return [...groupKeysByEncodedKey.values()];
-}
-function canonicalEcdsaLaneSelectionForFacts(facts) {
-	const selection = canonicalizeLaneFacts(facts, ecdsaCanonicalLaneInventoryAdapter);
-	switch (selection.kind) {
-		case "selected": return {
-			kind: "selected",
-			selectedFact: selection.selectedFact,
-			supersededFacts: selection.supersededFacts
-		};
-		case "no_current_lane": return {
-			kind: "no_current_lane",
-			unusableFacts: selection.unusableFacts
-		};
-		case "conflicting_key_material": return {
-			kind: "conflicting_key_material",
-			conflicts: selection.conflicts
-		};
-		case "ambiguous_material": return {
-			kind: "ambiguous_material",
-			candidates: ecdsaGroupKeysForFacts(selection.candidates),
-			candidateFacts: selection.candidates
-		};
-		default: return selection;
-	}
-}
-/**
-* An added auth method holds its own access projection over the wallet's
-* existing activation, so the same lane is reachable through two credentials.
-* For a wallet-level read that names no method, those are one lane, not two
-* competing ones - and they are indistinguishable to the canonical tie-break,
-* which keys on material identity precisely because siblings share it. Left
-* uncollapsed they cancel out as ambiguous and the wallet reports no lane at
-* all. A read that does name a method never sees more than one of them.
-*/
-function ecdsaMaterialIdentityKey(lane) {
-	if (!isConcreteAvailableSigningLane(lane)) return null;
-	return ecdsaCanonicalStableTieBreakKey(lane);
-}
-function canonicalizeEcdsaAvailableLanes(args) {
-	const canonicalCandidatesByTarget = {};
-	const canonicalLanesByTarget = {};
-	const candidatesByTarget = Object.fromEntries(Object.entries(args.candidatesByTarget).map(([targetKey, candidates]) => [targetKey, collapseExactDuplicateAvailableLanes(candidates, ecdsaMaterialIdentityKey)]));
-	const conflictsByFamilyGroup = ecdsaFamilyGroupConflicts(Object.values(candidatesByTarget).flatMap(ecdsaRecordFactsForCandidates));
-	for (const chainTarget of args.targets) {
-		const targetKey = thresholdEcdsaChainTargetKey(chainTarget);
-		const concreteFacts = ecdsaRecordFactsForCandidates(candidatesByTarget[targetKey] || []);
-		const targetConflicts = concreteFacts.flatMap((fact) => ecdsaFactFamilyConflicts({
-			fact,
-			conflictsByFamilyGroup
-		}));
-		if (targetConflicts.length) {
-			args.invalidLanes.push({
-				curve: "ecdsa",
-				source: "canonical_lane_inventory",
-				reason: "conflicting_key_material",
-				targetKey,
-				groupKey: targetConflicts[0]?.groupKey,
-				conflicts: targetConflicts
-			});
-			canonicalCandidatesByTarget[targetKey] = [];
-			canonicalLanesByTarget[targetKey] = emptyEcdsaLane({ chainTarget });
-			continue;
-		}
-		const selection = canonicalEcdsaLaneSelectionForFacts(concreteFacts);
-		switch (selection.kind) {
-			case "selected":
-				canonicalCandidatesByTarget[targetKey] = [selection.selectedFact.lane];
-				canonicalLanesByTarget[targetKey] = selection.selectedFact.lane;
-				break;
-			case "no_current_lane":
-				canonicalCandidatesByTarget[targetKey] = [];
-				canonicalLanesByTarget[targetKey] = emptyEcdsaLane({ chainTarget });
-				break;
-			case "conflicting_key_material":
-				args.invalidLanes.push({
-					curve: "ecdsa",
-					source: "canonical_lane_inventory",
-					reason: "conflicting_key_material",
-					targetKey,
-					groupKey: selection.conflicts[0]?.groupKey,
-					conflicts: selection.conflicts
-				});
-				canonicalCandidatesByTarget[targetKey] = [];
-				canonicalLanesByTarget[targetKey] = emptyEcdsaLane({ chainTarget });
-				break;
-			case "ambiguous_material":
-				args.invalidLanes.push({
-					curve: "ecdsa",
-					source: "canonical_lane_inventory",
-					reason: "ambiguous_material",
-					targetKey
-				});
-				canonicalCandidatesByTarget[targetKey] = [];
-				canonicalLanesByTarget[targetKey] = emptyEcdsaLane({ chainTarget });
-				break;
-		}
-	}
-	return {
-		lanesByTarget: canonicalLanesByTarget,
-		candidatesByTarget: canonicalCandidatesByTarget
-	};
-}
-function collapseExactDuplicateAvailableLanes(lanes, laneIdentityKey, comparePriority = compareAvailableLanePriority) {
-	const keyedGroups = /* @__PURE__ */ new Map();
-	const unkeyed = [];
-	for (const lane of lanes) {
-		const key = laneIdentityKey(lane);
-		if (!key) {
-			unkeyed.push(lane);
-			continue;
-		}
-		keyedGroups.set(key, [...keyedGroups.get(key) || [], lane]);
-	}
-	return [...[...keyedGroups.values()].map((group) => [...group].sort((left, right) => comparePriority(right, left))[0]), ...unkeyed];
-}
-function suppressPublicEd25519CandidatesWithDurablePolicy(candidates) {
-	const durableGroupKeys = new Set(candidates.filter((lane) => isConcreteAvailableSigningLane(lane) && lane.curve === "ed25519" && lane.source === "durable_sealed_record" && (lane.state === "ready" || lane.state === "restorable")).map(ed25519LaneGroupKey).filter((key) => key !== null).map(ed25519LaneGroupKeyString));
-	if (!durableGroupKeys.size) return [...candidates];
-	return candidates.filter((lane) => {
-		if (!isConcreteAvailableSigningLane(lane) || lane.curve !== "ed25519" || lane.source !== "public_capability_reference") return true;
-		const groupKey = ed25519LaneGroupKey(lane);
-		return !groupKey || !durableGroupKeys.has(ed25519LaneGroupKeyString(groupKey));
-	});
-}
-/**
-* Owner-scope matching. Ed25519 lanes bind an owner's credential AND
-* signer slot; ECDSA lanes bind the credential alone. State stays untouched:
-* the scope decides whose lane it is, never whether it is usable.
-*/
-async function ed25519LaneMatchesOwnerScope(lane, scope) {
-	if (lane.state === "missing") return false;
-	if (signingLaneAuthBindingKey(lane.auth) !== signingLaneAuthBindingKey(scope.auth)) return false;
-	if (!await ownerAuthorityMatchesEd25519Lane(lane, scope)) return false;
-	if (scope.auth.kind === "email_otp") return true;
-	if ("keyFamily" in scope && scope.keyFamily === "ecdsa") return false;
-	return lane.signerSlot === scope.signerSlot;
-}
-function ecdsaLaneMatchesOwnerScope(lane, scope) {
-	if (lane.state === "missing") return false;
-	if (signingLaneAuthBindingKey(lane.auth) !== signingLaneAuthBindingKey(scope.auth)) return false;
-	return ownerAuthorityMatchesLane(lane, scope);
-}
-function ownerAuthorityMatchesLane(lane, scope) {
-	const ownerAuthority = scope.auth.kind === "email_otp" ? scope.ownerAuthority : void 0;
-	if (!ownerAuthority) return true;
-	if (lane.curve === "ecdsa" && lane.source === "active_wallet_authority") return lane.runtime.factorAuthorityRef.walletAuthMethodId === ownerAuthority.walletAuthMethodId && String(lane.runtime.factorAuthorityRef.authorityDigest) === String(ownerAuthority.authorityDigest);
-	if (lane.curve === "ecdsa" && lane.source === "canonical_capability") {
-		const authority = lane.capability.manifest.signer.authority;
-		return authority.walletAuthMethodId === ownerAuthority.walletAuthMethodId && String(authority.authorityDigest) === String(ownerAuthority.authorityDigest);
-	}
-	return false;
-}
-async function ownerAuthorityMatchesEd25519Lane(lane, scope) {
-	const ownerAuthority = scope.auth.kind === "email_otp" ? scope.ownerAuthority : void 0;
-	if (!ownerAuthority) return true;
-	if (lane.state === "missing" || lane.curve !== "ed25519") return false;
-	if (lane.authorizationState === "authorization_required") return true;
-	try {
-		const factorAuthorityRef = await walletAuthAuthorityRef({ authority: lane.authorization.selectedFactorAuthority });
-		return factorAuthorityRef.walletId === lane.walletId && factorAuthorityRef.walletAuthMethodId === ownerAuthority.walletAuthMethodId && factorAuthorityRef.authorityDigest === ownerAuthority.authorityDigest;
-	} catch {
-		return false;
-	}
-}
-async function filterEd25519LanesByOwnerScope(lanes, scope) {
-	const filtered = [];
-	for (const lane of lanes) if (await ed25519LaneMatchesOwnerScope(lane, scope)) filtered.push(lane);
-	return filtered;
-}
-async function readAvailableSigningLanes(input, ports) {
-	const walletId = toWalletId(input.walletId);
-	const ecdsaTargetsByKey = /* @__PURE__ */ new Map();
-	for (const chainTarget of input.ecdsaChainTargets) ecdsaTargetsByKey.set(thresholdEcdsaChainTargetKey(chainTarget), chainTarget);
-	const ecdsaChainTargets = [...ecdsaTargetsByKey.values()];
-	const [ed25519Records, publicCapabilityReferences, activeAuthorizationRead, canonicalEcdsaLanes] = await Promise.all([
-		ports.listSealedRecordsForWallet({
-			walletId,
-			filter: {
-				...input.authMethod ? { authMethod: input.authMethod } : {},
-				curve: "ed25519"
-			}
-		}),
-		ports.listPublicCapabilityReferences?.() ?? [],
-		ports.readActiveWalletSessionAuthorization?.(walletId) ?? { kind: "missing" },
-		ecdsaChainTargets.length > 0 && ports.listCanonicalEcdsaLanesForWallet ? ports.listCanonicalEcdsaLanesForWallet({ walletId }) : []
-	]);
-	const activeAuthorization = activeAuthorizationRead.kind === "found" ? activeAuthorizationRead.authorization : null;
-	const ecdsaTargets = [...ecdsaChainTargets];
-	const ecdsaLanesByTarget = {};
-	const ecdsaCandidatesByTarget = {};
-	const ecdsaLaneUpdatedAtMsByTarget = {};
-	for (const chainTarget of ecdsaTargets) {
-		const targetKey = thresholdEcdsaChainTargetKey(chainTarget);
-		ecdsaLanesByTarget[targetKey] = emptyEcdsaLane({ chainTarget });
-		ecdsaCandidatesByTarget[targetKey] = [];
-		ecdsaLaneUpdatedAtMsByTarget[targetKey] = 0;
-	}
-	const ed25519Candidates = [];
-	let generation = 0;
-	const collectDiagnostics = isAvailableSigningLaneDiagnosticsEnabled();
-	const runtimeEcdsaDiscovery = [];
-	const invalidLanes = [];
-	for (const record of ed25519Records) {
-		const lane = recordToEd25519Lane(record, activeAuthorization, input.ownerScope);
-		if (!lane) continue;
-		ed25519Candidates.push(lane);
-		const updatedAtMs = availableLaneUpdatedAtMs(lane);
-		generation = Math.max(generation, updatedAtMs);
-	}
-	for (const reference of publicCapabilityReferences) {
-		if (String(reference.walletId) !== String(walletId)) continue;
-		const requiresStepUp = activeAuthorizationRead.kind === "exhausted" || activeAuthorizationRead.kind === "expired";
-		if (!ports.isPublicCapabilityActive?.(reference) && !requiresStepUp) continue;
-		const lane = publicCapabilityReferenceToEd25519Lane(reference, activeAuthorization, input.ownerScope);
-		if (!lane) continue;
-		if (input.authMethod && signingLaneAuthMethod(lane.auth) !== input.authMethod) continue;
-		ed25519Candidates.push(lane);
-	}
-	for (const lane of canonicalEcdsaLanes) {
-		const authMethod = signingLaneAuthMethod(lane.auth);
-		if (input.authMethod && authMethod !== input.authMethod) continue;
-		if (String(lane.key.walletId) !== String(walletId)) continue;
-		const targetKey = thresholdEcdsaChainTargetKey(lane.chainTarget);
-		if (!ecdsaTargetsByKey.has(targetKey)) continue;
-		ecdsaCandidatesByTarget[targetKey] ||= [];
-		ecdsaCandidatesByTarget[targetKey].push(lane);
-		const updatedAtMs = availableLaneUpdatedAtMs(lane);
-		generation = Math.max(generation, updatedAtMs);
-		runtimeEcdsaDiscovery.push({
-			result: "accepted",
-			targetKey,
-			lane: summarizeEcdsaLaneForDiagnostics(lane)
-		});
-	}
-	const activeWalletAuthorityEcdsaLanes = ecdsaChainTargets.length > 0 && ports.listActiveWalletAuthorityEcdsaLanesForWallet ? await ports.listActiveWalletAuthorityEcdsaLanesForWallet({
-		walletId,
-		chainTargets: ecdsaChainTargets
-	}) : [];
-	for (const lane of activeWalletAuthorityEcdsaLanes) {
-		const authMethod = signingLaneAuthMethod(lane.auth);
-		if (input.authMethod && authMethod !== input.authMethod) continue;
-		if (String(lane.key.walletId) !== String(walletId)) continue;
-		const targetKey = thresholdEcdsaChainTargetKey(lane.chainTarget);
-		if (!ecdsaTargetsByKey.has(targetKey)) continue;
-		ecdsaCandidatesByTarget[targetKey] ||= [];
-		ecdsaCandidatesByTarget[targetKey].push(lane);
-		runtimeEcdsaDiscovery.push({
-			result: "accepted",
-			targetKey,
-			lane: summarizeEcdsaLaneForDiagnostics(lane)
-		});
-	}
-	const ownerScope = input.ownerScope;
-	const ownerScopedEd25519Candidates = ownerScope ? await filterEd25519LanesByOwnerScope(ed25519Candidates, ownerScope) : ed25519Candidates;
-	if (ownerScope) for (const targetKey of Object.keys(ecdsaCandidatesByTarget)) ecdsaCandidatesByTarget[targetKey] = (ecdsaCandidatesByTarget[targetKey] || []).filter((lane) => ecdsaLaneMatchesOwnerScope(lane, ownerScope));
-	const activeEd25519Candidates = canonicalizeEd25519AvailableLanes(collapseExactDuplicateAvailableLanes(suppressPublicEd25519CandidatesWithDurablePolicy(ownerScopedEd25519Candidates), ed25519AvailableLaneIdentityKey, compareEd25519DuplicateLanePriority).sort(compareEd25519AvailableLanePriorityDescending), invalidLanes);
-	const preferredEd25519Lane = emailOtpPreferredEd25519PrimaryLane({
-		primaryLane: activeEd25519Candidates[0] || emptyEd25519Lane(),
-		candidates: activeEd25519Candidates
-	});
-	const canonicalEcdsaAvailableLanes = canonicalizeEcdsaAvailableLanes({
-		targets: ecdsaTargets,
-		candidatesByTarget: canonicalizeEcdsaAvailableLanes({
-			targets: ecdsaTargets,
-			candidatesByTarget: ecdsaCandidatesByTarget,
-			invalidLanes
-		}).candidatesByTarget,
-		invalidLanes
-	});
-	const availableLanes = {
-		walletId,
-		generation,
-		ecdsa: {
-			targets: ecdsaTargets,
-			lanesByTarget: canonicalEcdsaAvailableLanes.lanesByTarget,
-			candidatesByTarget: canonicalEcdsaAvailableLanes.candidatesByTarget
-		},
-		lanes: { ed25519: { near: preferredEd25519Lane } },
-		candidates: { ed25519: { near: activeEd25519Candidates } },
-		diagnostics: { invalidLanes }
-	};
-	const missingEcdsaTargets = ecdsaTargets.map((target) => {
-		const targetKey = thresholdEcdsaChainTargetKey(target);
-		const candidates = availableLanes.ecdsa.candidatesByTarget[targetKey] || [];
-		const selectedLane = availableLanes.ecdsa.lanesByTarget[targetKey];
-		const selectedLaneState = selectedLane?.state || "missing";
-		if (candidates.length > 0 && selectedLaneState !== "missing") return null;
-		return {
-			chainTarget: target,
-			targetKey,
-			candidateCount: candidates.length,
-			selectedLane: summarizeEcdsaLaneForDiagnostics(selectedLane)
-		};
-	}).filter((entry) => Boolean(entry));
-	const laneDiagnosticPayload = {
-		walletId,
-		authMethod: input.authMethod || "any",
-		requestedTargets: ecdsaTargets.map((target) => ({
-			chainTarget: target,
-			targetKey: thresholdEcdsaChainTargetKey(target)
-		})),
-		sealedRecordCount: 0,
-		runtimeRecordCount: canonicalEcdsaLanes.length,
-		durableDiscovery: [],
-		runtimeDiscovery: runtimeEcdsaDiscovery,
-		resultSelectedLanesByTarget: Object.fromEntries(Object.entries(availableLanes.ecdsa.lanesByTarget).map(([targetKey, lane]) => [targetKey, summarizeEcdsaLaneForDiagnostics(lane)])),
-		resultCandidatesByTarget: Object.fromEntries(Object.entries(availableLanes.ecdsa.candidatesByTarget).map(([targetKey, lanes]) => [targetKey, lanes.map((lane) => summarizeEcdsaLaneForDiagnostics(lane))]))
-	};
-	if (collectDiagnostics && missingEcdsaTargets.length > 0) try {
-		console.warn("[SigningLanes][available][ecdsa][missing-candidates]", JSON.stringify({
-			...laneDiagnosticPayload,
-			missingEcdsaTargets
-		}));
-	} catch {}
-	if (collectDiagnostics) try {
-		console.info("[SigningLanes][available][ecdsa]", JSON.stringify(laneDiagnosticPayload));
-	} catch {}
-	return availableLanes;
-}
-//#endregion
-//#region src/core/signingEngine/session/identity/selectLane.ts
-function receiveTransactionIntent(intent) {
-	return {
-		tag: "IntentReceived",
-		intent
-	};
-}
-function recordAvailableSigningLanesRead(state, args) {
-	return {
-		tag: "AvailableLanesRead",
-		intent: state.intent,
-		availableLanes: args.availableLanes
-	};
-}
-function isConcreteNearEd25519Lane(lane) {
-	return Boolean(lane) && lane.curve === "ed25519" && lane.chain === "near" && isConcreteAvailableSigningLane(lane);
-}
-function isConcreteEvmFamilyEcdsaLane(lane) {
-	return Boolean(lane) && lane.curve === "ecdsa" && Boolean(lane.chainTarget) && isConcreteAvailableSigningLane(lane);
-}
-function toEd25519LaneAuthorityKey(lane) {
-	const key = ed25519AvailableLaneIdentityKey(lane);
-	return key ? key : null;
-}
-function nearEd25519TransactionReadyState(lane) {
-	if (lane.state === "ready") return "ready";
-	if (lane.state === "restorable") return "restorable";
-	return null;
-}
-function nearEd25519TransactionReauthState(lane) {
-	if (lane.state === "expired") return "expired";
-	if (lane.state === "exhausted") return "exhausted";
-	return null;
-}
-function nearEd25519TransactionReadyAvailableLaneProjection(lane) {
-	const state = nearEd25519TransactionReadyState(lane);
-	if (!state) throw new Error("[SigningSessionSelectLane] Ed25519 lane is not transaction-ready");
-	return {
-		auth: lane.auth,
-		curve: "ed25519",
-		chain: "near",
-		materialActivation: lane.materialActivation,
-		walletId: lane.walletId,
-		nearAccountId: lane.nearAccountId,
-		nearEd25519SigningKeyId: lane.nearEd25519SigningKeyId,
-		signerSlot: lane.signerSlot,
-		authorizationState: "authorized",
-		authorization: lane.authorization,
-		state,
-		thresholdSessionId: lane.thresholdSessionId,
-		...lane.remainingUses == null ? {} : { remainingUses: lane.remainingUses },
-		...lane.expiresAtMs == null ? {} : { expiresAtMs: lane.expiresAtMs },
-		...lane.policyHint ? { policyHint: lane.policyHint } : {},
-		...lane.updatedAtMs == null ? {} : { updatedAtMs: lane.updatedAtMs }
-	};
-}
-function nearEd25519TransactionReauthAvailableLaneProjection(lane) {
-	const state = nearEd25519TransactionReauthState(lane);
-	if (!state) throw new Error("[SigningSessionSelectLane] Ed25519 lane is not transaction-reauthable");
-	return {
-		auth: lane.auth,
-		curve: "ed25519",
-		chain: "near",
-		materialActivation: lane.materialActivation,
-		walletId: lane.walletId,
-		nearAccountId: lane.nearAccountId,
-		nearEd25519SigningKeyId: lane.nearEd25519SigningKeyId,
-		signerSlot: lane.signerSlot,
-		authorizationState: "authorized",
-		authorization: lane.authorization,
-		state,
-		thresholdSessionId: lane.thresholdSessionId,
-		...lane.remainingUses == null ? {} : { remainingUses: lane.remainingUses },
-		...lane.expiresAtMs == null ? {} : { expiresAtMs: lane.expiresAtMs },
-		...lane.policyHint ? { policyHint: lane.policyHint } : {},
-		...lane.updatedAtMs == null ? {} : { updatedAtMs: lane.updatedAtMs }
-	};
-}
-function selectedEd25519LaneForTransactionCandidate(candidate) {
-	return selectedEd25519Lane({
-		walletId: candidate.walletId,
-		nearAccountId: candidate.nearAccountId,
-		nearEd25519SigningKeyId: candidate.nearEd25519SigningKeyId,
-		signerSlot: candidate.signerSlot,
-		auth: candidate.auth,
-		walletSessionId: candidate.authorization.operationCredential.walletSessionId,
-		quotaId: candidate.authorization.session.quotaId,
-		thresholdSessionId: candidate.thresholdSessionId
-	});
-}
-function buildNearEd25519TransactionReadyLane(args) {
-	return {
-		kind: "near_ed25519_transaction_ready_lane",
-		candidate: args.candidate,
-		availableLane: nearEd25519TransactionReadyAvailableLaneProjection(args.lane),
-		selectedLane: selectedEd25519LaneForTransactionCandidate(args.candidate),
-		authorityKey: args.authorityKey
-	};
-}
-function buildNearEd25519TransactionReauthLane(args) {
-	return {
-		kind: "near_ed25519_transaction_reauth_lane",
-		candidate: args.candidate,
-		availableLane: nearEd25519TransactionReauthAvailableLaneProjection(args.lane),
-		selectedLane: selectedEd25519LaneForTransactionCandidate(args.candidate),
-		authorityKey: args.authorityKey
-	};
-}
-function toNearEd25519TransactionSelectableLane(lane) {
-	if (!isConcreteNearEd25519Lane(lane)) return null;
-	if (lane.authorizationState !== "authorized") return null;
-	const readyState = nearEd25519TransactionReadyState(lane);
-	const reauthState = nearEd25519TransactionReauthState(lane);
-	if (!readyState && !reauthState) return null;
-	const authorityKey = toEd25519LaneAuthorityKey(lane);
-	if (!authorityKey) return null;
-	const candidate = ed25519LaneCandidateFromAvailableLane({ lane });
-	if (!candidate || candidate.authorizationState !== "authorized") return null;
-	if (readyState) return buildNearEd25519TransactionReadyLane({
-		lane,
-		candidate,
-		authorityKey
-	});
-	return buildNearEd25519TransactionReauthLane({
-		lane,
-		candidate,
-		authorityKey
-	});
-}
-function selectedLaneFromCandidate(candidate) {
-	if (candidate.curve === "ed25519") {
-		if (candidate.authorizationState !== "authorized" || !candidate.authorization) throw new Error("[SigningSessionSelectLane] Ed25519 lane requires active authorization");
-		return selectedEd25519Lane({
-			walletId: candidate.walletId,
-			nearAccountId: candidate.nearAccountId,
-			nearEd25519SigningKeyId: candidate.nearEd25519SigningKeyId,
-			signerSlot: candidate.signerSlot,
-			auth: candidate.auth,
-			walletSessionId: candidate.authorization.operationCredential.walletSessionId,
-			quotaId: candidate.authorization.session.quotaId,
-			thresholdSessionId: candidate.thresholdSessionId
-		});
-	}
-	if (candidate.authorizationState !== "authorized") throw new Error("[SigningSessionSelectLane] ECDSA lane requires active authorization");
-	return selectedEcdsaLane({
-		key: candidate.key,
-		materialActivation: candidate.materialActivation,
-		keyHandle: candidate.keyHandle,
-		walletId: candidate.walletId,
-		auth: candidate.auth,
-		authorization: candidate.authorization,
-		chainTarget: candidate.chainTarget
-	});
-}
-function allowedAuthMethods(candidates) {
-	return [...new Set(candidates.map((candidate) => laneCandidateAuthMethod(candidate.candidate)))].sort();
-}
-function selectOnlyConcreteTransactionCandidate(candidates) {
-	switch (candidates.length) {
-		case 0: return null;
-		case 1: {
-			const [candidate] = candidates;
-			return candidate || null;
-		}
-		default: return null;
-	}
-}
-function selectTransactionLane(input) {
-	const intent = input.intent;
-	if (intent.curve === "ed25519" && intent.chain === "near") return selectSelectedEd25519Lane({
-		...input,
-		intent
-	});
-	if (intent.curve === "ecdsa") return selectEvmFamilyEcdsaTransactionLane({
-		...input,
-		intent
-	});
-	return {
-		ok: false,
-		failure: {
-			kind: "unsupported_intent",
-			curve: intent.curve || "unknown",
-			chain: intent.chain || "unknown"
-		}
-	};
-}
-function selectSelectedEd25519Lane(input) {
-	const selected = selectNearEd25519MaterialCandidate(input);
-	if (!selected.ok) return selected;
-	if (selected.kind === "authorization_required") return {
-		ok: false,
-		failure: {
-			kind: "no_candidate",
-			authMethod: laneCandidateAuthMethod(selected.candidate)
-		}
-	};
-	const selectionCandidate = toNearEd25519TransactionSelectableLane(selected.availableLane);
-	if (!selectionCandidate) throw new Error("[SigningSessionSelectLane] authorized Ed25519 lane is not selectable");
-	return {
-		ok: true,
-		lane: selected.lane,
-		candidate: selected.candidate,
-		availableLane: selectionCandidate.availableLane,
-		selectionCandidate
-	};
-}
-function nearEd25519CandidateMatchesIntent(candidate, intent) {
-	if (candidate.candidate.walletId !== intent.walletId || candidate.candidate.nearAccountId !== intent.signerSelection.nearAccountId) return false;
-	switch (intent.signerSelection.kind) {
-		case "near_account": return true;
-		case "signer_slot": return candidate.candidate.signerSlot === intent.signerSelection.signerSlot;
-	}
-}
-function selectNearEd25519MaterialCandidate(input) {
-	const intent = input.intent;
-	const allowed = transactionCandidatesAllowedByAuthPolicy(intent, (input.availableLanes?.candidates.ed25519.near || []).filter(isConcreteNearEd25519Lane).map((availableLane) => ({
-		availableLane,
-		candidate: ed25519LaneCandidateFromAvailableLane({ lane: availableLane })
-	})).filter((entry) => entry.candidate !== null).filter((candidate) => nearEd25519CandidateMatchesIntent(candidate, intent)));
-	if (!allowed.length) return {
-		ok: false,
-		failure: intent.authSelectionPolicy.kind === "any" ? { kind: "no_candidate" } : {
-			kind: "no_candidate",
-			authMethod: intent.authSelectionPolicy.authMethod
-		}
-	};
-	const selected = selectOnlyConcreteTransactionCandidate(allowed);
-	if (!selected) return {
-		ok: false,
-		failure: {
-			kind: "ambiguous_material",
-			allowedAuthMethods: allowedAuthMethods(allowed)
-		}
-	};
-	if (selected.candidate.authorizationState === "authorization_required") {
-		if (selected.availableLane.authorizationState !== "authorization_required") throw new Error("[SigningSessionSelectLane] Ed25519 material authorization mismatch");
-		return {
-			ok: true,
-			kind: "authorization_required",
-			candidate: selected.candidate,
-			availableLane: selected.availableLane
-		};
-	}
-	if (selected.availableLane.authorizationState !== "authorized") throw new Error("[SigningSessionSelectLane] Ed25519 material authorization mismatch");
-	return {
-		ok: true,
-		kind: "authorized",
-		lane: selectedEd25519LaneForTransactionCandidate(selected.candidate),
-		candidate: selected.candidate,
-		availableLane: selected.availableLane
-	};
-}
-function selectEvmFamilyEcdsaTransactionLane(input) {
-	const selected = selectEvmFamilyEcdsaMaterialCandidate(input);
-	if (!selected.ok) return selected;
-	if (selected.kind === "authorization_required") return {
-		ok: false,
-		failure: {
-			kind: "no_candidate",
-			authMethod: laneCandidateAuthMethod(selected.candidate)
-		}
-	};
-	return {
-		ok: true,
-		lane: selected.lane,
-		candidate: selected.candidate,
-		availableLane: selected.availableLane,
-		selectionCandidate: {
-			candidate: selected.candidate,
-			availableLane: selected.availableLane
-		}
-	};
-}
-function selectEvmFamilyEcdsaMaterialCandidate(input) {
-	const intent = input.intent;
-	const allowed = transactionCandidatesAllowedByAuthPolicy(intent, input.availableLanes ? ecdsaAvailableLaneCandidatesForTarget(input.availableLanes, intent.chainTarget).filter(isConcreteEvmFamilyEcdsaLane).map((availableLane) => ({
-		availableLane,
-		candidate: ecdsaLaneCandidateFromAvailableLane({
-			walletId: intent.walletId,
-			lane: availableLane
-		})
-	})).filter((entry) => entry.candidate !== null) : []);
-	if (!allowed.length) return {
-		ok: false,
-		failure: intent.authSelectionPolicy.kind === "any" ? { kind: "no_candidate" } : {
-			kind: "no_candidate",
-			authMethod: intent.authSelectionPolicy.authMethod
-		}
-	};
-	const selected = selectOnlyConcreteTransactionCandidate(allowed);
-	if (!selected) return {
-		ok: false,
-		failure: {
-			kind: "ambiguous_material",
-			allowedAuthMethods: allowedAuthMethods(allowed)
-		}
-	};
-	if (selected.candidate.authorizationState === "authorization_required") return {
-		ok: true,
-		kind: "authorization_required",
-		candidate: selected.candidate,
-		availableLane: selected.availableLane
-	};
-	return {
-		ok: true,
-		kind: "authorized",
-		lane: selectedEvmFamilyLaneFromCandidate({
-			intent,
-			candidate: selected.candidate
-		}),
-		candidate: selected.candidate,
-		availableLane: selected.availableLane
-	};
-}
-function selectedEvmFamilyLaneFromCandidate(args) {
-	if (!thresholdEcdsaChainTargetsEqual(args.candidate.chainTarget, args.intent.chainTarget)) throw new Error("[SigningSessionSelectLane] ECDSA available lane target mismatch");
-	return selectedLaneFromCandidate(args.candidate);
-}
-function transactionCandidatesAllowedByAuthPolicy(intent, candidates) {
-	if (intent.authSelectionPolicy.kind === "any") return candidates;
-	const policyAuthMethod = intent.authSelectionPolicy.authMethod;
-	return candidates.filter((candidate) => laneCandidateAuthMethod(candidate.candidate) === policyAuthMethod);
-}
-function selectTransactionLaneFromAvailableLanes(state) {
-	const selection = selectTransactionLane({
-		intent: state.intent,
-		availableLanes: state.availableLanes
-	});
-	if (!selection.ok) return {
-		tag: "LaneSelectionFailed",
-		intent: state.intent,
-		failure: selection.failure
-	};
-	return {
-		tag: "LaneSelected",
-		intent: state.intent,
-		lane: selection.lane,
-		candidate: selection.candidate,
-		availableLane: selection.availableLane,
-		selectionCandidate: selection.selectionCandidate
-	};
-}
-//#endregion
-//#region src/core/signingEngine/session/operationState/preparedOperation.ts
-async function prepareThresholdSigningOperation(args) {
-	const lifecycle = await args.lifecycleAdapter.prepare({
-		intent: args.intent,
-		...args.operation ? { operation: args.operation } : {}
-	});
-	if (lifecycle.lane.curve !== lifecycle.readiness.readiness.curve) throw new Error("[SigningSession] prepared lane and readiness curves do not match");
-	const coordinatorInput = {
-		lane: lifecycle.lane,
-		readiness: lifecycle.readiness.readiness,
-		expiresAtMs: lifecycle.readiness.expiresAtMs,
-		remainingUses: lifecycle.readiness.remainingUses,
-		usesNeeded: lifecycle.readiness.usesNeeded,
-		...lifecycle.readiness.trustedStatusAuth ? { trustedStatusAuth: lifecycle.readiness.trustedStatusAuth } : {},
-		forceFreshAuth: args.forceFreshAuth || lifecycle.forceFreshAuth,
-		sensitiveOperationPolicy: args.sensitiveOperationPolicy,
-		missingWhenExpiresAtMissing: args.missingWhenExpiresAtMissing
-	};
-	const resolved = await args.coordinator.resolveAuthPlanFromReadiness(coordinatorInput, args.onPlannerTrace);
-	return {
-		intent: args.intent,
-		...args.operation ? { operation: args.operation } : {},
-		lane: lifecycle.lane,
-		authMethod: signingLaneAuthMethod(lifecycle.lane.auth),
-		signingSessionPlan: resolved.signingSessionPlan,
-		readiness: resolved.readiness,
-		expiresAtMs: resolved.expiresAtMs,
-		remainingUses: resolved.remainingUses,
-		...lifecycle.readiness.trustedStatusAuth ? { trustedStatusAuth: lifecycle.readiness.trustedStatusAuth } : {},
-		availableLanesGeneration: Math.max(0, Math.floor(Number(lifecycle.availableLanesGeneration) || 0)),
-		metadata: lifecycle.metadata || {}
-	};
-}
-//#endregion
-//#region src/core/signingEngine/session/operationState/transactionState.ts
-function classifyTransactionReadiness(state, readiness) {
-	return {
-		tag: "ReadinessClassified",
-		intent: state.intent,
-		lane: state.lane,
-		candidate: state.candidate,
-		availableLane: state.availableLane,
-		readiness
-	};
-}
-function prepareTransactionOperationFromReadiness(state) {
-	return {
-		intent: state.intent,
-		lane: state.lane,
-		readiness: state.readiness
-	};
-}
-async function prepareTransactionSigningOperation(args) {
-	let transactionLane = null;
-	let transactionIntent = null;
-	let transactionOperation = null;
-	const thresholdOperation = await prepareThresholdSigningOperation({
-		intent: thresholdIntentFromTransactionIntent(args.intent),
-		lifecycleAdapter: { prepare: async (input) => {
-			const lifecycle = await args.lifecycleAdapter.prepare({
-				intent: args.intent,
-				...input.operation ? { operation: input.operation } : {}
-			});
-			transactionLane = lifecycle.transactionLane;
-			transactionIntent = lifecycle.transactionIntent || args.intent;
-			return {
-				lane: lifecycle.lane,
-				readiness: lifecycle.readiness,
-				availableLanesGeneration: lifecycle.availableLanesGeneration,
-				forceFreshAuth: lifecycle.forceFreshAuth,
-				metadata: {
-					...lifecycle.metadata || {},
-					transactionLane: lifecycle.transactionLane,
-					transactionOperation: null
-				}
-			};
-		} },
-		coordinator: args.coordinator,
-		...args.operation ? { operation: args.operation } : {},
-		forceFreshAuth: args.forceFreshAuth,
-		sensitiveOperationPolicy: args.sensitiveOperationPolicy,
-		missingWhenExpiresAtMissing: args.missingWhenExpiresAtMissing,
-		onPlannerTrace: args.onPlannerTrace
-	});
-	if (!transactionLane) throw new Error("[SigningSession] transaction prepare did not return a transaction lane");
-	transactionOperation = {
-		intent: transactionIntent || args.intent,
-		lane: transactionLane,
-		readiness: transactionReadinessFromThresholdOperation(thresholdOperation)
-	};
-	thresholdOperation.metadata.transactionOperation = transactionOperation;
-	return {
-		thresholdOperation,
-		transactionOperation
-	};
-}
-function thresholdIntentFromTransactionIntent(intent) {
-	return {
-		kind: "transaction_sign",
-		chain: intent.chain,
-		curve: intent.curve,
-		walletId: String(intent.walletId),
-		reason: "transaction"
-	};
-}
-function transactionReadinessFromThresholdOperation(operation) {
-	const status = operation.readiness.status;
-	if (status === "ready") return {
-		status: "ready",
-		remainingUses: Math.max(0, Math.floor(Number(operation.remainingUses) || 0)),
-		expiresAtMs: Math.max(0, Math.floor(Number(operation.expiresAtMs) || 0))
-	};
-	if (status === "missing_session") return {
-		status: "status_unavailable",
-		reason: "missing_session"
-	};
-	if (status === "expired") return { status: "expired" };
-	if (status === "exhausted") return { status: "exhausted" };
-	if (status === "auth_unavailable") return {
-		status: "auth_unavailable",
-		reason: "auth_unavailable"
-	};
-	if (status === "status_unavailable") return {
-		status: "status_unavailable",
-		reason: "status_unavailable"
-	};
-	if (status === "status_unknown") return {
-		status: "status_unknown",
-		reason: "status_unknown"
-	};
-	return {
-		status: "policy_blocked",
-		reason: status
-	};
-}
-//#endregion
-export { parseWalletSessionAuthorizationBoundary as _, recordAvailableSigningLanesRead as a, withThresholdCommitQueue as b, selectTransactionLaneFromAvailableLanes as c, availableEd25519SigningLaneAuthMethod as d, ecdsaAvailableLaneCandidatesForTarget as f, readAvailableSigningLanes as g, isConcreteAvailableSigningLane as h, receiveTransactionIntent as i, activeWalletAuthorityAvailableLaneFromProjection as l, ecdsaAvailableLaneIdentityKey as m, prepareTransactionOperationFromReadiness as n, selectEvmFamilyEcdsaMaterialCandidate as o, ecdsaAvailableLaneForTarget as p, prepareTransactionSigningOperation as r, selectNearEd25519MaterialCandidate as s, classifyTransactionReadiness as t, availableEcdsaSigningLaneAuthMethod as u, requireAuthoritativeExpiredWalletSessionAuthorizationBoundary as v, clearThresholdCommitQueue as y };