@seams/wallet 0.7.3 → 0.8.0

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

@@ -1,464 +0,0 @@
-import { mpcMaterialActivationRefsEqual, parseThresholdEd25519SessionId } from "../../../../shared-ts/src/utils/domainIds.js";
-import { SIGNER_AUTH_METHODS } from "../../../../shared-ts/src/utils/signerDomain.js";
-import { listExactSealedSessionsForWallet } from "../persistence/sealedSessionStore.js";
-import { parseExactEd25519SealedSessionRuntime } from "../warmCapabilities/ed25519SealedSessionRuntime.js";
-import { createClearVolatileWarmSessionMaterialCommand } from "../warmCapabilities/volatileWarmMaterialCommands.js";
-import { resolveWalletAuthorityOperation } from "../authority/authorityOperationResolver.js";
-import { normalizeWarmSessionReadPorts, readWarmSessionClaim, toSigningSessionStatus } from "../warmCapabilities/readModel.js";
-import { ed25519WalletSessionStatusOwner, normalizeSessionStatusRequired, walletSessionStatusIdentityKey, walletSessionStatusOwnerKey } from "../lifecycle/walletSessionStatus.js";
-//#region src/core/signingEngine/session/availability/readiness.ts
-function normalizeNonEmpty(value) {
-	return String(value || "").trim();
-}
-function warmClaimFromRecordPolicy(args) {
-	const thresholdSessionId = normalizeNonEmpty(args.thresholdSessionId);
-	const remainingUses = Math.max(0, Math.floor(Number(args.remainingUses) || 0));
-	const expiresAtMs = Math.floor(Number(args.expiresAtMs) || 0);
-	if (expiresAtMs <= Date.now()) return {
-		state: "expired",
-		thresholdSessionId
-	};
-	if (remainingUses <= 0) return {
-		state: "exhausted",
-		thresholdSessionId
-	};
-	return {
-		state: "warm",
-		thresholdSessionId,
-		remainingUses,
-		expiresAtMs
-	};
-}
-function applyWalletSessionStatusToSigningSessionReadiness(args) {
-	let status = args.status;
-	let expiresAtMs = Math.floor(Number(args.expiresAtMs) || 0);
-	let remainingUses = Math.max(0, Math.floor(Number(args.remainingUses) || 0));
-	const walletSessionStatus = args.walletSessionStatus;
-	if (walletSessionStatus) {
-		if (walletSessionStatus.status === "not_found") {
-			status = "missing_session";
-			remainingUses = 0;
-		} else if (walletSessionStatus.status === "status_unknown" && status === "ready") {
-			status = "status_unknown";
-			remainingUses = 0;
-		} else if (walletSessionStatus.status === "unavailable") {
-			status = "status_unavailable";
-			remainingUses = 0;
-		} else if (walletSessionStatus.status === "expired") {
-			status = "expired";
-			remainingUses = 0;
-		} else if (walletSessionStatus.status === "exhausted") {
-			status = "exhausted";
-			remainingUses = 0;
-		} else if (walletSessionStatus.status === "active") {
-			const sessionRemainingUses = Math.max(0, Math.floor(Number(walletSessionStatus.remainingUses) || 0));
-			const sessionExpiresAtMs = Math.floor(Number(walletSessionStatus.expiresAtMs) || 0);
-			remainingUses = sessionRemainingUses;
-			if (sessionExpiresAtMs > 0) expiresAtMs = sessionExpiresAtMs;
-			if (status === "exhausted") status = "ready";
-		}
-	}
-	const usesNeeded = Math.max(1, Math.floor(Number(args.usesNeeded) || 1));
-	if (status === "ready" && args.missingWhenExpiresAtMissing && expiresAtMs <= 0) status = "missing_session";
-	if (status === "ready" && expiresAtMs <= (args.nowMs ?? Date.now())) status = "expired";
-	if (status === "ready" && remainingUses < usesNeeded) status = "exhausted";
-	return {
-		readiness: status === "ready" || status === "exhausted" ? {
-			status,
-			curve: "ed25519",
-			thresholdSessionId: args.thresholdSessionId,
-			remainingUses,
-			expiresAtMs
-		} : status === "expired" ? {
-			status,
-			curve: "ed25519",
-			thresholdSessionId: args.thresholdSessionId,
-			expiresAtMs
-		} : {
-			status,
-			curve: "ed25519",
-			thresholdSessionId: args.thresholdSessionId
-		},
-		expiresAtMs,
-		remainingUses
-	};
-}
-function toLaneSource(runtime) {
-	switch (runtime.factor.kind) {
-		case "email_otp": return SIGNER_AUTH_METHODS.emailOtp;
-		case "passkey": return SIGNER_AUTH_METHODS.passkey;
-	}
-}
-function authMethodForSigningSessionLanes(lanes) {
-	for (const lane of lanes) {
-		const source = lane.source;
-		switch (source) {
-			case SIGNER_AUTH_METHODS.emailOtp: return SIGNER_AUTH_METHODS.emailOtp;
-			case SIGNER_AUTH_METHODS.passkey: break;
-			default: return assertNeverSigningSessionLaneAuthMethod(source);
-		}
-	}
-	return null;
-}
-function assertNeverSigningSessionLaneAuthMethod(value) {
-	throw new Error(`Unsupported signing session lane auth method: ${String(value)}`);
-}
-function resolveRuntimeWalletOwnerId(runtime) {
-	return ed25519WalletSessionStatusOwner(runtime.walletId);
-}
-function addLane(lanes, lane) {
-	if (!lane) return;
-	if (!lane.thresholdSessionId || !lane.walletSessionId) return;
-	lanes.push(lane);
-}
-function buildDiscoveredLaneForRuntime(runtime, walletSessionId, quotaId) {
-	return {
-		curve: "ed25519",
-		chain: "near",
-		source: toLaneSource(runtime),
-		thresholdSessionId: runtime.thresholdSessionId,
-		walletSessionId,
-		quotaId,
-		materialActivation: runtime.sealedRecord.ed25519Restore.materialActivation,
-		backing: "record_policy",
-		runtime
-	};
-}
-async function discoverLanesForWallet(deps, walletId) {
-	return await discoverLanesForWalletWithExactAuthorization(deps, walletId, deps.exactWalletSessionReadPorts);
-}
-function exactEd25519SignSubjectMatches(authorization, materialActivation) {
-	return authorization.capabilitySubjects.some((subject) => subject.kind === "sign" && subject.keyFamily === "ed25519" && mpcMaterialActivationRefsEqual(subject.materialActivation, materialActivation));
-}
-function selectedMethodMatchesRuntime(args) {
-	switch (args.runtime.factor.kind) {
-		case "passkey": return args.authMethod.kind === "passkey" && String(args.authMethod.rpId) === String(args.runtime.factor.rpId) && String(args.authMethod.credentialIdB64u) === String(args.runtime.factor.credentialIdB64u);
-		case "email_otp": return args.authMethod.kind === "email_otp" && args.authMethod.emailHashHex === args.runtime.factor.emailHashHex;
-	}
-}
-async function discoverLanesForWalletWithExactAuthorization(deps, walletId, resolver) {
-	const listSealed = deps.listExactSealedSessionsForWallet ?? listExactSealedSessionsForWallet;
-	const records = (await Promise.all([listSealed({
-		walletId,
-		filter: {
-			authMethod: SIGNER_AUTH_METHODS.passkey,
-			curve: "ed25519"
-		}
-	}), listSealed({
-		walletId,
-		filter: {
-			authMethod: SIGNER_AUTH_METHODS.emailOtp,
-			curve: "ed25519"
-		}
-	})])).flat();
-	let selected;
-	try {
-		selected = await resolver.resolveSelectedWalletAuthority(String(walletId));
-	} catch {
-		return [];
-	}
-	if (selected.kind !== "resolved") return [];
-	const { selection, authMethod, authority } = selected;
-	if (selection.lockState !== "unlocked" || selection.walletId !== walletId || selection.walletAuthMethodId !== authMethod.walletAuthMethodId || authMethod.status !== "active" || authMethod.walletId !== walletId || authMethod.walletAuthorityId !== authority.authorityId || authority.state !== "active" || authority.walletId !== walletId) return [];
-	let operation;
-	try {
-		operation = await resolveWalletAuthorityOperation({
-			selected: {
-				authMethod,
-				authority
-			},
-			operation: {
-				kind: "near_sign",
-				operation: "sign",
-				keyFamily: "ed25519"
-			}
-		});
-	} catch {
-		return [];
-	}
-	if (operation.kind !== "resolved" || operation.value.walletId !== walletId || operation.value.authorityId !== authority.authorityId || operation.value.authMethodId !== authMethod.walletAuthMethodId) return [];
-	let authorizationRead;
-	try {
-		authorizationRead = await resolver.readExactWithOperationCredential({
-			walletId,
-			authorityId: authority.authorityId,
-			authMethodId: authMethod.walletAuthMethodId
-		});
-	} catch {
-		return [];
-	}
-	if (authorizationRead.kind !== "found") return [];
-	const authorization = authorizationRead.record;
-	const operationCredential = authorizationRead.operationCredential;
-	if (authorization.walletId !== walletId || authorization.authorityId !== authority.authorityId || authorization.authMethodId !== authMethod.walletAuthMethodId || authorization.authorityDigestB64u !== authority.authorityDigestB64u || authorization.authorityRevocationEpoch !== authority.revocationEpoch || authorization.expiresAtMs <= Date.now() || operationCredential.walletSessionId.length === 0 || operationCredential.token.trim().length === 0 || !exactEd25519SignSubjectMatches(authorization, operation.value.materialActivation)) return [];
-	const lanes = [];
-	const seenThresholdSessionIds = /* @__PURE__ */ new Set();
-	for (const record of records) {
-		if (record.curve !== "ed25519") continue;
-		const runtime = parseExactEd25519SealedSessionRuntime(record);
-		if (!runtime || runtime.walletId !== walletId) continue;
-		if (!selectedMethodMatchesRuntime({
-			runtime,
-			authMethod
-		}) || !mpcMaterialActivationRefsEqual(runtime.sealedRecord.ed25519Restore.materialActivation, operation.value.materialActivation)) continue;
-		if (seenThresholdSessionIds.has(runtime.thresholdSessionId)) continue;
-		seenThresholdSessionIds.add(runtime.thresholdSessionId);
-		addLane(lanes, buildDiscoveredLaneForRuntime(runtime, operationCredential.walletSessionId, authorization.quotaId));
-	}
-	return lanes;
-}
-async function getLanesForWalletSession(args) {
-	const walletSessionId = normalizeSessionStatusRequired(args.walletSessionId, "walletSessionId");
-	return (await discoverLanesForWallet(args.deps, args.walletId)).filter((lane) => lane.walletSessionId === walletSessionId && lane.quotaId === args.quotaId);
-}
-function walletScopedClaimsForLanes(args) {
-	const grouped = /* @__PURE__ */ new Map();
-	for (const lane of args.lanes) {
-		const groupKey = walletSessionStatusIdentityKey({
-			walletSessionId: lane.walletSessionId,
-			quotaId: lane.quotaId
-		});
-		const group = grouped.get(groupKey) || [];
-		group.push(lane);
-		grouped.set(groupKey, group);
-	}
-	const scoped = /* @__PURE__ */ new Map();
-	for (const group of grouped.values()) {
-		const firstLane = group[0];
-		if (!firstLane) continue;
-		const walletSessionId = firstLane.walletSessionId;
-		const quotaId = firstLane.quotaId;
-		const applicableOverride = resolveApplicableWalletSessionStatusOverrideForGroup({
-			walletSessionId,
-			quotaId,
-			lanes: group,
-			claimsByThresholdSessionId: args.claimsByThresholdSessionId,
-			statusOverrides: args.statusOverrides
-		});
-		const entries = group.map((lane) => ({
-			lane,
-			claim: args.claimsByThresholdSessionId.get(lane.thresholdSessionId) || null
-		}));
-		const applyRawScopedClaims = (rawEntries) => {
-			if (!rawEntries.length) return;
-			const terminal = rawEntries.find((entry) => entry.claim?.state === "expired")?.claim || rawEntries.find((entry) => entry.claim?.state === "exhausted")?.claim || null;
-			const warmClaims = rawEntries.map((entry) => entry.claim).filter((claim) => claim?.state === "warm");
-			const walletRemainingUses = warmClaims.length ? Math.min(...warmClaims.map((claim) => Math.floor(Number(claim.remainingUses) || 0))) : void 0;
-			const walletExpiresAtMs = warmClaims.length ? Math.min(...warmClaims.map((claim) => Math.floor(Number(claim.expiresAtMs) || 0))) : void 0;
-			for (const entry of rawEntries) {
-				if (terminal) {
-					scoped.set(entry.lane.thresholdSessionId, attachWarmClaimToThresholdSession(terminal, entry.lane.thresholdSessionId));
-					continue;
-				}
-				if (entry.claim?.state === "warm") {
-					scoped.set(entry.lane.thresholdSessionId, {
-						state: "warm",
-						thresholdSessionId: entry.lane.thresholdSessionId,
-						remainingUses: walletRemainingUses ?? entry.claim.remainingUses,
-						expiresAtMs: walletExpiresAtMs ?? entry.claim.expiresAtMs
-					});
-					continue;
-				}
-				scoped.set(entry.lane.thresholdSessionId, entry.claim);
-			}
-		};
-		if (applicableOverride) {
-			const overrideClaim = claimFromWalletSessionStatusOverride(applicableOverride);
-			const overrideEntries = entries.filter((entry) => applicableOverride.thresholdSessionIds.has(normalizeNonEmpty(entry.lane.thresholdSessionId)));
-			const rawEntries = entries.filter((entry) => !applicableOverride.thresholdSessionIds.has(normalizeNonEmpty(entry.lane.thresholdSessionId)));
-			if (overrideEntries.length === entries.length) {
-				for (const entry of entries) scoped.set(entry.lane.thresholdSessionId, overrideClaim ? attachWarmClaimToThresholdSession(overrideClaim, entry.lane.thresholdSessionId) : null);
-				continue;
-			}
-			for (const entry of overrideEntries) scoped.set(entry.lane.thresholdSessionId, overrideClaim ? attachWarmClaimToThresholdSession(overrideClaim, entry.lane.thresholdSessionId) : null);
-			applyRawScopedClaims(rawEntries);
-			continue;
-		}
-		applyRawScopedClaims(entries);
-	}
-	return scoped;
-}
-function resolveApplicableWalletSessionStatusOverrideForGroup(args) {
-	const statusOverrides = args.statusOverrides;
-	if (!statusOverrides) return null;
-	for (const owner of walletSessionStatusOverrideOwnersForLanes(args.lanes)) {
-		const override = statusOverrides.get(walletOwnerSigningSessionStatusOverrideKey(owner, args.walletSessionId, args.quotaId));
-		if (!override) continue;
-		const applicable = resolveApplicableWalletSessionStatusOverride({
-			override,
-			lanes: args.lanes,
-			claimsByThresholdSessionId: args.claimsByThresholdSessionId,
-			statusOverrides
-		});
-		if (applicable) return applicable;
-	}
-	return null;
-}
-function walletSessionStatusOverrideOwnersForLanes(lanes) {
-	const ownersByKey = /* @__PURE__ */ new Map();
-	for (const lane of lanes) {
-		const owner = resolveRuntimeWalletOwnerId(lane.runtime);
-		ownersByKey.set(walletSessionStatusOwnerKey(owner), owner);
-	}
-	return [...ownersByKey.values()];
-}
-function walletOwnerSigningSessionStatusOverrideKey(owner, walletSessionId, quotaId) {
-	return `${walletSessionStatusOwnerKey(owner)}:${walletSessionStatusIdentityKey({
-		walletSessionId,
-		quotaId
-	})}`;
-}
-function resolveApplicableWalletSessionStatusOverride(args) {
-	if (!args.lanes.length) return null;
-	if (args.lanes.find((lane) => {
-		const thresholdSessionId = normalizeNonEmpty(lane.thresholdSessionId);
-		if (args.override.thresholdSessionIds.has(thresholdSessionId)) return false;
-		if (lane.runtime.sealedRecord.updatedAtMs <= args.override.updatedAtMs) return false;
-		return (args.claimsByThresholdSessionId.get(thresholdSessionId) || null)?.state === "warm";
-	})) {
-		for (const lane of args.lanes) args.statusOverrides?.delete(walletOwnerSigningSessionStatusOverrideKey(resolveRuntimeWalletOwnerId(lane.runtime), args.override.walletSessionId, args.override.quotaId));
-		return null;
-	}
-	return args.override;
-}
-function claimFromWalletSessionStatusOverride(override) {
-	const status = override.status;
-	if (status.status === "active") {
-		if (typeof status.remainingUses !== "number" || typeof status.expiresAtMs !== "number") return {
-			state: "unavailable",
-			code: "invalid_wallet_budget_status"
-		};
-		const remainingUses = Math.max(0, Math.floor(Number(status.remainingUses) || 0));
-		const expiresAtMs = Math.floor(Number(status.expiresAtMs) || 0);
-		if (expiresAtMs <= Date.now()) return { state: "expired" };
-		if (remainingUses <= 0) return { state: "exhausted" };
-		return {
-			state: "warm",
-			remainingUses,
-			expiresAtMs
-		};
-	}
-	if (status.status === "expired") return { state: "expired" };
-	if (status.status === "exhausted") return { state: "exhausted" };
-	if (status.status === "unavailable") return {
-		state: "unavailable",
-		code: String(status.statusCode || "wallet_budget_status_override")
-	};
-	return null;
-}
-async function readClaimsForLanes(args) {
-	const claims = /* @__PURE__ */ new Map();
-	for (const lane of args.lanes) claims.set(lane.thresholdSessionId, warmClaimFromRecordPolicy({
-		thresholdSessionId: lane.thresholdSessionId,
-		remainingUses: lane.runtime.remainingUses,
-		expiresAtMs: lane.runtime.expiresAtMs
-	}));
-	return claims;
-}
-function attachWarmClaimToThresholdSession(claim, thresholdSessionId) {
-	switch (claim.state) {
-		case "warm": return {
-			state: "warm",
-			thresholdSessionId,
-			remainingUses: claim.remainingUses,
-			expiresAtMs: claim.expiresAtMs
-		};
-		case "unavailable": return {
-			state: "unavailable",
-			thresholdSessionId,
-			code: claim.code
-		};
-		case "missing": return {
-			state: "missing",
-			thresholdSessionId
-		};
-		case "expired": return {
-			state: "expired",
-			thresholdSessionId
-		};
-		case "exhausted": return {
-			state: "exhausted",
-			thresholdSessionId
-		};
-	}
-}
-async function readWalletScopedLaneClaimsForWallet(args) {
-	const lanes = await discoverLanesForWallet(args.deps, args.walletId);
-	return readWalletScopedLaneClaimsForLanes({
-		deps: args.deps,
-		lanes,
-		statusOverrides: args.statusOverrides
-	});
-}
-async function readWalletScopedLaneClaimsForLanes(args) {
-	const rawClaims = await readClaimsForLanes({
-		deps: args.deps,
-		lanes: args.lanes
-	});
-	return walletScopedClaimsForLanes({
-		lanes: args.lanes,
-		claimsByThresholdSessionId: rawClaims,
-		statusOverrides: args.statusOverrides
-	});
-}
-async function readDirectSigningSessionStatusForTargets(args) {
-	const walletSessionId = args.walletSessionId;
-	const targetThresholdSessionIds = Array.from(new Set([...args.targetThresholdSessionIds || []].map(normalizeNonEmpty).filter(Boolean)));
-	if (!targetThresholdSessionIds.length) return null;
-	const touchConfirm = normalizeWarmSessionReadPorts(args.deps.touchConfirm);
-	const claims = await Promise.all(targetThresholdSessionIds.map((thresholdSessionId) => readWarmSessionClaim(touchConfirm, thresholdSessionId)));
-	return toSigningSessionStatus({
-		sessionId: walletSessionId,
-		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
-	});
-}
-function statusFromClaim(args) {
-	const hasEmailOtpLane = args.lanes.some((lane) => lane.source === SIGNER_AUTH_METHODS.emailOtp);
-	return toSigningSessionStatus({
-		sessionId: args.walletSessionId,
-		claim: args.claim,
-		authMethod: authMethodForSigningSessionLanes(args.lanes),
-		retention: hasEmailOtpLane ? "session" : null
-	});
-}
-async function clearWalletSession(args) {
-	const lanes = await getLanesForWalletSession({
-		deps: args.deps,
-		walletId: args.walletId,
-		walletSessionId: args.walletSessionId,
-		quotaId: args.quotaId
-	});
-	args.statusOverrides.delete(walletOwnerSigningSessionStatusOverrideKey(ed25519WalletSessionStatusOwner(args.walletId), args.walletSessionId, args.quotaId));
-	const cleared = /* @__PURE__ */ new Set();
-	const failures = /* @__PURE__ */ new Set();
-	for (const lane of lanes) {
-		if (lane.backing === "record_policy") continue;
-		const materialActivationId = String(lane.materialActivation.activationId);
-		if (cleared.has(materialActivationId)) continue;
-		cleared.add(materialActivationId);
-		if (lane.backing === "email_otp_worker") {
-			try {
-				await args.deps.clearEmailOtpWarmSessionMaterial?.(lane.thresholdSessionId);
-			} catch {
-				failures.add("email_otp_material");
-			}
-			continue;
-		}
-		const thresholdSessionId = parseThresholdEd25519SessionId(lane.thresholdSessionId);
-		if (!thresholdSessionId.ok) continue;
-		try {
-			await args.deps.touchConfirm?.clearVolatileWarmSessionMaterial?.(createClearVolatileWarmSessionMaterialCommand(thresholdSessionId.value));
-		} catch {
-			failures.add("touch_confirm_material");
-		}
-	}
-	if (failures.size > 0) return {
-		kind: "unavailable",
-		failures: [...failures]
-	};
-	return { kind: "cleared" };
-}
-//#endregion
-export { applyWalletSessionStatusToSigningSessionReadiness, clearWalletSession, discoverLanesForWallet, normalizeNonEmpty, readClaimsForLanes, readDirectSigningSessionStatusForTargets, readWalletScopedLaneClaimsForWallet, statusFromClaim, walletScopedClaimsForLanes, warmClaimFromRecordPolicy };
-
-//# sourceMappingURL=readiness.js.map

