@seams/wallet 0.7.3 → 0.8.0

package/dist/esm/react/core/signingEngine/session/material/nearEd25519YaoMaterialActivation.js

@@ -1,80 +0,0 @@
-import { mpcMaterialActivationRefsEqual, parseMpcCapabilityRuntimeRef } from "../../../../shared-ts/src/utils/domainIds.js";
-import { buildBlockedMpcCapabilityHydrationPlan, buildReauthorizePublicAnchorHydrationPlan, buildRehydrateMaterialActivationHydrationPlan, buildUseLiveRuntimeHydrationPlan } from "./mpcCapabilityHydration.js";
-//#region src/core/signingEngine/session/material/nearEd25519YaoMaterialActivation.ts
-function requireParsedDomainId(result) {
-	if (!result.ok) throw new Error(result.error.message);
-	return result.value;
-}
-function nearEd25519YaoMaterialActivationFromMetadata(metadata) {
-	return metadata.materialActivation;
-}
-function nearEd25519YaoRuntimeRef(materialActivation) {
-	return requireParsedDomainId(parseMpcCapabilityRuntimeRef(`near-ed25519-yao:${materialActivation.activationId}`));
-}
-function blockedNearHydration(input, reason) {
-	const capability = input.sealed.kind === "available" ? input.sealed.materialActivation.capability : input.runtime.kind === "live" ? input.runtime.materialActivation.capability : input.publicLocator.kind === "available" ? input.publicLocator.materialActivation.capability : null;
-	return capability ? buildBlockedMpcCapabilityHydrationPlan({
-		capability,
-		reason
-	}) : buildBlockedMpcCapabilityHydrationPlan({
-		capability: null,
-		reason: "missing_capability"
-	});
-}
-function resolveNearEd25519YaoCapabilityHydrationV1(input) {
-	switch (input.publicLocator.kind) {
-		case "missing": return buildBlockedMpcCapabilityHydrationPlan({
-			capability: null,
-			reason: "missing_capability"
-		});
-		case "retired": return buildReauthorizePublicAnchorHydrationPlan({
-			retirement: input.publicLocator.retirement,
-			publicReauthAnchor: input.publicLocator.publicReauthAnchor
-		});
-		case "conflict": return blockedNearHydration(input, "exact_record_conflict");
-		case "corrupt": return blockedNearHydration(input, "corrupt");
-		case "unavailable": return buildBlockedMpcCapabilityHydrationPlan({
-			capability: input.publicLocator.capability,
-			reason: "persistence_unavailable"
-		});
-		case "available": break;
-		default: input.publicLocator;
-	}
-	const publicMaterialActivation = input.publicLocator.materialActivation;
-	if (String(publicMaterialActivation.materialOwner) !== input.publicLocator.walletId) return blockedNearHydration(input, "binding_mismatch");
-	switch (input.runtime.kind) {
-		case "live":
-			if (!mpcMaterialActivationRefsEqual(publicMaterialActivation, input.runtime.materialActivation)) return blockedNearHydration(input, "binding_mismatch");
-			return buildUseLiveRuntimeHydrationPlan({
-				authority: input.publicLocator.authority,
-				runtime: input.runtime.runtime,
-				materialActivation: publicMaterialActivation
-			});
-		case "absent": break;
-		default: input.runtime;
-	}
-	switch (input.sealed.kind) {
-		case "missing": return blockedNearHydration(input, "missing_material");
-		case "corrupt": return blockedNearHydration(input, "corrupt");
-		case "available": break;
-		default: input.sealed;
-	}
-	const sealed = input.sealed;
-	if (String(sealed.authority.walletId) !== input.publicLocator.walletId || String(sealed.authority.authorityDigest) !== String(input.publicLocator.authority.authorityDigest) || String(sealed.materialActivation.materialOwner) !== input.publicLocator.walletId || !mpcMaterialActivationRefsEqual(sealed.materialActivation, input.publicLocator.materialActivation)) return blockedNearHydration(input, "binding_mismatch");
-	switch (input.unlockSource.kind) {
-		case "unavailable": return blockedNearHydration(input, "missing_material");
-		case "available":
-			if (String(input.unlockSource.authority.walletId) !== String(sealed.authority.walletId) || String(input.unlockSource.authority.authorityDigest) !== String(sealed.authority.authorityDigest)) return blockedNearHydration(input, "binding_mismatch");
-			return buildRehydrateMaterialActivationHydrationPlan({
-				authority: sealed.authority,
-				materialActivation: sealed.materialActivation,
-				sealedMaterial: sealed.sealedMaterial
-			});
-		default: input.unlockSource;
-	}
-	throw new Error("Unsupported Near Ed25519 unlock-source observation");
-}
-//#endregion
-export { nearEd25519YaoMaterialActivationFromMetadata, nearEd25519YaoRuntimeRef, resolveNearEd25519YaoCapabilityHydrationV1 };
-
-//# sourceMappingURL=nearEd25519YaoMaterialActivation.js.map

