@seams/wallet 0.7.1 → 0.8.0

package/dist/esm/react/core/signingEngine/session/availability/availableSigningLanes.js

@@ -1,1073 +0,0 @@
-import { mpcMaterialActivationRefsEqual } from "../../../../shared-ts/src/utils/domainIds.js";
-import { walletAuthAuthorityRef } from "../../../../shared-ts/src/utils/walletAuthAuthority.js";
-import { signingLaneAuthBindingKey, signingLaneAuthMethod } from "../identity/signingLaneAuthBinding.js";
-import { nearEd25519SigningKeyIdFromString } from "../../../../shared-ts/src/utils/registrationIds.js";
-import { thresholdEcdsaChainTargetKey, toWalletId } from "../../interfaces/ecdsaChainTarget.js";
-import { deriveEvmFamilyKeyFingerprintFromPublicFacts, toRpId } from "../identity/evmFamilyEcdsaIdentity.js";
-import { parseSignerSlot } from "../../../../shared-ts/src/utils/signerSlot.js";
-import { toAccountId } from "../../../types/accountIds.js";
-import { nearEd25519SessionMatchesMaterialActivation } from "../material/nearEd25519YaoSigningPreparation.js";
-import { canonicalizeLaneFacts, serverIssuedGenerationFromNumber } from "./canonicalLaneInventory.js";
-//#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
-export { activeWalletAuthorityAvailableLaneFromProjection, availableEcdsaSigningLaneAuthMethod, availableEd25519SigningLaneAuthMethod, ecdsaAvailableLaneCandidatesForTarget, ecdsaAvailableLaneForTarget, ecdsaAvailableLaneIdentityKey, ecdsaLaneCandidateFromAvailableLane, ed25519AvailableLaneIdentityKey, ed25519LaneCandidateFromAvailableLane, isConcreteAvailableSigningLane, readAvailableSigningLanes };
-
-//# sourceMappingURL=availableSigningLanes.js.map