package/dist/esm/react/core/signingEngine/session/emailOtp/EmailOtpWalletSessionCoordinator.js

@@ -1,131 +0,0 @@
-import { createEmailOtpEcdsaSigningSessionMaterialRestorer } from "./ecdsaRecovery.js";
-import { EmailOtpEcdsaLifecycleRuntime } from "./ecdsaLifecycleRuntime.js";
-import { EmailOtpExportRecoveryRuntime } from "./exportRecoveryRuntime.js";
-import { EmailOtpRuntimeConfig } from "./runtimeConfig.js";
-import { EmailOtpSealedSessionRegistry } from "./sealedSessionRegistry.js";
-import { EmailOtpSealedRefreshPolicy } from "./sealedRefreshPolicy.js";
-import { EmailOtpSealedRestoreOrchestrator } from "./sealedRestoreOrchestrator.js";
-import { EmailOtpWarmSessionRuntime, createEmailOtpWarmSessionWorkerClient } from "./warmSessionRuntime.js";
-//#region src/core/signingEngine/session/emailOtp/EmailOtpWalletSessionCoordinator.ts
-var EmailOtpWalletSessionCoordinator = class {
-	constructor(deps) {
-		this.sealedRefreshDiagnosticLogAtMsByKey = /* @__PURE__ */ new Map();
-		this.runtimeConfig = new EmailOtpRuntimeConfig({
-			configs: deps.configs,
-			getRpId: deps.getRpId
-		});
-		this.sealedSessionRegistry = new EmailOtpSealedSessionRegistry({
-			configs: deps.configs,
-			getSignerWorkerContext: deps.getSignerWorkerContext,
-			commitEvmFamilyThresholdEcdsaSessions: deps.commitEvmFamilyThresholdEcdsaSessions,
-			listActiveEcdsaCapabilityManifestsForWallet: deps.listActiveEcdsaCapabilityManifestsForWallet,
-			writeExactSealedSession: deps.writeExactSealedSession,
-			readExactSealedSession: deps.readExactSealedSession,
-			clearEcdsaRestoreCaches: () => this.clearEcdsaRestoreCaches()
-		});
-		this.ecdsaLifecycleRuntime = new EmailOtpEcdsaLifecycleRuntime({
-			configs: deps.configs,
-			getSignerWorkerContext: deps.getSignerWorkerContext,
-			loadWalletCustodyEd25519Material: deps.loadWalletCustodyEd25519Material,
-			restoreWalletCustodyEcdsaContinuity: deps.restoreWalletCustodyEcdsaContinuity,
-			provisionThresholdEcdsaSession: deps.provisionThresholdEcdsaSession,
-			provisionEmailOtpEcdsaExplicitExportSession: deps.provisionEmailOtpEcdsaExplicitExportSession,
-			runtimeConfig: this.runtimeConfig,
-			ownerLaneScopeStores: deps.ownerLaneScopeStores,
-			resolveSelectedWalletAuthority: deps.resolveSelectedWalletAuthority,
-			resolveCurrentEcdsaCapabilityRuntime: deps.resolveCurrentEcdsaCapabilityRuntime,
-			publicationPorts: () => this.sealedSessionRegistry.ecdsaPublicationPorts()
-		});
-		this.exportRecoveryRuntime = new EmailOtpExportRecoveryRuntime({
-			getSignerWorkerContext: deps.getSignerWorkerContext,
-			requireRelayUrl: () => this.runtimeConfig.requireRelayUrl(),
-			requireSigningSessionSealGroupId: () => this.runtimeConfig.requireSigningSessionSealGroupId(),
-			resolveSelectedWalletAuthority: deps.resolveSelectedWalletAuthority,
-			prepareEcdsaExportCapability: (request) => this.ecdsaLifecycleRuntime.prepareEcdsaExportCapability(request)
-		});
-		const restoreEcdsaSigningSessionMaterialFromSealedRecord = createEmailOtpEcdsaSigningSessionMaterialRestorer({
-			configs: deps.configs,
-			withThresholdEcdsaSigningQueue: deps.withThresholdEcdsaSigningQueue,
-			getSignerWorkerContext: deps.getSignerWorkerContext,
-			resolveSelectedWalletAuthority: deps.resolveSelectedWalletAuthority,
-			readExactWalletSessionAuthorization: deps.readExactWalletSessionAuthorization,
-			provisionThresholdEcdsaSession: deps.provisionThresholdEcdsaSession,
-			commitEvmFamilyThresholdEcdsaSessions: deps.commitEvmFamilyThresholdEcdsaSessions,
-			resolveCurrentEcdsaCapabilityRuntime: deps.resolveCurrentEcdsaCapabilityRuntime
-		});
-		const warmSessionWorkerClient = createEmailOtpWarmSessionWorkerClient({ worker: deps.signerWorkerManager });
-		this.sealedRefreshPolicy = new EmailOtpSealedRefreshPolicy({
-			updateExactSealedSessionPolicy: deps.updateExactSealedSessionPolicy,
-			clearEcdsaRestoreCaches: () => this.clearEcdsaRestoreCaches()
-		});
-		this.sealedRestoreOrchestrator = new EmailOtpSealedRestoreOrchestrator({
-			sessionPersistenceMode: deps.configs.signing.sessionPersistenceMode,
-			listExactSealedSessionsForWallet: deps.listExactSealedSessionsForWallet,
-			readExactSealedSession: deps.readExactSealedSession,
-			acquireSigningSessionRestoreLease: deps.acquireSigningSessionRestoreLease,
-			releaseSigningSessionRestoreLease: deps.releaseSigningSessionRestoreLease,
-			readWarmSessionStatusFromWorker: (thresholdSessionId) => warmSessionWorkerClient.readStatus({
-				kind: "ecdsa",
-				thresholdSessionId
-			}),
-			restoreEcdsaSigningSessionMaterialFromSealedRecord: (restoreArgs) => restoreEcdsaSigningSessionMaterialFromSealedRecord(restoreArgs),
-			recordSessionMaterialRestored: (purpose, status) => this.sealedRefreshPolicy.recordSessionMaterialRestored(purpose, status),
-			shouldLogDiagnostic: (key) => this.shouldLogSealedRefreshDiagnostic(key)
-		});
-		this.warmSessionRuntime = new EmailOtpWarmSessionRuntime({
-			workerClient: warmSessionWorkerClient,
-			sealedRefreshPolicy: this.sealedRefreshPolicy,
-			sealedRestoreOrchestrator: this.sealedRestoreOrchestrator
-		});
-	}
-	async persistEcdsaSessionForRefresh(args) {
-		await this.sealedSessionRegistry.persistEcdsaSessionForRefresh(args);
-	}
-	clearEcdsaRestoreCaches() {
-		this.sealedRestoreOrchestrator.clearCache();
-	}
-	shouldLogSealedRefreshDiagnostic(key, nowMs = Date.now()) {
-		const normalizedKey = String(key || "").trim();
-		if (!normalizedKey) return false;
-		if (nowMs - (this.sealedRefreshDiagnosticLogAtMsByKey.get(normalizedKey) || 0) < 6e4) return false;
-		this.sealedRefreshDiagnosticLogAtMsByKey.set(normalizedKey, nowMs);
-		return true;
-	}
-	async discoverPersistedSessionsForWallet(args) {
-		return await this.sealedRestoreOrchestrator.discoverPersistedSessionsForWallet(args);
-	}
-	async restorePersistedSessionForSigning(args) {
-		return await this.sealedRestoreOrchestrator.restorePersistedSessionForSigning(args);
-	}
-	async readWarmSessionStatusOnly(target) {
-		return await this.warmSessionRuntime.readWarmSessionStatusOnly(target);
-	}
-	async consumeWarmSessionUses(args) {
-		return await this.warmSessionRuntime.consumeWarmSessionUses(args);
-	}
-	async clearVolatileWarmSessionMaterial(target) {
-		await this.warmSessionRuntime.clearVolatileWarmSessionMaterial(target);
-	}
-	async requestTransactionSigningChallenge(args) {
-		return await this.exportRecoveryRuntime.requestTransactionSigningChallenge(args);
-	}
-	async requestExportChallenge(args) {
-		return await this.exportRecoveryRuntime.requestExportChallenge(args);
-	}
-	async exportEcdsaKeyWithDurableAuthorization(args) {
-		return await this.exportRecoveryRuntime.exportEcdsaKeyWithDurableAuthorization(args);
-	}
-	async exportEd25519YaoSeedWithFreshEmailOtpLane(args) {
-		return await this.exportRecoveryRuntime.exportEd25519YaoSeedWithFreshEmailOtpLane(args);
-	}
-	async loginWithEcdsaCapabilityForSigning(args) {
-		return await this.ecdsaLifecycleRuntime.loginWithEcdsaCapabilityForSigning(args);
-	}
-	async loginWithEcdsaCapabilityInternal(args) {
-		return await this.ecdsaLifecycleRuntime.loginWithEcdsaCapabilityInternal(args);
-	}
-};
-//#endregion
-export { EmailOtpWalletSessionCoordinator };
-
-//# sourceMappingURL=EmailOtpWalletSessionCoordinator.js.map