package/dist/esm/react/core/signingEngine/session/material/nearEd25519YaoSigningPreparation.js

@@ -1,122 +0,0 @@
-import { mpcMaterialActivationRefsEqual } from "../../../../shared-ts/src/utils/domainIds.js";
-import { activeWalletSessionV1RecordsEqual } from "../../../../shared-ts/src/device-linking/activeWalletSession.js";
-import { walletAuthAuthorityRef } from "../../../../shared-ts/src/utils/walletAuthAuthority.js";
-//#region src/core/signingEngine/session/material/nearEd25519YaoSigningPreparation.ts
-function classifyNearEd25519WalletSessionAuthorization(result) {
-	switch (result.kind) {
-		case "found": return {
-			kind: "authorized",
-			authorization: result.authorization
-		};
-		case "expired":
-		case "exhausted": return {
-			kind: "operation_step_up",
-			reason: result.kind
-		};
-		case "persistence_unavailable": return {
-			kind: "temporarily_unavailable",
-			reason: result.kind
-		};
-		case "missing":
-		case "corrupt":
-		case "upgrade_required":
-		case "superseded":
-		case "authority_unavailable":
-		case "method_unavailable":
-		case "capability_unavailable":
-		case "unavailable": return {
-			kind: "full_login_required",
-			reason: result.kind
-		};
-		default: throw new Error("[SigningEngine][near] unsupported Wallet Session authorization state");
-	}
-}
-function hydrationAuthority(hydration) {
-	switch (hydration.kind) {
-		case "use_live_runtime":
-		case "rehydrate_material_activation":
-		case "reauthorize_public_anchor": return hydration.authority;
-		case "blocked": return null;
-		default: throw new Error("[SigningEngine][near] unsupported MPC hydration plan");
-	}
-}
-function selectedAuthorityMatchesAuthMethod(args) {
-	const { selectedAuthority, selectedAuthMethod, selectedFactorAuthority } = args;
-	if (selectedAuthority.state !== "active" || selectedAuthority.walletId !== selectedAuthMethod.walletId || selectedAuthority.authorityId !== selectedAuthMethod.walletAuthorityId || selectedAuthority.signerActivations.ed25519 === void 0 || selectedFactorAuthority.walletId !== selectedAuthMethod.walletId || selectedFactorAuthority.bindingId !== selectedAuthMethod.walletAuthMethodId) return false;
-	if (selectedAuthMethod.kind === "passkey") return selectedFactorAuthority.factor.kind === "passkey" && selectedFactorAuthority.factor.credentialIdB64u === selectedAuthMethod.credentialIdB64u && selectedFactorAuthority.verifier.kind === "webauthn" && selectedFactorAuthority.verifier.rpId === selectedAuthMethod.rpId;
-	return selectedFactorAuthority.factor.kind === "email_otp" && selectedFactorAuthority.verifier.kind === "email_otp_wallet_auth_method" && selectedFactorAuthority.verifier.emailHashHex === selectedAuthMethod.emailHashHex && selectedFactorAuthority.factor.providerUserId.trim().length > 0;
-}
-function exactNearEd25519AuthorizationIdentityMatches(args) {
-	const { authorization, nowMs } = args;
-	const { selectedAuthority, selectedAuthMethod, session, operationCredential, status } = authorization;
-	if (!selectedAuthorityMatchesAuthMethod({
-		selectedAuthority,
-		selectedAuthMethod,
-		selectedFactorAuthority: authorization.selectedFactorAuthority
-	}) || session.kind !== "active_wallet_session_v1" || session.walletId !== selectedAuthority.walletId || session.authorityId !== selectedAuthority.authorityId || session.authMethodId !== selectedAuthMethod.walletAuthMethodId || session.authorityDigestB64u !== selectedAuthority.authorityDigestB64u || session.authorityRevocationEpoch !== selectedAuthority.revocationEpoch || operationCredential.kind !== "opaque_wallet_session_operation_credential_v1" || operationCredential.token.trim().length === 0 || operationCredential.walletSessionId.trim().length === 0 || session.authorizationId.trim().length === 0 || session.quotaId.trim().length === 0 || session.expiresAtMs <= nowMs || status.status !== "active" || status.walletSessionId !== operationCredential.walletSessionId || status.quotaId !== session.quotaId || status.remainingUses <= 0 || status.expiresAtMs <= nowMs || status.quotaLifecycle !== "active" || status.authorization.expiresAtMs !== session.expiresAtMs || !activeWalletSessionV1RecordsEqual(status.authorization, session)) return false;
-	return true;
-}
-/** A V6 session must carry exactly one Ed25519 signing subject for the lane. */
-function nearEd25519SessionMatchesMaterialActivation(args) {
-	let matchCount = 0;
-	for (const subject of args.session.capabilitySubjects) if (subject.kind === "sign" && subject.keyFamily === "ed25519" && mpcMaterialActivationRefsEqual(subject.materialActivation, args.materialActivation)) matchCount += 1;
-	return matchCount === 1;
-}
-async function assertAuthorizationMatchesHydration(args) {
-	const authority = hydrationAuthority(args.hydration);
-	if (!authority) return;
-	const selectedFactorAuthority = await walletAuthAuthorityRef({ authority: args.authorization.selectedFactorAuthority });
-	if (authority.walletId !== selectedFactorAuthority.walletId || authority.walletAuthMethodId !== selectedFactorAuthority.walletAuthMethodId || authority.authorityDigest !== selectedFactorAuthority.authorityDigest) throw new Error("[SigningEngine][near] Wallet Session authorization does not match material authority");
-}
-function assertAuthorizationMatchesRequirement(args) {
-	const { requirement, authorization } = args;
-	if (requirement.kind !== authorization.selectedAuthMethod.kind) throw new Error("[SigningEngine][near] Wallet Session authorization does not match material factor");
-	if (requirement.kind === "passkey") {
-		if (authorization.selectedAuthMethod.kind !== "passkey" || String(requirement.rpId) !== String(authorization.selectedAuthMethod.rpId) || requirement.credentialIdB64u !== authorization.selectedAuthMethod.credentialIdB64u) throw new Error("[SigningEngine][near] Wallet Session authorization does not match Passkey factor");
-		return;
-	}
-	if (authorization.selectedAuthMethod.kind !== "email_otp" || authorization.selectedFactorAuthority.factor.kind !== "email_otp" || requirement.providerSubjectId !== authorization.selectedFactorAuthority.factor.providerUserId) throw new Error("[SigningEngine][near] Wallet Session authorization does not match Email OTP factor");
-}
-function buildActiveNearEd25519WalletSessionAuthorization(args) {
-	if (!Number.isSafeInteger(args.nowMs) || args.nowMs < 0) throw new Error("[SigningEngine][near] Wallet Session authorization requires a valid timestamp");
-	const authorization = {
-		kind: "exact_near_ed25519_wallet_session_authorization_v1",
-		selectedAuthority: args.selectedAuthority,
-		selectedAuthMethod: args.selectedAuthMethod,
-		selectedFactorAuthority: args.selectedFactorAuthority,
-		session: args.session,
-		operationCredential: args.operationCredential,
-		status: args.status
-	};
-	if (!exactNearEd25519AuthorizationIdentityMatches({
-		authorization,
-		nowMs: args.nowMs
-	})) throw new Error("[SigningEngine][near] Exact Wallet Session authorization identity is invalid");
-	return authorization;
-}
-async function buildAuthorizedNearEd25519YaoSigningPreparation(args) {
-	assertAuthorizationMatchesRequirement(args);
-	await assertAuthorizationMatchesHydration(args);
-	return {
-		kind: "near_ed25519_yao_signing_preparation",
-		hydration: args.hydration,
-		authorization: {
-			kind: "authorized",
-			authorization: args.authorization
-		}
-	};
-}
-function buildAuthorizationRequiredNearEd25519YaoSigningPreparation(args) {
-	return {
-		kind: "near_ed25519_yao_signing_preparation",
-		hydration: args.hydration,
-		authorization: {
-			kind: "authorization_required",
-			requirement: args.requirement
-		}
-	};
-}
-//#endregion
-export { buildActiveNearEd25519WalletSessionAuthorization, buildAuthorizationRequiredNearEd25519YaoSigningPreparation, buildAuthorizedNearEd25519YaoSigningPreparation, classifyNearEd25519WalletSessionAuthorization, nearEd25519SessionMatchesMaterialActivation };
-
-//# sourceMappingURL=nearEd25519YaoSigningPreparation.js.map

