@seams/wallet 0.8.0 → 0.9.1

package/dist/esm/core/signingEngine/session/SigningSessionCoordinator.js

@@ -1,344 +0,0 @@
-import { createSigningSessionExpiredEvent } from "../../types/sdkSentEvents.js";
-import { toWalletId } from "../interfaces/ecdsaChainTarget.js";
-import { signingLaneAuthMethod } from "./identity/signingLaneAuthBinding.js";
-import { createSigningPlannerDecisionTraceEvent, planSigningSession } from "./planning/planner.js";
-import { requiredSigningSubjectForExactSigningLane, resolveExactWalletSessionOperationCredential } from "./identity/exactWalletSessionCredential.js";
-import { resolveActiveAuthorizedRouterAbEd25519WalletSessionState } from "./warmCapabilities/routerAbEd25519WalletSessionState.js";
-import { buildWalletSessionStatusCheck, unknownSigningSessionStatus, walletSessionStatusOwnerForLane } from "./lifecycle/walletSessionStatus.js";
-import { applyWalletSessionStatusToSigningSessionReadiness, clearWalletSession, discoverLanesForWallet, normalizeNonEmpty, readClaimsForLanes, readDirectSigningSessionStatusForTargets, readWalletScopedLaneClaimsForWallet, statusFromClaim, walletScopedClaimsForLanes } from "./availability/readiness.js";
-import { SigningOperationIdBindingRegistry } from "./planning/operationIdBinding.js";
-import { ClientWalletSessionExpiryInvalidator } from "./availability/clientSessionExpiryInvalidator.js";
-//#region src/core/signingEngine/session/SigningSessionCoordinator.ts
-function isEd25519SigningSessionAuthPlanInput(input) {
-	return input.lane.curve === "ed25519" && input.readiness.curve === "ed25519";
-}
-function isEcdsaSigningSessionAuthPlanInput(input) {
-	return input.lane.curve === "ecdsa" && input.readiness.curve === "ecdsa";
-}
-var SigningSessionLifecycleSubscriptionHandle = class {
-	#listeners;
-	#listener;
-	#active = true;
-	constructor(args) {
-		this.#listeners = args.listeners;
-		this.#listener = args.listener;
-	}
-	unsubscribe() {
-		if (!this.#active) return;
-		this.#active = false;
-		this.#listeners.delete(this.#listener);
-	}
-};
-function mapWalletSessionExpiredEvent(args) {
-	return createSigningSessionExpiredEvent({
-		walletId: args.event.walletId,
-		walletSessionId: args.event.walletSessionId,
-		authMethod: args.event.authMethod,
-		expiresAtMs: args.event.expiresAtMs,
-		detectedAtMs: args.event.detectedAtMs,
-		source: args.source
-	});
-}
-var SigningSessionCoordinator = class {
-	constructor(deps) {
-		this.lifecycleListeners = /* @__PURE__ */ new Set();
-		this.walletSessionQuotaAdmissionRefreshQueues = /* @__PURE__ */ new Map();
-		this.exactWalletSessionReadPorts = deps.exactWalletSessionReadPorts;
-		this.onPlannerTrace = deps.onPlannerTrace;
-		this.walletSessionDeps = deps;
-		this.walletSessionState = { statusOverrides: /* @__PURE__ */ new Map() };
-		this.walletSessionExpiryInvalidator = new ClientWalletSessionExpiryInvalidator({
-			readiness: {
-				touchConfirm: deps.touchConfirm,
-				clearEmailOtpWarmSessionMaterial: deps.clearEmailOtpWarmSessionMaterial
-			},
-			statusOverrides: this.walletSessionState.statusOverrides
-		});
-		this.operationIdBindings = new SigningOperationIdBindingRegistry();
-		this.walletSessionStatusReader = deps.getStatus;
-	}
-	async resolveActiveAuthorizedRouterAbEd25519WalletSessionState(args) {
-		return await resolveActiveAuthorizedRouterAbEd25519WalletSessionState({
-			state: args.state,
-			nowMs: args.nowMs,
-			ports: this.exactWalletSessionReadPorts
-		});
-	}
-	subscribeLifecycle(listener) {
-		this.lifecycleListeners.add(listener);
-		return new SigningSessionLifecycleSubscriptionHandle({
-			listeners: this.lifecycleListeners,
-			listener
-		});
-	}
-	async invalidateExpiredWalletSession(args) {
-		const credential = await resolveExactWalletSessionOperationCredential({
-			ports: this.exactWalletSessionReadPorts,
-			input: {
-				walletId: args.state.walletId,
-				authMethod: args.state.authMethod,
-				walletSessionId: args.state.walletSessionId,
-				quotaId: args.state.quotaId,
-				requiredSigningSubject: requiredSigningSubjectForExactSigningLane(args.state.laneIdentity),
-				expiry: {
-					kind: "expired",
-					nowMs: args.state.detectedAtMs
-				}
-			}
-		});
-		if (credential.kind !== "resolved") return {
-			kind: "unavailable",
-			failures: ["wallet_session_authorization"],
-			event: null
-		};
-		const invalidation = await this.walletSessionExpiryInvalidator.invalidate({
-			state: args.state,
-			walletSessionId: credential.resolved.walletSessionId
-		});
-		if (invalidation.kind !== "invalidated") return invalidation;
-		const event = mapWalletSessionExpiredEvent({
-			event: invalidation.event,
-			source: args.source
-		});
-		this.emitLifecycleEvent(event);
-		return {
-			kind: "invalidated",
-			event
-		};
-	}
-	emitLifecycleEvent(event) {
-		for (const listener of this.lifecycleListeners) try {
-			listener(event);
-		} catch (error) {
-			console.error("[SigningSessionCoordinator] lifecycle listener failed", error);
-		}
-	}
-	resolveAuthPlan(input, onTrace) {
-		const plan = planSigningSession(input);
-		const traceEvent = createSigningPlannerDecisionTraceEvent(input, plan);
-		onTrace?.(traceEvent);
-		if (!onTrace) this.onPlannerTrace?.(traceEvent);
-		return plan;
-	}
-	async resolveAuthPlanFromReadiness(input, onTrace) {
-		if (isEd25519SigningSessionAuthPlanInput(input)) {
-			const sessionStatusAware = await this.applyWalletSessionStatusToEd25519Readiness(input);
-			return {
-				...sessionStatusAware,
-				signingSessionPlan: this.resolveAuthPlan({
-					lane: input.lane,
-					readiness: sessionStatusAware.readiness,
-					forceFreshAuth: input.forceFreshAuth,
-					sensitiveOperationPolicy: input.sensitiveOperationPolicy
-				}, onTrace)
-			};
-		}
-		if (isEcdsaSigningSessionAuthPlanInput(input)) {
-			const expiresAtMs = input.readiness.status === "ready" || input.readiness.status === "exhausted" || input.readiness.status === "expired" ? input.readiness.expiresAtMs : Math.floor(Number(input.expiresAtMs) || 0);
-			const remainingUses = input.readiness.status === "ready" || input.readiness.status === "exhausted" ? input.readiness.remainingUses : 0;
-			return {
-				readiness: input.readiness,
-				expiresAtMs,
-				remainingUses,
-				signingSessionPlan: this.resolveAuthPlan({
-					lane: input.lane,
-					readiness: input.readiness,
-					forceFreshAuth: input.forceFreshAuth,
-					sensitiveOperationPolicy: input.sensitiveOperationPolicy
-				}, onTrace)
-			};
-		}
-		throw new Error("[SigningSessionCoordinator] lane and readiness curves do not match");
-	}
-	async getStatus(args) {
-		const walletId = toWalletId(args.walletId);
-		const walletSessionId = args.walletSessionId;
-		const targetThreshold = new Set((args.targetThresholdSessionIds || []).map(normalizeNonEmpty).filter(Boolean));
-		const hasExplicitTarget = targetThreshold.size > 0;
-		const readDirectTargetStatus = async () => {
-			if (!hasExplicitTarget) return null;
-			return await readDirectSigningSessionStatusForTargets({
-				deps: this.walletSessionDeps,
-				walletSessionId,
-				targetThresholdSessionIds: targetThreshold
-			});
-		};
-		const lanes = (await discoverLanesForWallet(this.walletSessionDeps, walletId)).filter((lane) => lane.walletSessionId === walletSessionId && lane.quotaId === args.quotaId);
-		if (!lanes.length) return await readDirectTargetStatus();
-		const statusLanes = hasExplicitTarget ? lanes.filter((lane) => targetThreshold.has(lane.thresholdSessionId)) : lanes;
-		if (hasExplicitTarget && !statusLanes.length) return await readDirectTargetStatus() || {
-			sessionId: walletSessionId,
-			status: "not_found"
-		};
-		const scopedClaims = walletScopedClaimsForLanes({
-			lanes: statusLanes,
-			claimsByThresholdSessionId: await readClaimsForLanes({
-				deps: this.walletSessionDeps,
-				lanes: statusLanes
-			}),
-			statusOverrides: this.walletSessionState.statusOverrides
-		});
-		const claims = statusLanes.map((lane) => scopedClaims.get(lane.thresholdSessionId) || null).filter(Boolean);
-		return statusFromClaim({
-			walletSessionId,
-			lanes: statusLanes,
-			claim: claims.find((candidate) => candidate?.state === "expired") || claims.find((candidate) => candidate?.state === "exhausted") || claims.find((candidate) => candidate?.state === "unavailable") || claims.find((candidate) => candidate?.state === "warm") || null
-		});
-	}
-	async getLaneClaimsForWallet(walletId) {
-		return await readWalletScopedLaneClaimsForWallet({
-			deps: this.walletSessionDeps,
-			walletId: toWalletId(walletId),
-			statusOverrides: this.walletSessionState.statusOverrides
-		});
-	}
-	async clear(args) {
-		await clearWalletSession({
-			deps: this.walletSessionDeps,
-			statusOverrides: this.walletSessionState.statusOverrides,
-			walletId: toWalletId(args.walletId),
-			walletSessionId: args.walletSessionId,
-			quotaId: args.quotaId
-		});
-	}
-	async getAvailableStatus(input) {
-		if (!this.walletSessionStatusReader) return null;
-		return await this.walletSessionStatusReader(input);
-	}
-	bindCallerProvidedOperationIdToFingerprint(args) {
-		this.operationIdBindings.bindCallerProvidedOperationIdToFingerprint(args);
-	}
-	async readWalletSessionStatus(sessionStatusCheck) {
-		const walletSessionId = sessionStatusCheck?.authorization.walletSessionId;
-		if (!walletSessionId) return { kind: "authorization_missing" };
-		if (!this.walletSessionStatusReader) return {
-			kind: "status",
-			status: unknownSigningSessionStatus({
-				walletSessionId,
-				reason: "adapter_unavailable"
-			})
-		};
-		const status = await this.walletSessionStatusReader(sessionStatusCheck);
-		if (!status) return {
-			kind: "status",
-			status: unknownSigningSessionStatus({
-				walletSessionId,
-				reason: "missing_trusted_status"
-			})
-		};
-		return {
-			kind: "status",
-			status
-		};
-	}
-	async runWalletSessionQuotaAdmissionRetry(args) {
-		const queueKey = String(args.queueKey);
-		const existing = this.walletSessionQuotaAdmissionRefreshQueues.get(queueKey);
-		if (existing) {
-			await existing.catch(() => void 0);
-			return await args.retryAfterRefresh();
-		}
-		const refreshPromise = args.refresh();
-		const queueEntry = refreshPromise.catch(() => void 0).then(() => {
-			if (this.walletSessionQuotaAdmissionRefreshQueues.get(queueKey) === queueEntry) this.walletSessionQuotaAdmissionRefreshQueues.delete(queueKey);
-		});
-		this.walletSessionQuotaAdmissionRefreshQueues.set(queueKey, queueEntry);
-		return await refreshPromise;
-	}
-	async applyWalletSessionStatusToEd25519Readiness(input) {
-		const walletSessionId = String(input.lane.walletSessionId).trim();
-		const sessionStatusCheck = await buildSessionStatusCheckForLane({
-			lane: input.lane,
-			trustedStatusAuth: input.trustedStatusAuth,
-			nowMs: Date.now(),
-			exactWalletSessionReadPorts: this.exactWalletSessionReadPorts
-		});
-		const statusRead = await this.readWalletSessionStatus(sessionStatusCheck).catch(() => sessionStatusCheck ? {
-			kind: "status",
-			status: {
-				sessionId: String(sessionStatusCheck.authorization.walletSessionId),
-				status: "unavailable"
-			}
-		} : { kind: "authorization_missing" });
-		if (statusRead.kind === "authorization_missing") return applyWalletSessionStatusToSigningSessionReadiness({
-			status: "missing_session",
-			thresholdSessionId: input.readiness.thresholdSessionId,
-			walletSessionStatus: null,
-			expiresAtMs: Math.floor(Number(input.expiresAtMs) || 0),
-			remainingUses: 0,
-			usesNeeded: input.usesNeeded,
-			missingWhenExpiresAtMissing: input.missingWhenExpiresAtMissing
-		});
-		const walletSessionStatus = statusRead.status;
-		const emailOtpEd25519PreflightUnavailable = signingLaneAuthMethod(input.lane.auth) === "email_otp" && input.lane.curve === "ed25519" && (walletSessionStatus?.status === "status_unknown" || walletSessionStatus?.status === "unavailable");
-		const passkeyEd25519PreflightUnavailable = signingLaneAuthMethod(input.lane.auth) === "passkey" && input.readiness.status === "ready" && (walletSessionStatus?.status === "status_unknown" || walletSessionStatus?.status === "unavailable");
-		let sessionStatusForPlanning = walletSessionStatus;
-		if (passkeyEd25519PreflightUnavailable) sessionStatusForPlanning = null;
-		else if (emailOtpEd25519PreflightUnavailable) sessionStatusForPlanning = {
-			sessionId: walletSessionId,
-			status: "not_found",
-			statusCode: walletSessionStatus.status
-		};
-		if (emailOtpEd25519PreflightUnavailable) console.warn("[SigningSessionCoordinator][email-otp-ed25519] session-status preflight unavailable", {
-			walletSessionId,
-			thresholdSessionId: input.lane.thresholdSessionId,
-			sessionStatus: walletSessionStatus.status,
-			readiness: input.readiness.status,
-			remainingUses: input.remainingUses,
-			usesNeeded: input.usesNeeded
-		});
-		if (passkeyEd25519PreflightUnavailable) console.debug("[SigningSessionCoordinator][passkey-ed25519] session-status preflight deferred", {
-			walletSessionId,
-			thresholdSessionId: input.lane.thresholdSessionId,
-			sessionStatus: walletSessionStatus.status,
-			readiness: input.readiness.status,
-			remainingUses: input.remainingUses,
-			usesNeeded: input.usesNeeded
-		});
-		return applyWalletSessionStatusToSigningSessionReadiness({
-			status: input.readiness.status,
-			thresholdSessionId: input.readiness.thresholdSessionId,
-			walletSessionStatus: sessionStatusForPlanning,
-			expiresAtMs: Math.floor(Number(input.expiresAtMs) || 0),
-			remainingUses: Math.floor(Number(input.remainingUses) || 0),
-			usesNeeded: input.usesNeeded,
-			missingWhenExpiresAtMissing: input.missingWhenExpiresAtMissing
-		});
-	}
-};
-async function buildSessionStatusCheckForLane(args) {
-	const owner = walletSessionStatusOwnerForLane(args.lane);
-	if (args.trustedStatusAuth) return buildWalletSessionStatusCheck({
-		owner,
-		authorization: {
-			walletSessionId: args.trustedStatusAuth.walletSessionId,
-			quotaId: args.trustedStatusAuth.quotaId
-		}
-	});
-	const credential = await resolveExactWalletSessionOperationCredential({
-		ports: args.exactWalletSessionReadPorts,
-		input: {
-			walletId: owner.walletId,
-			authMethod: signingLaneAuthMethod(args.lane.auth),
-			walletSessionId: args.lane.walletSessionId,
-			quotaId: args.lane.quotaId,
-			requiredSigningSubject: requiredSigningSubjectForExactSigningLane(args.lane.identity),
-			expiry: {
-				kind: "unexpired",
-				nowMs: args.nowMs
-			}
-		}
-	});
-	if (credential.kind !== "resolved") return null;
-	return buildWalletSessionStatusCheck({
-		owner,
-		authorization: {
-			walletSessionId: credential.resolved.walletSessionId,
-			quotaId: credential.resolved.session.quotaId
-		}
-	});
-}
-//#endregion
-export { SigningSessionCoordinator };
-
-//# sourceMappingURL=SigningSessionCoordinator.js.map

package/dist/esm/core/signingEngine/session/authority/authorityOperationResolver.js

@@ -1,114 +0,0 @@
-import { computeWalletAuthorityDigestB64u, computeWalletSignerActivationSetDigestB64u } from "../../../../shared-ts/src/authorization/walletAuthority.js";
-//#region src/core/signingEngine/session/authority/authorityOperationResolver.ts
-async function resolveWalletAuthorityOperation(input) {
-	const { authMethod, authority } = input.selected;
-	if (authority.state !== "active") return {
-		kind: "rejected",
-		reason: { kind: "authority_not_active" }
-	};
-	if (authMethod.status !== "active") return {
-		kind: "rejected",
-		reason: { kind: "auth_method_not_active" }
-	};
-	if (authority.walletId !== authMethod.walletId) return {
-		kind: "rejected",
-		reason: { kind: "wallet_id_mismatch" }
-	};
-	if (authority.authorityId !== authMethod.walletAuthorityId) return {
-		kind: "rejected",
-		reason: { kind: "authority_id_mismatch" }
-	};
-	if (await computeWalletSignerActivationSetDigestB64u(authority.signerActivations) !== authority.signerActivationSetDigestB64u) return {
-		kind: "rejected",
-		reason: { kind: "authority_activation_set_digest_mismatch" }
-	};
-	if (await computeWalletAuthorityDigestB64u(authority) !== authority.authorityDigestB64u) return {
-		kind: "rejected",
-		reason: { kind: "authority_digest_mismatch" }
-	};
-	const requiredPermission = requiredPermissionForOperation(input.operation);
-	if (!authority.permissions.includes(requiredPermission)) return {
-		kind: "rejected",
-		reason: { kind: "permission_missing" }
-	};
-	switch (input.operation.kind) {
-		case "near_sign":
-		case "near_export": return resolveEd25519Operation(authority, authMethod);
-		case "evm_sign":
-		case "evm_export": return resolveEcdsaOperation(authority, authMethod);
-		default: return assertNeverOperation(input.operation);
-	}
-}
-function requiredPermissionForOperation(operation) {
-	switch (operation.kind) {
-		case "near_sign":
-		case "evm_sign": return "sign";
-		case "near_export":
-		case "evm_export": return "export_keys";
-		default: return assertNeverOperation(operation);
-	}
-}
-function resolveEd25519Operation(authority, authMethod) {
-	const activation = ed25519Activation(authority.signerActivations);
-	if (activation === null) return {
-		kind: "rejected",
-		reason: { kind: "signer_family_unavailable" }
-	};
-	if (activation.signer.walletId !== authority.walletId) return {
-		kind: "rejected",
-		reason: { kind: "signer_wallet_id_mismatch" }
-	};
-	return {
-		kind: "resolved",
-		value: {
-			kind: "resolved",
-			keyFamily: "ed25519",
-			walletId: authority.walletId,
-			authorityId: authority.authorityId,
-			authMethodId: authMethod.walletAuthMethodId,
-			materialActivation: activation.materialActivation,
-			registeredPublicKeyB64u: activation.signer.registeredPublicKeyB64u
-		}
-	};
-}
-function resolveEcdsaOperation(authority, authMethod) {
-	const activation = ecdsaActivation(authority.signerActivations);
-	if (activation === null) return {
-		kind: "rejected",
-		reason: { kind: "signer_family_unavailable" }
-	};
-	if (activation.signer.walletId !== authority.walletId) return {
-		kind: "rejected",
-		reason: { kind: "signer_wallet_id_mismatch" }
-	};
-	return {
-		kind: "resolved",
-		value: {
-			kind: "resolved",
-			keyFamily: "ecdsa_secp256k1",
-			walletId: authority.walletId,
-			authorityId: authority.authorityId,
-			authMethodId: authMethod.walletAuthMethodId,
-			materialActivation: activation.materialActivation,
-			thresholdPublicKey33B64u: activation.signer.thresholdPublicKey33B64u,
-			evmAddress: activation.signer.evmAddress
-		}
-	};
-}
-function ed25519Activation(activations) {
-	if (activations.keyFamilies[0] !== "ed25519") return null;
-	if (activations.ed25519 === void 0) return null;
-	return activations.ed25519;
-}
-function ecdsaActivation(activations) {
-	if (activations.keyFamilies[0] !== "ecdsa_secp256k1" && activations.keyFamilies.length !== 2) return null;
-	if (activations.ecdsa === void 0) return null;
-	return activations.ecdsa;
-}
-function assertNeverOperation(value) {
-	throw new Error(`unsupported wallet authority operation: ${String(value)}`);
-}
-//#endregion
-export { resolveWalletAuthorityOperation };
-
-//# sourceMappingURL=authorityOperationResolver.js.map

package/dist/esm/core/signingEngine/session/availability/canonicalLaneInventory.js

@@ -1,127 +0,0 @@
-//#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
-export { canonicalizeLaneFacts, serverIssuedGenerationFromNumber };
-
-//# sourceMappingURL=canonicalLaneInventory.js.map

package/dist/esm/core/signingEngine/session/availability/clientSessionExpiryInvalidator.js

@@ -1,72 +0,0 @@
-import { createClearVolatileWarmSessionMaterialCommand } from "../warmCapabilities/volatileWarmMaterialCommands.js";
-//#region src/core/signingEngine/session/availability/clientSessionExpiryInvalidator.ts
-function walletSessionInvalidationKey(state) {
-	return `${String(state.walletId)}:wallet-session:${String(state.walletSessionId)}`;
-}
-function walletSessionExpiredEvent(args) {
-	const state = args.state;
-	return {
-		kind: "wallet_session_expired",
-		walletId: state.walletId,
-		walletSessionId: args.walletSessionId,
-		authMethod: state.authMethod,
-		expiresAtMs: state.expiresAtMs,
-		detectedAtMs: state.detectedAtMs
-	};
-}
-async function clearExpiredAuthorization(args) {
-	const lane = args.state.laneIdentity;
-	if (!("thresholdSessionId" in lane)) return { kind: "cleared" };
-	try {
-		if (lane.auth.kind === "email_otp") await args.deps.readiness.clearEmailOtpWarmSessionMaterial(lane.thresholdSessionId);
-		else await args.deps.readiness.touchConfirm.clearVolatileWarmSessionMaterial(createClearVolatileWarmSessionMaterialCommand(lane.thresholdSessionId));
-		return { kind: "cleared" };
-	} catch {
-		return {
-			kind: "unavailable",
-			failures: [lane.auth.kind === "email_otp" ? "email_otp_material" : "touch_confirm_material"]
-		};
-	}
-}
-var ClientWalletSessionExpiryInvalidator = class {
-	#deps;
-	#cleanupBySession = /* @__PURE__ */ new Map();
-	#eventDelivered = /* @__PURE__ */ new Set();
-	constructor(deps) {
-		this.#deps = deps;
-	}
-	async invalidate(input) {
-		const state = input.state;
-		const key = walletSessionInvalidationKey(state);
-		let cleanup = this.#cleanupBySession.get(key);
-		if (!cleanup) {
-			cleanup = clearExpiredAuthorization({
-				deps: this.#deps,
-				state
-			});
-			this.#cleanupBySession.set(key, cleanup);
-		}
-		const cleanupResult = await cleanup;
-		if (cleanupResult.kind === "unavailable") {
-			this.#cleanupBySession.delete(key);
-			return {
-				kind: "unavailable",
-				failures: cleanupResult.failures,
-				event: null
-			};
-		}
-		if (this.#eventDelivered.has(key)) return {
-			kind: "already_invalidated",
-			event: null
-		};
-		this.#eventDelivered.add(key);
-		return {
-			kind: "invalidated",
-			event: walletSessionExpiredEvent(input)
-		};
-	}
-};
-//#endregion
-export { ClientWalletSessionExpiryInvalidator };
-
-//# sourceMappingURL=clientSessionExpiryInvalidator.js.map