package/dist/esm/react/core/signingEngine/session/emailOtp/challengeDelivery.js

@@ -1,56 +0,0 @@
-import { requireTrimmedString } from "../../../../shared-ts/src/utils/validation.js";
-//#region src/core/signingEngine/session/emailOtp/challengeDelivery.ts
-function requireDeliveryObject(value, label) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${label} must be an object`);
-	return value;
-}
-function parseDeliveryStatus(value, label) {
-	const status = requireTrimmedString(value, label);
-	switch (status) {
-		case "sent":
-		case "reused": return status;
-		default: throw new Error(`${label} must be sent or reused`);
-	}
-}
-function providerDelivery(status, emailHint) {
-	return {
-		kind: "provider",
-		status,
-		emailHint
-	};
-}
-function parseEmailOtpChallengeDelivery(value, label) {
-	const delivery = requireDeliveryObject(value, label);
-	const kind = requireTrimmedString(delivery.kind, `${label}.kind`);
-	const status = parseDeliveryStatus(delivery.status, `${label}.status`);
-	const emailHint = requireTrimmedString(delivery.emailHint, `${label}.emailHint`);
-	switch (kind) {
-		case "provider":
-		case "development":
-			if (delivery.otpCode !== void 0) throw new Error(`${label}.otpCode is only valid for code-bearing delivery`);
-			return providerDelivery(status, emailHint);
-		case "demo_code_response":
-		case "provider_and_demo_code": {
-			const otpCode = requireTrimmedString(delivery.otpCode, `${label}.otpCode`);
-			if (!/^\d{6}$/.test(otpCode)) throw new Error(`${label}.otpCode must be a 6-digit code`);
-			return {
-				kind,
-				status,
-				emailHint,
-				otpCode
-			};
-		}
-		default: throw new Error(`${label}.kind is invalid`);
-	}
-}
-function demoEmailOtpCodeFromDelivery(delivery) {
-	switch (delivery.kind) {
-		case "provider": return null;
-		case "demo_code_response":
-		case "provider_and_demo_code": return delivery.otpCode;
-	}
-}
-//#endregion
-export { demoEmailOtpCodeFromDelivery, parseEmailOtpChallengeDelivery };
-
-//# sourceMappingURL=challengeDelivery.js.map