package/dist/esm/react/core/signingEngine/session/material/restorableMpcMaterialRef.internal.js

@@ -1,21 +0,0 @@
-//#region src/core/signingEngine/session/material/restorableMpcMaterialRef.internal.ts
-var RestorableMpcMaterialReference = class RestorableMpcMaterialReference {
-	constructor(durableMaterialRef) {
-		this.kind = "restorable_mpc_material_ref";
-		this.protocolProof = true;
-		this.durableMaterialRef = durableMaterialRef;
-		this.protocolProof;
-	}
-	static build(durableMaterialRef) {
-		const normalized = String(durableMaterialRef || "").trim();
-		if (!normalized) throw new Error("Restorable MPC material reference is required");
-		return new RestorableMpcMaterialReference(normalized);
-	}
-};
-function buildRestorableMpcMaterialRefInternal(durableMaterialRef) {
-	return RestorableMpcMaterialReference.build(durableMaterialRef);
-}
-//#endregion
-export { buildRestorableMpcMaterialRefInternal };
-
-//# sourceMappingURL=restorableMpcMaterialRef.internal.js.map

package/dist/esm/react/core/signingEngine/session/material/walletSigningStateFailure.js

@@ -1,84 +0,0 @@
-//#region src/core/signingEngine/session/material/walletSigningStateFailure.ts
-const WALLET_SIGNING_MATERIAL_INVALID = "wallet_signing_material_invalid";
-const WALLET_FULL_LOGIN_REQUIRED = "wallet_full_login_required";
-const WALLET_SIGNING_MATERIAL_TEMPORARILY_UNAVAILABLE = "wallet_signing_material_temporarily_unavailable";
-const WALLET_OPERATION_STEP_UP_CANCELLED = "wallet_operation_step_up_cancelled";
-function classifyWalletSigningMaterialBlock(reason) {
-	switch (reason) {
-		case "missing_capability":
-		case "missing_material":
-		case "authority_ambiguous":
-		case "binding_mismatch":
-		case "exact_record_conflict":
-		case "corrupt": return {
-			kind: "invalid_material",
-			reason
-		};
-		case "revoked":
-		case "replaced": return {
-			kind: "full_login_required",
-			reason
-		};
-		case "persistence_unavailable": return {
-			kind: "temporarily_unavailable",
-			reason
-		};
-		default: throw new Error("[SigningEngine] unsupported signing material block reason");
-	}
-}
-var InvalidWalletSigningMaterialError = class extends Error {
-	constructor(reason) {
-		super("Wallet signing material is invalid. Log in again or recover the wallet.");
-		this.reason = reason;
-		this.name = "InvalidWalletSigningMaterialError";
-		this.code = WALLET_SIGNING_MATERIAL_INVALID;
-	}
-};
-var WalletFullLoginRequiredError = class extends Error {
-	constructor(reason) {
-		super("A full wallet login is required before signing.");
-		this.reason = reason;
-		this.name = "WalletFullLoginRequiredError";
-		this.code = WALLET_FULL_LOGIN_REQUIRED;
-	}
-};
-var WalletOperationStepUpCancelled = class extends Error {
-	constructor() {
-		super("Request cancelled.");
-		this.name = "WalletOperationStepUpCancelled";
-		this.code = WALLET_OPERATION_STEP_UP_CANCELLED;
-	}
-};
-var WalletSigningMaterialTemporarilyUnavailableError = class extends Error {
-	constructor() {
-		super("Wallet signing material storage is temporarily unavailable. Retry the operation.");
-		this.name = "WalletSigningMaterialTemporarilyUnavailableError";
-		this.code = WALLET_SIGNING_MATERIAL_TEMPORARILY_UNAVAILABLE;
-		this.reason = "persistence_unavailable";
-	}
-};
-function invalidWalletSigningMaterial(reason) {
-	return new InvalidWalletSigningMaterialError(reason);
-}
-function fullWalletLoginRequired(reason) {
-	return new WalletFullLoginRequiredError(reason);
-}
-function walletSigningMaterialBlockError(reason) {
-	const disposition = classifyWalletSigningMaterialBlock(reason);
-	switch (disposition.kind) {
-		case "invalid_material": return invalidWalletSigningMaterial(disposition.reason);
-		case "full_login_required": return fullWalletLoginRequired(disposition.reason);
-		case "temporarily_unavailable": return new WalletSigningMaterialTemporarilyUnavailableError();
-		default: throw new Error("[SigningEngine] unsupported signing material disposition");
-	}
-}
-function walletOperationStepUpCancelled() {
-	return new WalletOperationStepUpCancelled();
-}
-function isWalletSigningStateFailure(error) {
-	return error instanceof InvalidWalletSigningMaterialError || error instanceof WalletFullLoginRequiredError || error instanceof WalletOperationStepUpCancelled;
-}
-//#endregion
-export { fullWalletLoginRequired, invalidWalletSigningMaterial, isWalletSigningStateFailure, walletOperationStepUpCancelled, walletSigningMaterialBlockError };
-
-//# sourceMappingURL=walletSigningStateFailure.js.map

package/dist/esm/react/core/signingEngine/session/operationState/authorizationAdmission.js

@@ -1,98 +0,0 @@
-//#region src/core/signingEngine/session/operationState/authorizationAdmission.ts
-const WALLET_SESSION_QUOTA_EXHAUSTED_ERROR = "[WalletSessionQuotaAdmission] wallet-session quota is exhausted";
-const WALLET_SESSION_QUOTA_IN_FLIGHT_ERROR = "[WalletSessionQuotaAdmission] wallet-session quota is reserved by an in-flight operation";
-var WalletSessionQuotaAdmissionError = class extends Error {
-	constructor(failure, authorizationDecision) {
-		super(walletSessionQuotaAdmissionFailureMessage(failure));
-		this.name = "WalletSessionQuotaAdmissionError";
-		this.failure = failure;
-		this.authorizationDecision = authorizationDecision;
-	}
-};
-function isWalletSessionQuotaAdmissionError(error) {
-	return error instanceof WalletSessionQuotaAdmissionError;
-}
-function walletSessionQuotaAdmissionFailureMessage(failure) {
-	switch (failure.kind) {
-		case "exhausted": return `${WALLET_SESSION_QUOTA_EXHAUSTED_ERROR}: ${failure.detail}`;
-		case "in_flight": return `${WALLET_SESSION_QUOTA_IN_FLIGHT_ERROR}: ${failure.detail}`;
-		case "stale_projection": return `${WALLET_SESSION_QUOTA_EXHAUSTED_ERROR}: stale projection ${failure.localProjectionVersion} -> ${failure.serverProjectionVersion}: ${failure.detail}`;
-	}
-}
-function classifyWalletSessionQuotaAdmissionFailure(error) {
-	if (isWalletSessionQuotaAdmissionError(error)) return error.failure;
-	const message = error instanceof Error ? error.message : String(error || "");
-	if (message.includes(WALLET_SESSION_QUOTA_IN_FLIGHT_ERROR)) return {
-		kind: "in_flight",
-		source: "local_projection",
-		detail: message || WALLET_SESSION_QUOTA_IN_FLIGHT_ERROR,
-		retryAfterMs: 150
-	};
-	if (message.includes(WALLET_SESSION_QUOTA_EXHAUSTED_ERROR)) return {
-		kind: "exhausted",
-		source: "local_projection",
-		detail: message || WALLET_SESSION_QUOTA_EXHAUSTED_ERROR
-	};
-	return null;
-}
-function decideWalletSessionQuotaAdmissionFailure(failure) {
-	switch (failure.kind) {
-		case "in_flight": return {
-			kind: "wait_and_retry_admission",
-			retryAfterMs: failure.retryAfterMs,
-			failure
-		};
-		case "exhausted": return {
-			kind: "request_fresh_step_up",
-			reason: "exhausted",
-			failure
-		};
-		case "stale_projection": return {
-			kind: "request_fresh_step_up",
-			reason: "stale_projection",
-			failure
-		};
-	}
-}
-function buildWalletSessionQuotaAdmissionQueueKey(args) {
-	const walletId = normalizeQueueKeyPart(args.walletId, "wallet");
-	const walletSessionId = normalizeQueueKeyPart(args.walletSessionId, "wallet session");
-	const quotaId = normalizeQueueKeyPart(args.quotaId, "quota");
-	const projectionVersion = normalizeQueueKeyPart(args.projectionVersion, "projection");
-	const authorityKey = normalizeQueueKeyPart(args.authorityKey, "authority");
-	const targetKey = normalizeQueueKeyPart(args.targetKey, "target");
-	return [
-		"wallet-session-quota-admission",
-		walletId,
-		args.curve,
-		walletSessionId,
-		quotaId,
-		projectionVersion,
-		authorityKey,
-		targetKey
-	].join(":");
-}
-function buildOperationAuthorizationQueueKey(args) {
-	return [
-		"operation-authorization",
-		normalizeQueueKeyPart(args.walletId, "wallet"),
-		normalizeQueueKeyPart(args.materialActivationId, "activation"),
-		normalizeQueueKeyPart(args.authorizationId, "authorization"),
-		normalizeQueueKeyPart(args.authorityKey, "authority"),
-		normalizeQueueKeyPart(args.targetKey, "target")
-	].join(":");
-}
-async function waitForWalletSessionQuotaAdmissionRetry(retryAfterMs) {
-	const delayMs = Math.max(0, Math.floor(Number(retryAfterMs) || 0));
-	if (delayMs <= 0) return;
-	await new Promise((resolve) => setTimeout(resolve, delayMs));
-}
-function normalizeQueueKeyPart(value, label) {
-	const normalized = String(value || "").trim();
-	if (!normalized) throw new Error(`[WalletSessionQuotaAdmission] ${label} is required for admission queue key`);
-	return normalized;
-}
-//#endregion
-export { WalletSessionQuotaAdmissionError, buildOperationAuthorizationQueueKey, buildWalletSessionQuotaAdmissionQueueKey, classifyWalletSessionQuotaAdmissionFailure, decideWalletSessionQuotaAdmissionFailure, waitForWalletSessionQuotaAdmissionRetry };
-
-//# sourceMappingURL=authorizationAdmission.js.map

package/dist/esm/react/core/signingEngine/session/operationState/lanes.js

@@ -1,127 +0,0 @@
-import { selectedEcdsaLane, selectedEd25519Lane } from "../identity/laneIdentity.js";
-//#region src/core/signingEngine/session/operationState/lanes.ts
-function buildEd25519PasskeySigningLane(input) {
-	return buildSigningLane({
-		...selectedEd25519Lane({
-			walletId: input.walletId,
-			nearAccountId: input.nearAccountId,
-			nearEd25519SigningKeyId: input.nearEd25519SigningKeyId,
-			signerSlot: input.signerSlot,
-			auth: input.auth,
-			walletSessionId: input.walletSessionId,
-			quotaId: input.quotaId,
-			thresholdSessionId: input.thresholdSessionId
-		}),
-		keyKind: "threshold_ed25519",
-		chainFamily: "near",
-		storageSource: input.storageSource,
-		sessionOrigin: input.sessionOrigin || signingSessionOriginFromStorageSource(input.storageSource),
-		...input.retention ? { retention: input.retention } : {}
-	});
-}
-function buildEd25519EmailOtpSigningLane(input) {
-	return buildSigningLane({
-		...selectedEd25519Lane({
-			walletId: input.walletId,
-			nearAccountId: input.nearAccountId,
-			nearEd25519SigningKeyId: input.nearEd25519SigningKeyId,
-			signerSlot: input.signerSlot,
-			auth: input.auth,
-			walletSessionId: input.walletSessionId,
-			quotaId: input.quotaId,
-			thresholdSessionId: input.thresholdSessionId
-		}),
-		keyKind: "threshold_ed25519",
-		chainFamily: "near",
-		storageSource: "email_otp",
-		sessionOrigin: input.sessionOrigin || "per_operation",
-		...input.retention ? { retention: input.retention } : {}
-	});
-}
-function buildEcdsaPasskeySigningLane(input) {
-	return buildSigningLane({
-		...selectedEcdsaLane({
-			key: input.key,
-			materialActivation: input.materialActivation,
-			keyHandle: input.keyHandle,
-			walletId: input.walletId,
-			auth: input.auth,
-			authorization: input.authorization,
-			chainTarget: input.chainTarget
-		}),
-		keyKind: "threshold_ecdsa_secp256k1",
-		chainFamily: input.chainTarget.kind,
-		storageSource: input.storageSource,
-		sessionOrigin: input.sessionOrigin || signingSessionOriginFromStorageSource(input.storageSource),
-		...input.retention ? { retention: input.retention } : {}
-	});
-}
-function buildEcdsaEmailOtpSigningLane(input) {
-	return buildSigningLane({
-		...selectedEcdsaLane({
-			key: input.key,
-			materialActivation: input.materialActivation,
-			keyHandle: input.keyHandle,
-			walletId: input.walletId,
-			auth: input.auth,
-			authorization: input.authorization,
-			chainTarget: input.chainTarget
-		}),
-		keyKind: "threshold_ecdsa_secp256k1",
-		chainFamily: input.chainTarget.kind,
-		storageSource: "email_otp",
-		sessionOrigin: input.sessionOrigin || "per_operation",
-		...input.retention ? { retention: input.retention } : {}
-	});
-}
-function buildNearTransactionSigningLane(input) {
-	if (isEd25519EmailOtpTransactionSigningLaneInput(input)) return buildEd25519EmailOtpSigningLane(input);
-	if (isEd25519PasskeyTransactionSigningLaneInput(input)) return buildEd25519PasskeySigningLane(input);
-	throw new Error("[SigningSession] unsupported NEAR lane auth");
-}
-function buildTempoTransactionSigningLane(input) {
-	if (input.chainTarget.kind !== "tempo") throw new Error("Tempo ECDSA transaction lane requires a Tempo chain target");
-	return buildEcdsaTransactionSigningLane(input);
-}
-function buildEvmTransactionSigningLane(input) {
-	if (input.chainTarget.kind !== "evm") throw new Error("EVM ECDSA transaction lane requires an EIP-155 chain target");
-	return buildEcdsaTransactionSigningLane(input);
-}
-function buildEcdsaTransactionSigningLane(input) {
-	if (isEcdsaEmailOtpTransactionSigningLaneInput(input)) return buildEcdsaEmailOtpSigningLane(input);
-	if (isEcdsaPasskeyTransactionSigningLaneInput(input)) return buildEcdsaPasskeySigningLane(input);
-	throw new Error("[SigningSession] unsupported ECDSA lane auth");
-}
-function isEd25519PasskeyTransactionSigningLaneInput(input) {
-	return input.auth.kind === "passkey";
-}
-function isEd25519EmailOtpTransactionSigningLaneInput(input) {
-	return input.auth.kind === "email_otp";
-}
-function isEcdsaPasskeyTransactionSigningLaneInput(input) {
-	return input.auth.kind === "passkey";
-}
-function isEcdsaEmailOtpTransactionSigningLaneInput(input) {
-	return input.auth.kind === "email_otp";
-}
-function buildSigningLane(input) {
-	return {
-		...input,
-		retention: input.retention || "session"
-	};
-}
-function signingSessionOriginFromStorageSource(source) {
-	switch (source) {
-		case "login": return "login";
-		case "registration": return "registration";
-		case "add-signer": return "add_signer";
-		case "manual-bootstrap": return "manual_bootstrap";
-		case "manual-connect": return "manual_connect";
-		case "bootstrap": return "bootstrap";
-		case "sealed_restore": return "sealed_restore";
-	}
-}
-//#endregion
-export { buildEvmTransactionSigningLane, buildNearTransactionSigningLane, buildTempoTransactionSigningLane };
-
-//# sourceMappingURL=lanes.js.map

package/dist/esm/react/core/signingEngine/session/operationState/preparedOperation.js

@@ -1,38 +0,0 @@
-import { signingLaneAuthMethod } from "../identity/signingLaneAuthBinding.js";
-//#region src/core/signingEngine/session/operationState/preparedOperation.ts
-async function prepareThresholdSigningOperation(args) {
-	const lifecycle = await args.lifecycleAdapter.prepare({
-		intent: args.intent,
-		...args.operation ? { operation: args.operation } : {}
-	});
-	if (lifecycle.lane.curve !== lifecycle.readiness.readiness.curve) throw new Error("[SigningSession] prepared lane and readiness curves do not match");
-	const coordinatorInput = {
-		lane: lifecycle.lane,
-		readiness: lifecycle.readiness.readiness,
-		expiresAtMs: lifecycle.readiness.expiresAtMs,
-		remainingUses: lifecycle.readiness.remainingUses,
-		usesNeeded: lifecycle.readiness.usesNeeded,
-		...lifecycle.readiness.trustedStatusAuth ? { trustedStatusAuth: lifecycle.readiness.trustedStatusAuth } : {},
-		forceFreshAuth: args.forceFreshAuth || lifecycle.forceFreshAuth,
-		sensitiveOperationPolicy: args.sensitiveOperationPolicy,
-		missingWhenExpiresAtMissing: args.missingWhenExpiresAtMissing
-	};
-	const resolved = await args.coordinator.resolveAuthPlanFromReadiness(coordinatorInput, args.onPlannerTrace);
-	return {
-		intent: args.intent,
-		...args.operation ? { operation: args.operation } : {},
-		lane: lifecycle.lane,
-		authMethod: signingLaneAuthMethod(lifecycle.lane.auth),
-		signingSessionPlan: resolved.signingSessionPlan,
-		readiness: resolved.readiness,
-		expiresAtMs: resolved.expiresAtMs,
-		remainingUses: resolved.remainingUses,
-		...lifecycle.readiness.trustedStatusAuth ? { trustedStatusAuth: lifecycle.readiness.trustedStatusAuth } : {},
-		availableLanesGeneration: Math.max(0, Math.floor(Number(lifecycle.availableLanesGeneration) || 0)),
-		metadata: lifecycle.metadata || {}
-	};
-}
-//#endregion
-export { prepareThresholdSigningOperation };
-
-//# sourceMappingURL=preparedOperation.js.map

package/dist/esm/react/core/signingEngine/session/operationState/trace.js

@@ -1,94 +0,0 @@
-import { summarizeSigningLane } from "./types.js";
-import { parseEcdsaServerTiming } from "../../../../shared-ts/src/utils/ecdsaServerTiming.js";
-//#region src/core/signingEngine/session/operationState/trace.ts
-function emitEcdsaServerTiming(operationId, phase, header) {
-	if (!header || !isSigningSessionTraceEnabled()) return;
-	for (const [stage, durationMs] of parseEcdsaServerTiming(header)) emitSigningSessionFlowTrace("evm-family", {
-		event: "ecdsa_server_timing",
-		operationId,
-		phase,
-		stage,
-		durationMs
-	});
-}
-function emitEcdsaPresignServerTiming(presignSessionId, phase, header) {
-	if (!header || !isSigningSessionTraceEnabled()) return;
-	for (const [stage, durationMs] of parseEcdsaServerTiming(header)) emitSigningSessionFlowTrace("evm-family", {
-		event: "ecdsa_presign_server_timing",
-		presignSessionId,
-		phase,
-		stage,
-		durationMs
-	});
-}
-function emitEcdsaSigningTiming(operationId, stage, startedAt, outcome = "succeeded") {
-	emitSigningSessionFlowTrace("evm-family", {
-		event: "ecdsa_signing_timing",
-		operationId,
-		stage,
-		durationMs: Math.max(0, performance.now() - startedAt),
-		outcome
-	});
-}
-function emitEd25519SigningTiming(operationId, stage, startedAt, outcome = "succeeded") {
-	emitSigningSessionFlowTrace("near", {
-		event: "ed25519_signing_timing",
-		operationId,
-		stage,
-		durationMs: Math.max(0, performance.now() - startedAt),
-		outcome
-	});
-}
-function emitSigningLaneResolutionTrace(scope, lane, args = {}) {
-	if (!lane || !isSigningSessionTraceEnabled()) return;
-	try {
-		console.debug(`[SigningLane][${scope}]`, {
-			event: "signing_lane_resolved",
-			lane: summarizeSigningLane(lane),
-			...args.reason ? { reason: args.reason } : {}
-		});
-	} catch {}
-}
-function emitSigningBoundaryTrace(scope, event) {
-	if (!isSigningSessionTraceEnabled()) return;
-	try {
-		console.debug(`[SigningBoundary][${scope}]`, event);
-	} catch {}
-}
-function createSigningBoundaryTraceEvent(args) {
-	return {
-		event: args.event,
-		...args.lane ? { lane: summarizeSigningLane(args.lane) } : {},
-		...args.readinessStatus ? { readinessStatus: args.readinessStatus } : {},
-		...args.sideEffect ? { sideEffect: args.sideEffect } : {},
-		phase: args.phase
-	};
-}
-function emitSigningPlannerDecisionTrace(scope, event) {
-	if (!isSigningSessionTraceEnabled()) return;
-	try {
-		console.debug(`[SigningSessionPlanner][${scope}]`, event);
-	} catch {}
-}
-function emitSigningSessionFlowTrace(scope, event) {
-	if (!isSigningSessionTraceEnabled()) return;
-	try {
-		console.info(`[SigningFlow][${scope}]`, JSON.stringify(event));
-	} catch {}
-}
-function emitSigningSessionFlowFailure(scope, event) {
-	try {
-		console.warn(`[SigningFlow][${scope}][failure]`, event);
-	} catch {}
-}
-function isSigningSessionTraceEnabled() {
-	try {
-		return globalThis.localStorage?.getItem("seams:debug:signing-session") === "1";
-	} catch {
-		return false;
-	}
-}
-//#endregion
-export { createSigningBoundaryTraceEvent, emitEcdsaPresignServerTiming, emitEcdsaServerTiming, emitEcdsaSigningTiming, emitEd25519SigningTiming, emitSigningBoundaryTrace, emitSigningLaneResolutionTrace, emitSigningPlannerDecisionTrace, emitSigningSessionFlowFailure, emitSigningSessionFlowTrace };
-
-//# sourceMappingURL=trace.js.map