@seams/wallet 0.6.1 → 0.7.1

package/dist/{esm/sdk/ed25519SeedMaterial-Cghz8-XB.js → public/sdk/walletCustodyEcdsaContinuity-Hn4ORIbf.js}

@@ -1,27 +1,29 @@
-import { B as parseWalletRecoveryOperationId, E as parseMpcMaterialOwnerRef, F as parseWalletAuthMethodId, H as parseWebAuthnRpId, L as parseWalletAuthorityId, M as parseThresholdEd25519SessionId, P as parseVerifiedEmailAddress, R as parseWalletId, T as parseMpcMaterialActivationRef, V as parseWebAuthnCredentialIdB64u, _ as parseEmailOtpProviderUserId, c as normalizeTrimmedString, f as hasWhitespaceOrControlCharacters, g as parseEmailOtpChallengeId, m as parseCapabilityInstanceRef, p as mpcMaterialActivationRefsEqual, r as normalizeFiniteNumber, z as parseWalletKeyId } from "./normalize-BephcEIF.js";
+import { A as parseWalletRecoveryOperationId, B as normalizeTrimmedString, D as parseWalletAuthorityId, F as normalizeFiniteNumber, M as parseWebAuthnRpId, O as parseWalletId, S as parseThresholdEd25519SessionId, T as parseWalletAuthMethodId, g as parseMpcMaterialOwnerRef, h as parseMpcMaterialActivationRef, i as parseCapabilityInstanceRef, j as parseWebAuthnCredentialIdB64u, k as parseWalletKeyId, n as hasWhitespaceOrControlCharacters, o as parseEmailOtpChallengeId, r as mpcMaterialActivationRefsEqual, s as parseEmailOtpProviderUserId, w as parseVerifiedEmailAddress } from "./domainIds-lcrFg6Sa.js";
+import { _ as requireRecord, h as requireCanonicalString, m as requireArray } from "./validation-gat4LEKm.js";
 import { i as base64UrlEncode, r as base64UrlDecode } from "./base64-Clm8C-e9.js";
 import { r as secureRandomId } from "./secureRandomId-BORsmdS4.js";
-import { u as walletSessionPreservesCapabilities } from "./device-linking-DpVGjSeq.js";
-import { A as alphabetizeStringify, D as sameWalletAuthMethodRecordV2, F as parseCorrelationId, I as parseDigestB64u, L as parseIsoTimestamp, M as sha256BytesUtf8, N as sha256HexUtf8, b as parseWalletAuthMethodRecordV2, j as sha256Bytes, k as walletIdFromString, m as nearEd25519SigningKeyIdFromString } from "./registrationIntent-DwAIMQYh.js";
-import { a as thresholdEcdsaChainTargetFromRequest, c as toWalletId } from "./ecdsaChainTarget-BOTPGIU_.js";
-import { r as SIGNER_KINDS } from "./signerDomain-DDLiwuYS.js";
-import { a as toIndexedDbChainTargetKey, i as normalizeLastUserScope, n as normalizeIndexedDbAccountModel, r as normalizeIndexedDbChainIdKey, t as normalizeIndexedDbAccountAddress } from "./normalization-oJyXl3Vn.js";
-import { _ as SEAMS_WALLET_INDEXES, f as parseRecoveryCodeReservationId, g as SEAMS_WALLET_DB_NAME, h as seamsWalletDB, u as parseWalletRecoveryCommittedProjectionV1, v as SEAMS_WALLET_STORES } from "./wallet-recovery-CKqoHbxT.js";
-import { d as parseEd25519PublicKeyB64u, o as normalizeRuntimePolicyScope } from "./participants-Bcnsa_ip.js";
-import { B as buildNearProfileId, L as buildEnvelopeAAD, M as WALLET_CUSTODY_ED25519_MATERIAL_KEY_KIND, N as assertWalletCustodyEd25519MaterialBindingV1, P as buildWalletCustodyEd25519MaterialRecordV1, R as normalizePayloadEnvelope, z as sanitizePayload } from "./accountLifecycle-Ddavc_FC.js";
-import { t as toAccountId } from "./accountIds-Ck4GAQfm.js";
-import { D as sameDelegatedWalletAuthorityV1, f as encodeWalletSignerActivationSetV1, h as isActiveRecoveredWalletAuthorityV1, m as isActiveEcdsaWalletAuthorityV1, o as normalizeThresholdRuntimePolicyScope, p as extendEcdsaWalletAuthorityWithEd25519, v as parseWalletAuthorityV1, x as walletAuthorityDigestsMatchV1 } from "./sessionPolicy-B4FsPuk2.js";
-import { Bt as parseWalletAuthAuthorityRef, Cn as routerAbMpcMaterialActivationRefToWire, Dt as sameRouterAbEcdsaRegistrationActivationReceiptV1, Ft as isEmailOtpWalletAuthAuthority, I as parseLocalAuthorityInstallationReceiptV1, It as isPasskeyWalletAuthAuthority, Lt as parseEmailOtpWalletAuthAuthority, R as parseWalletSessionOperationCredentialV1, Sn as routerAbMpcMaterialActivationRefFromWire, Tt as sameRouterAbEcdsaDerivationPublicCapabilityV1, V as parseLinkedDeviceEcdsaSourcePreservingActivationReceiptV1, Vt as walletAuthAuthoritiesMatch, _n as sameRouterAbEd25519YaoActivationBindingV1, _t as requireRouterAbEcdsaDerivationNormalSigningStateV1, en as parseRouterAbEd25519YaoActivationPublicReceiptV1, fn as parseRouterAbEd25519YaoRegistrationActivationAdmissionReceiptV1, ft as parseRouterAbEcdsaRegistrationActivationReceiptV1, gt as parseRouterAbEcdsaVerifiedClientActivationFactsV1, hn as parseRouterAbEd25519YaoRegistrationAdmissionRequestV1, it as parseRouterAbEcdsaDerivationPublicCapabilityV1, nn as parseRouterAbEd25519YaoCeremonyBindingV1, on as parseRouterAbEd25519YaoParticipantIdsV1, pn as parseRouterAbEd25519YaoRegistrationActivationExecuteRequestV1, tn as parseRouterAbEd25519YaoApplicationBindingFactsV1, wt as sameRouterAbEcdsaDerivationNormalSigningStateV1, xt as routerAbEcdsaDerivationNormalSigningScopeCanonicalBytesV1, yn as canonicalRouterAbMpcMaterialActivationRefBytes, zt as parseWalletAuthAuthority } from "./ecdsaPresignLifecycle-CnSnzoRJ.js";
-import { d as parseMpcWalletSigningQuotaId, h as parseWalletSessionId, l as parseDeviceId, m as parseWalletSessionAuthorizationId } from "./capabilityKinds-jwCEaqBU.js";
-import { _t as parseEvmFamilyEcdsaSignerId, b as toParticipantId, bt as parseSdkEcdsaDerivationSigningRootId, ct as parseEcdsaCapabilityManifestId, dt as parseEcdsaCiphertextDigest, ft as parseEcdsaIv12B64u, gt as parseEcdsaServerGeneration, ht as parseEcdsaPendingCiphertextDigest, l as buildVerifiedEcdsaPublicFacts, lt as parseEcdsaCapabilityManifestRevision, mt as parseEcdsaMaterialSealingKeyId, ot as parseCanonicalEcdsaServerActivationRequest, ut as parseEcdsaCiphertextB64u, x as toRpId, xt as parseSdkEcdsaDerivationSigningRootVersion, y as toEvmFamilyEcdsaKeyHandle } from "./evmFamilyEcdsaIdentity-_kuKSW35.js";
-import { d as parsePasskeyCustodyEnvelopeRecord, p as sameWalletCustodyEnvelopeOwnership } from "./passkey-custody-BaHyYMhj.js";
-import { a as parseEcdsaRelayerKeyId, d as parseEcdsaThresholdKeyId, i as parseEcdsaKeyHandle, l as parseEcdsaRoleLocalPersistedMaterialRef, n as parseEcdsaClientVerifyingPublicKey33B64u, o as parseEcdsaRoleLocalBindingDigest, s as parseEcdsaRoleLocalDurableMaterialRef } from "./keyMaterialBrands-BbjCfzXv.js";
-import { v as parseNearProvisioningState } from "./sdkSentEvents-5Pi-hjHB.js";
-import { t as parseSignerSlot } from "./signerSlot-DbNAs-kc.js";
-import { S as buildEcdsaRoleLocalPublicFacts, _ as buildServerCommittedEcdsaActivationJournal, a as buildEcdsaManifestIdentity, c as buildEncryptedEcdsaPendingCandidate, d as buildNoCurrentEcdsaManifestExpectation, f as buildNoCurrentEcdsaServerGenerationExpectation, g as buildReplacedEcdsaCapabilityManifest, h as buildPreparedEvmFamilySigner, i as buildEcdsaCapabilityScope, l as buildExactEcdsaManifestExpectation, m as buildPreparedEcdsaActivationJournal, n as buildDurableEcdsaMaterialBinding, o as buildEcdsaRoleLocalMaterialBinding, p as buildPreparedEcdsaActivationCandidate, r as buildEcdsaActivationBinding, s as buildEcdsaServerActivationCommit, t as buildActiveEcdsaCapabilityManifest, u as buildExactEcdsaServerGenerationExpectation, v as buildValidatedEncryptedEcdsaReadyMaterial } from "./ecdsaCapabilityManifest-C8itxV9S.js";
-import { i as parseEcdsaClientPresignPoolIdentity, n as ecdsaClientPresignPoolKey, r as equalEcdsaClientPresignPoolIdentity } from "./ecdsaPresignPoolIdentity-Yopr4jvS.js";
-import { _ as NonceCoordinatorDegradationReason, b as NonceDurableLeaseState, u as nonceLaneKey, v as NonceCoordinatorFallback } from "./nonceLaneKeys-B_RcSS6M.js";
-import { i as buildNearAccountRefs, n as resolveProfileAccountContextFromCandidates } from "./profileAccountProjection-C9rVhbeJ.js";
+import { M as sameDelegatedWalletAuthorityV1, b as parseEd25519PublicKeyB64u, h as normalizeRuntimePolicyScope, o as normalizeThresholdRuntimePolicyScope } from "./sessionPolicy-CHiilOAB.js";
+import { $ as parseWalletAuthAuthority, A as parseRouterAbEcdsaVerifiedClientActivationFactsV1, At as walletSessionPreservesCapabilities, Ct as routerAbMpcMaterialActivationRefFromWire, E as parseRouterAbEcdsaRegistrationActivationReceiptV1, F as routerAbEcdsaDerivationNormalSigningScopeCanonicalBytesV1, R as sameRouterAbEcdsaDerivationNormalSigningStateV1, V as sameRouterAbEcdsaRegistrationActivationReceiptV1, X as isPasskeyWalletAuthAuthority, Y as isEmailOtpWalletAuthAuthority, Z as parseEmailOtpWalletAuthAuthority, _t as parseSdkEcdsaDerivationSigningRootId, at as parseEcdsaCapabilityManifestId, bt as canonicalRouterAbMpcMaterialActivationRefBytes, ct as parseEcdsaCiphertextDigest, dt as parseEcdsaMaterialSealingKeyId, et as parseWalletAuthAuthorityRef, ft as parseEcdsaPendingCiphertextDigest, j as requireRouterAbEcdsaDerivationNormalSigningStateV1, kt as parseWalletSessionOperationCredentialV1, lt as parseEcdsaIv12B64u, mt as parseEvmFamilyEcdsaSignerId, ot as parseEcdsaCapabilityManifestRevision, pt as parseEcdsaServerGeneration, rt as parseCanonicalEcdsaServerActivationRequest, st as parseEcdsaCiphertextB64u, tt as walletAuthAuthoritiesMatch, v as parseRouterAbEcdsaDerivationPublicCapabilityV1, vt as parseSdkEcdsaDerivationSigningRootVersion, wt as routerAbMpcMaterialActivationRefToWire, z as sameRouterAbEcdsaDerivationPublicCapabilityV1 } from "./ecdsaPresignLifecycle-BFOTNYCK.js";
+import { d as parseMpcWalletSigningQuotaId, h as parseWalletSessionId, l as parseDeviceId, m as parseWalletSessionAuthorizationId } from "./capabilityKinds-hvYqa6S_.js";
+import { f as alphabetizeStringify, h as sha256HexUtf8, m as sha256BytesUtf8, p as sha256Bytes } from "./chains-BMh3btVo.js";
+import { a as sha256DigestB64u, i as parseIsoTimestamp, n as parseCorrelationId, r as parseDigestB64u } from "./canonicalPrimitives-BTHWz80v.js";
+import { a as thresholdEcdsaChainTargetFromRequest, c as toWalletId } from "./ecdsaChainTarget-Bl-JWyuw.js";
+import { r as SIGNER_KINDS } from "./signerDomain-IEAVrOrc.js";
+import { a as toIndexedDbChainTargetKey, i as normalizeLastUserScope, n as normalizeIndexedDbAccountModel, r as normalizeIndexedDbChainIdKey, t as normalizeIndexedDbAccountAddress } from "./normalization-CBt413-z.js";
+import { _ as SEAMS_WALLET_INDEXES, f as parseRecoveryCodeReservationId, g as SEAMS_WALLET_DB_NAME, h as seamsWalletDB, u as parseWalletRecoveryCommittedProjectionV1, v as SEAMS_WALLET_STORES } from "./wallet-recovery-Bz9qKgaL.js";
+import { B as buildNearProfileId, L as buildEnvelopeAAD, M as WALLET_CUSTODY_ED25519_MATERIAL_KEY_KIND, N as assertWalletCustodyEd25519MaterialBindingV1, P as buildWalletCustodyEd25519MaterialRecordV1, R as normalizePayloadEnvelope, z as sanitizePayload } from "./accountLifecycle-BAGG_rbk.js";
+import { t as toAccountId } from "./accountIds-DhIPGOSN.js";
+import { Jt as parseRouterAbEd25519YaoCeremonyBindingV1, Kt as parseRouterAbEd25519YaoActivationPublicReceiptV1, Mt as parseLinkedDeviceEcdsaSourcePreservingActivationReceiptV1, Qt as parseRouterAbEd25519YaoParticipantIdsV1, Y as parseLocalAuthorityInstallationReceiptV1, an as parseRouterAbEd25519YaoRegistrationActivationExecuteRequestV1, b as toParticipantId, in as parseRouterAbEd25519YaoRegistrationActivationAdmissionReceiptV1, l as buildVerifiedEcdsaPublicFacts, ln as sameRouterAbEd25519YaoActivationBindingV1, qt as parseRouterAbEd25519YaoApplicationBindingFactsV1, sn as parseRouterAbEd25519YaoRegistrationAdmissionRequestV1, x as toRpId, y as toEvmFamilyEcdsaKeyHandle } from "./evmFamilyEcdsaIdentity-Co5XDcEA.js";
+import { T as sameWalletAuthMethodRecordV2, a as isActiveEcdsaWalletAuthorityV1, c as isEcdsaExtensionOfEd25519WalletAuthority, i as extendEcdsaWalletAuthorityWithEd25519, m as walletAuthorityDigestsMatchV1, o as isActiveRecoveredWalletAuthorityV1, r as encodeWalletSignerActivationSetV1, u as parseWalletAuthorityV1, w as parseWalletAuthMethodRecordV2 } from "./walletAuthority-BQBxgUBn.js";
+import { i as nearEd25519SigningKeyIdFromString, o as walletIdFromString } from "./registrationIds-DLSdEKSv.js";
+import { d as parsePasskeyCustodyEnvelopeRecord, p as sameWalletCustodyEnvelopeOwnership } from "./passkey-custody-Bk1jAknm.js";
+import { a as parseEcdsaRoleLocalPersistedMaterialRef, d as parseEcdsaRelayerKeyId, n as parseEcdsaRoleLocalBindingDigest, r as parseEcdsaRoleLocalDurableMaterialRef, s as parseEcdsaThresholdKeyId, t as parseEcdsaClientVerifyingPublicKey33B64u, u as parseEcdsaKeyHandle } from "./keyMaterialBrands-CX41hur6.js";
+import { v as parseNearProvisioningState } from "./sdkSentEvents-MqDkbQg1.js";
+import { t as parseSignerSlot } from "./signerSlot-_ovonwVX.js";
+import { C as buildEcdsaRoleLocalPublicFacts, _ as buildServerCommittedEcdsaActivationJournal, a as buildEcdsaManifestIdentity, b as unwrapDomainId, c as buildEncryptedEcdsaPendingCandidate, d as buildNoCurrentEcdsaManifestExpectation, f as buildNoCurrentEcdsaServerGenerationExpectation, g as buildReplacedEcdsaCapabilityManifest, h as buildPreparedEvmFamilySigner, i as buildEcdsaCapabilityScope, l as buildExactEcdsaManifestExpectation, m as buildPreparedEcdsaActivationJournal, n as buildDurableEcdsaMaterialBinding, o as buildEcdsaRoleLocalMaterialBinding, p as buildPreparedEcdsaActivationCandidate, r as buildEcdsaActivationBinding, s as buildEcdsaServerActivationCommit, t as buildActiveEcdsaCapabilityManifest, u as buildExactEcdsaServerGenerationExpectation, v as buildValidatedEncryptedEcdsaReadyMaterial } from "./ecdsaCapabilityManifest-kzO_fW09.js";
+import { i as parseEcdsaClientPresignPoolIdentity, n as ecdsaClientPresignPoolKey, r as equalEcdsaClientPresignPoolIdentity } from "./ecdsaPresignPoolIdentity-BjxZVIqn.js";
+import { _ as NonceCoordinatorDegradationReason, b as NonceDurableLeaseState, u as nonceLaneKey, v as NonceCoordinatorFallback } from "./nonceLaneKeys-C3c9lG6u.js";
+import { i as buildNearAccountRefs, n as resolveProfileAccountContextFromCandidates } from "./profileAccountProjection-uZVJuBvS.js";
 //#region src/core/indexedDB/linkedAuthoritySignerMaterial.ts
 function linkedAuthorityMaterialSealAadV1(input) {
 	return alphabetizeStringify({
@@ -36,7 +38,7 @@ function linkedAuthorityMaterialSealAadV1(input) {
 	});
 }
 function parseWalletAuthorityLinkedSignerMaterialRecordV1(value) {
-	const record = requireRecord$2(value, "linked signer material record");
+	const record = requireRecord(value, "linked signer material record");
 	if (record.kind !== "wallet_authority_linked_signer_material_v1") throw new Error("linked signer material record kind is invalid");
 	if (record.keyFamily !== "ed25519" && record.keyFamily !== "ecdsa_secp256k1") throw new Error("linked signer material keyFamily is invalid");
 	const commonKeys = [
@@ -56,7 +58,7 @@ function parseWalletAuthorityLinkedSignerMaterialRecordV1(value) {
 	const authorityId = parseBoundaryValue(parseWalletAuthorityId(record.authorityId), "authorityId");
 	const walletAuthMethodId = parseBoundaryValue(parseWalletAuthMethodId(record.walletAuthMethodId), "walletAuthMethodId");
 	const materialActivation = parseBoundaryValue(parseMpcMaterialActivationRef(record.materialActivation), "materialActivation");
-	const activationId = requireNonEmptyString$1(record.activationId, "activationId");
+	const activationId = requireCanonicalString(record.activationId, "activationId", "must be a non-empty canonical string");
 	if (materialActivation.activationId !== activationId) throw new Error("linked signer material activationId does not match materialActivation");
 	const sealedMaterialB64u = parseCanonicalNonEmptyB64u(record.sealedMaterialB64u, "sealedMaterialB64u");
 	const sealedMaterialDigestB64u = parseDigestB64u(record.sealedMaterialDigestB64u);
@@ -131,7 +133,7 @@ async function openWalletAuthorityLinkedSignerMaterialV1(input) {
 			reason: "sealed_material_invalid"
 		};
 	}
-	if (parseDigestB64u(base64UrlEncode(await sha256Bytes(sealed))) !== record.sealedMaterialDigestB64u) {
+	if (await sha256DigestB64u(sealed) !== record.sealedMaterialDigestB64u) {
 		sealed.fill(0);
 		return {
 			kind: "wallet_authority_linked_signer_material_open_failed_v1",
@@ -191,7 +193,7 @@ async function openWalletAuthorityLinkedSignerMaterialV1(input) {
 	}
 }
 function parseWalletAuthorityLinkedMaterialTargetFactorV1(value) {
-	const record = requireRecord$2(value, "linked signer material target factor");
+	const record = requireRecord(value, "linked signer material target factor");
 	if (record.kind === "passkey") {
 		exactKeys(record, [
 			"kind",
@@ -216,20 +218,20 @@ function parseWalletAuthorityLinkedMaterialTargetFactorV1(value) {
 			"emailHashHex",
 			"registrationAuthorityId"
 		], "linked signer material email target factor");
-		const emailHashHex = requireNonEmptyString$1(record.emailHashHex, "targetFactor.emailHashHex");
+		const emailHashHex = requireCanonicalString(record.emailHashHex, "targetFactor.emailHashHex", "must be a non-empty canonical string");
 		if (!/^[0-9a-f]{64}$/.test(emailHashHex)) throw new Error("targetFactor.emailHashHex is invalid");
 		return {
 			kind: "email_otp",
 			walletAuthMethodId: parseBoundaryValue(parseWalletAuthMethodId(record.walletAuthMethodId), "targetFactor.walletAuthMethodId"),
 			verificationDigestB64u: parseDigestB64u(record.verificationDigestB64u),
 			emailHashHex,
-			registrationAuthorityId: requireNonEmptyString$1(record.registrationAuthorityId, "targetFactor.registrationAuthorityId")
+			registrationAuthorityId: requireCanonicalString(record.registrationAuthorityId, "targetFactor.registrationAuthorityId", "must be a non-empty canonical string")
 		};
 	}
 	throw new Error("linked signer material target factor kind is invalid");
 }
 function parseEd25519PublicFacts(value, materialActivation) {
-	const record = requireRecord$2(value, "linked signer material Ed25519 public facts");
+	const record = requireRecord(value, "linked signer material Ed25519 public facts");
 	exactKeys(record, [
 		"keyFamily",
 		"participantIds",
@@ -251,7 +253,7 @@ function parseEd25519PublicFacts(value, materialActivation) {
 	};
 }
 function parseEcdsaPublicFacts$1(value, materialActivation) {
-	const record = requireRecord$2(value, "linked signer material ECDSA public facts");
+	const record = requireRecord(value, "linked signer material ECDSA public facts");
 	exactKeys(record, [
 		"keyFamily",
 		"ecdsaThresholdKeyId",
@@ -280,14 +282,6 @@ function parseBoundaryValue(result, label) {
 	if (!result.ok) throw new Error(`${label}: ${result.error.message}`);
 	return result.value;
 }
-function requireNonEmptyString$1(value, label) {
-	if (typeof value !== "string" || value.length === 0 || value.trim() !== value) throw new Error(`${label} must be a non-empty canonical string`);
-	return value;
-}
-function requireRecord$2(value, label) {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`${label} must be an object`);
-	return value;
-}
 function exactKeys(record, keys, label) {
 	const actual = Object.keys(record);
 	if (actual.length !== keys.length || keys.some((key) => !actual.includes(key))) throw new Error(`${label} fields are invalid`);
@@ -2440,7 +2434,7 @@ var WalletSessionAuthorizationRepository = class {
 };
 const walletSessionAuthorizations = new WalletSessionAuthorizationRepository();
 //#endregion
-//#region src/core/indexedDB/seamsWalletDB/ecdsaCapabilityManifestStore.ts
+//#region src/core/indexedDB/seamsWalletDB/ecdsaCapabilityManifestRecords.ts
 const MANIFEST_RECORD_VERSION = "ecdsa_capability_manifest_v3";
 const POINTER_RECORD_VERSION = "ecdsa_current_capability_manifest_v2";
 const MATERIAL_RECORD_VERSION = "ecdsa_role_local_material_v2";
@@ -2452,40 +2446,11 @@ const MATERIAL_STORE = SEAMS_WALLET_STORES.ecdsaRoleLocalMaterial;
 const JOURNAL_STORE = SEAMS_WALLET_STORES.ecdsaActivationCommitJournals;
 const SEALING_KEY_STORE = SEAMS_WALLET_STORES.ecdsaMaterialSealingKeys;
 const PRESIGNATURE_STORE = SEAMS_WALLET_STORES.ecdsaClientPresignatures;
-const AES_GCM_IV_BYTES = 12;
-const MATERIAL_AAD_VERSION = 1;
-const CLIENT_PRESIGNATURE_AAD_DOMAIN = "seams/ecdsa-client-presignature/v1";
-const MAX_EXPIRED_CLIENT_PRESIGNATURE_DELETIONS_PER_TRANSACTION = 32;
-const MAX_DURABLE_CLIENT_PRESIGNATURE_FUTURE_SKEW_MS = 5 * 6e4;
-function activeManifestMatchesWalletCustodyImport(input) {
-	const manifest = input.manifest;
-	const binding = input.activationBinding;
-	return walletAuthAuthorityRefsMatch(manifest.signer.authority, binding.signer.authority) && ecdsaCapabilityScopesMatch(manifest.signer.scope, binding.signer.scope) && manifest.signer.walletId === binding.signer.walletId && manifest.signer.capability === binding.signer.capability && manifest.signer.materialOwner === binding.signer.materialOwner && manifest.signer.signingRootId === binding.signer.signingRootId && manifest.signer.signingRootVersion === binding.signer.signingRootVersion && ecdsaRegisteredPublicFactsMatch(manifest.signer.registeredPublicFacts, input.registeredPublicFacts) && ecdsaServerActivationCommitsMatch(manifest.activation.serverActivation, input.serverActivation) && mpcMaterialActivationRefsEqual(manifest.activation.materialActivation, routerAbMpcMaterialActivationRefFromWire(input.serverActivation.serverActivationReceipt.protocolReceipt.ecdsa_activation.material_activation)) && manifest.durableMaterial.bindingDigest === binding.bindingDigest && manifest.durableMaterial.durableMaterialRef === binding.durableMaterialRef && ecdsaRoleLocalMaterialBindingsMatch(manifest.durableMaterial.roleLocalBinding, binding.roleLocalBinding) && ecdsaRoleLocalPublicFactsMatch(manifest.durableMaterial.roleLocalPublicFacts, input.roleLocalPublicFacts) && sameRouterAbEcdsaDerivationNormalSigningStateV1(manifest.durableMaterial.routerAbEcdsaDerivationNormalSigning, input.routerAbEcdsaDerivationNormalSigning) && runtimePolicyScopesMatch(manifest.durableMaterial.runtimePolicyScope, normalizeRuntimePolicyScope(input.runtimePolicyScope));
-}
-var FinalizationControlError = class extends Error {
-	constructor(kind, message) {
-		super(message);
-		this.name = "FinalizationControlError";
-		this.kind = kind;
-	}
-};
-function requireRecord$1(value, label) {
-	if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error(`${label} must be an object`);
-	return value;
-}
 function requireExactKeys$1(record, label, expectedKeys) {
 	const actual = Object.keys(record).sort();
 	const expected = [...expectedKeys].sort();
 	if (actual.length !== expected.length || actual.some((field, index) => field !== expected[index])) throw new Error(`${label} has unexpected fields`);
 }
-function requireArray(value, label) {
-	if (!Array.isArray(value)) throw new Error(`${label} must be an array`);
-	return value;
-}
-function unwrapDomainId(result) {
-	if (!result.ok) throw new Error(result.error.message);
-	return result.value;
-}
 function normalizeSelector(selector) {
 	const authority = parseWalletAuthAuthorityRef(selector.authority);
 	if (!authority) throw new Error("ECDSA capability selector authority is invalid");
@@ -2494,17 +2459,17 @@ function normalizeSelector(selector) {
 		authority
 	};
 }
-function selectorFromJournal(journal) {
+function selectorFromSigner(signer) {
 	return {
-		capability: journal.candidate.activationBinding.signer.capability,
-		authority: journal.candidate.activationBinding.signer.authority
+		capability: signer.capability,
+		authority: signer.authority
 	};
 }
+function selectorFromJournal(journal) {
+	return selectorFromSigner(journal.candidate.activationBinding.signer);
+}
 function selectorFromManifest(manifest) {
-	return {
-		capability: manifest.signer.capability,
-		authority: manifest.signer.authority
-	};
+	return selectorFromSigner(manifest.signer);
 }
 function selectorKey(selector) {
 	return [
@@ -2513,6 +2478,22 @@ function selectorKey(selector) {
 		String(selector.authority.authorityDigest)
 	];
 }
+function selectorColumns(selector) {
+	return {
+		capability_ref: selector.capability,
+		wallet_id: selector.authority.walletId,
+		authority_digest: selector.authority.authorityDigest,
+		wallet_auth_method_id: selector.authority.walletAuthMethodId
+	};
+}
+function authorityFromColumns(record) {
+	return parseWalletAuthAuthorityRef({
+		kind: "wallet_auth_authority_ref",
+		walletId: record.wallet_id,
+		authorityDigest: record.authority_digest,
+		walletAuthMethodId: record.wallet_auth_method_id
+	});
+}
 function walletAuthAuthorityRefsMatch(left, right) {
 	return left.kind === right.kind && left.walletId === right.walletId && left.authorityDigest === right.authorityDigest && left.walletAuthMethodId === right.walletAuthMethodId;
 }
@@ -2545,7 +2526,7 @@ function ecdsaRoleLocalPublicFactsMatch(left, right) {
 	return left.walletId === right.walletId && ecdsaChainTargetsMatch(left.chainTarget, right.chainTarget) && left.keyHandle === right.keyHandle && left.ecdsaThresholdKeyId === right.ecdsaThresholdKeyId && left.signingRootId === right.signingRootId && left.signingRootVersion === right.signingRootVersion && left.applicationBindingDigestB64u === right.applicationBindingDigestB64u && left.clientParticipantId === right.clientParticipantId && left.relayerParticipantId === right.relayerParticipantId && orderedNumberValuesMatch(left.participantIds, right.participantIds) && left.contextBinding32B64u === right.contextBinding32B64u && left.derivationClientSharePublicKey33B64u === right.derivationClientSharePublicKey33B64u && left.relayerPublicKey33B64u === right.relayerPublicKey33B64u && left.groupPublicKey33B64u === right.groupPublicKey33B64u && left.ethereumAddress === right.ethereumAddress && sameRouterAbEcdsaDerivationPublicCapabilityV1(left.publicCapability, right.publicCapability);
 }
 function ecdsaRegisteredPublicFactsMatch(left, right) {
-	return left.kind === right.kind && left.keyHandle === right.keyHandle && left.publicKeyB64u === right.publicKeyB64u && left.participantIds.length === right.participantIds.length && left.participantIds.every((participantId, index) => participantId === right.participantIds[index]) && left.thresholdOwnerAddress === right.thresholdOwnerAddress;
+	return left.kind === right.kind && left.keyHandle === right.keyHandle && left.publicKeyB64u === right.publicKeyB64u && orderedNumberValuesMatch(left.participantIds, right.participantIds) && left.thresholdOwnerAddress === right.thresholdOwnerAddress;
 }
 function ecdsaManifestIdentitiesMatch(left, right) {
 	return left.manifestId === right.manifestId && left.manifestRevision === right.manifestRevision;
@@ -2566,17 +2547,17 @@ function ecdsaServerGenerationExpectationsMatch(left, right) {
 		default: return assertNever$1(left);
 	}
 }
-function ecdsaPreparedEvmFamilySignersMatch(left, right) {
+function ecdsaEvmFamilySignersMatch(left, right) {
 	return left.kind === right.kind && left.capability === right.capability && left.signerId === right.signerId && left.walletId === right.walletId && walletAuthAuthorityRefsMatch(left.authority, right.authority) && ecdsaCapabilityScopesMatch(left.scope, right.scope) && left.materialOwner === right.materialOwner && left.signingRootId === right.signingRootId && left.signingRootVersion === right.signingRootVersion;
 }
 function ecdsaRegisteredEvmFamilySignersMatch(left, right) {
-	return left.kind === right.kind && left.capability === right.capability && left.signerId === right.signerId && left.walletId === right.walletId && walletAuthAuthorityRefsMatch(left.authority, right.authority) && ecdsaCapabilityScopesMatch(left.scope, right.scope) && left.materialOwner === right.materialOwner && left.signingRootId === right.signingRootId && left.signingRootVersion === right.signingRootVersion && ecdsaRegisteredPublicFactsMatch(left.registeredPublicFacts, right.registeredPublicFacts);
+	return ecdsaEvmFamilySignersMatch(left, right) && ecdsaRegisteredPublicFactsMatch(left.registeredPublicFacts, right.registeredPublicFacts);
 }
 function ecdsaEncryptedPendingCandidatesMatch(left, right) {
 	return left.kind === right.kind && left.sealingKeyId === right.sealingKeyId && left.iv12B64u === right.iv12B64u && left.ciphertextB64u === right.ciphertextB64u && left.ciphertextDigest === right.ciphertextDigest;
 }
 function ecdsaActivationBindingsMatch(left, right) {
-	return left.kind === right.kind && ecdsaManifestIdentitiesMatch(left.targetManifest, right.targetManifest) && ecdsaPreparedEvmFamilySignersMatch(left.signer, right.signer) && ecdsaRoleLocalMaterialBindingsMatch(left.roleLocalBinding, right.roleLocalBinding) && left.bindingDigest === right.bindingDigest && left.durableMaterialRef === right.durableMaterialRef;
+	return left.kind === right.kind && ecdsaManifestIdentitiesMatch(left.targetManifest, right.targetManifest) && ecdsaEvmFamilySignersMatch(left.signer, right.signer) && ecdsaRoleLocalMaterialBindingsMatch(left.roleLocalBinding, right.roleLocalBinding) && left.bindingDigest === right.bindingDigest && left.durableMaterialRef === right.durableMaterialRef;
 }
 function ecdsaServerActivationCommitsMatch(left, right) {
 	return left.kind === right.kind && left.correlationId === right.correlationId && left.activationRequestDigest === right.activationRequestDigest && left.serverGeneration === right.serverGeneration && ecdsaServerActivationReceiptsMatch(left.serverActivationReceipt, right.serverActivationReceipt);
@@ -2610,54 +2591,46 @@ function ecdsaActiveCapabilityManifestsMatch(left, right) {
 }
 function serverActivationRecordMatches(expected, record) {
 	try {
-		const receipt = requireRecord$1(record.serverActivationReceipt, "ECDSA server activation receipt");
+		const receipt = requireRecord(record.serverActivationReceipt, "ECDSA server activation receipt");
 		return record.kind === expected.kind && parseCorrelationId(record.correlationId) === expected.correlationId && parseDigestB64u(record.activationRequestDigest) === expected.activationRequestDigest && parseEcdsaServerGeneration(record.serverGeneration) === expected.serverGeneration && receipt.kind === expected.serverActivationReceipt.kind && receipt.lifecycleId === String(expected.serverActivationReceipt.lifecycleId) && receipt.activationDigest === String(expected.serverActivationReceipt.activationDigest) && parseIsoTimestamp(receipt.activatedAt) === expected.serverActivationReceipt.activatedAt && sameRouterAbEcdsaRegistrationActivationReceiptV1(parseRouterAbEcdsaRegistrationActivationReceiptV1(receipt.protocolReceipt), expected.serverActivationReceipt.protocolReceipt);
 	} catch {
 		return false;
 	}
 }
-async function persistenceDigest(category, selector, detail) {
-	return parseDigestB64u(base64UrlEncode(await sha256BytesUtf8(alphabetizeStringify({
-		category,
-		capability_ref: selector.capability,
-		wallet_id: selector.authority.walletId,
-		authority_digest: selector.authority.authorityDigest,
-		wallet_auth_method_id: selector.authority.walletAuthMethodId,
-		detail
-	}))));
-}
-function retryCorrelation() {
-	return parseCorrelationId(secureRandomId("ecdsa-persistence-retry", 16, "ECDSA persistence retry correlations"));
-}
 function buildPreparedJournalFromEncryptedCandidate(input) {
 	const candidate = buildPreparedEcdsaActivationCandidate({
 		activationBinding: input.preparation.activationBinding,
 		encryptedPending: input.encryptedPending
 	});
-	switch (input.preparation.expectedManifest.kind) {
+	return buildPreparedJournalForExpectations({
+		...input.preparation,
+		candidate
+	});
+}
+function buildPreparedJournalForExpectations(input) {
+	const common = {
+		journalId: input.journalId,
+		candidate: input.candidate,
+		requestDigest: input.requestDigest,
+		canonicalRequest: input.canonicalRequest,
+		createdAt: input.createdAt
+	};
+	switch (input.expectedManifest.kind) {
 		case "no_current_manifest":
-			if (input.preparation.expectedGeneration.kind !== "no_current_generation") throw new Error("Initial ECDSA activation cannot expect a server generation");
+			if (input.expectedGeneration.kind !== "no_current_generation") throw new Error("Initial ECDSA activation cannot expect a server generation");
 			return buildPreparedEcdsaActivationJournal({
-				journalId: input.preparation.journalId,
-				expectedManifest: input.preparation.expectedManifest,
-				expectedGeneration: input.preparation.expectedGeneration,
-				candidate,
-				requestDigest: input.preparation.requestDigest,
-				canonicalRequest: input.preparation.canonicalRequest,
-				createdAt: input.preparation.createdAt
+				...common,
+				expectedManifest: input.expectedManifest,
+				expectedGeneration: input.expectedGeneration
 			});
 		case "exact_manifest":
-			if (input.preparation.expectedGeneration.kind !== "exact_generation") throw new Error("Replacement ECDSA activation requires an exact server generation");
+			if (input.expectedGeneration.kind !== "exact_generation") throw new Error("Replacement ECDSA activation requires an exact server generation");
 			return buildPreparedEcdsaActivationJournal({
-				journalId: input.preparation.journalId,
-				expectedManifest: input.preparation.expectedManifest,
-				expectedGeneration: input.preparation.expectedGeneration,
-				candidate,
-				requestDigest: input.preparation.requestDigest,
-				canonicalRequest: input.preparation.canonicalRequest,
-				createdAt: input.preparation.createdAt
+				...common,
+				expectedManifest: input.expectedManifest,
+				expectedGeneration: input.expectedGeneration
 			});
-		default: return assertNever$1(input.preparation.expectedManifest);
+		default: return assertNever$1(input.expectedManifest);
 	}
 }
 function decodeCanonicalStateBlob(value, label) {
@@ -2669,391 +2642,126 @@ function decodeCanonicalStateBlob(value, label) {
 	}
 	return bytes;
 }
-function activationBindingAadProjection(binding) {
-	return {
-		target_manifest: binding.targetManifest,
-		signer: {
-			capability: binding.signer.capability,
-			signer_id: binding.signer.signerId,
-			wallet_id: binding.signer.walletId,
-			authority: binding.signer.authority,
-			scope: binding.signer.scope,
-			material_owner: binding.signer.materialOwner,
-			signing_root_id: binding.signer.signingRootId,
-			signing_root_version: binding.signer.signingRootVersion
-		},
-		role_local_binding: binding.roleLocalBinding,
-		binding_digest: binding.bindingDigest,
-		durable_material_ref: binding.durableMaterialRef
-	};
-}
-function activeManifestBindingAadProjection(manifest) {
-	return {
-		target_manifest: manifest.identity,
-		signer: {
-			capability: manifest.signer.capability,
-			signer_id: manifest.signer.signerId,
-			wallet_id: manifest.signer.walletId,
-			authority: manifest.signer.authority,
-			scope: manifest.signer.scope,
-			material_owner: manifest.signer.materialOwner,
-			signing_root_id: manifest.signer.signingRootId,
-			signing_root_version: manifest.signer.signingRootVersion
-		},
-		role_local_binding: manifest.durableMaterial.roleLocalBinding,
-		binding_digest: manifest.durableMaterial.bindingDigest,
-		durable_material_ref: manifest.durableMaterial.durableMaterialRef
-	};
-}
-function pendingAadProjection(input) {
-	if ("activationBinding" in input) return {
-		version: MATERIAL_AAD_VERSION,
-		stage: "activation_prepared",
-		journal_id: input.journalId,
-		expected_manifest: input.expectedManifest,
-		activation_command: {
-			kind: "ecdsa_server_activation_command",
-			correlationId: input.journalId,
-			expectedGeneration: input.expectedGeneration,
-			requestDigest: input.requestDigest,
-			canonicalRequest: input.canonicalRequest
-		},
-		activation_binding: activationBindingAadProjection(input.activationBinding),
-		created_at: input.createdAt
-	};
-	return {
-		version: MATERIAL_AAD_VERSION,
-		stage: "activation_prepared",
-		journal_id: input.journalId,
-		expected_manifest: input.expectedManifest,
-		activation_command: input.activationCommand,
-		activation_binding: activationBindingAadProjection(input.candidate.activationBinding),
-		created_at: input.createdAt
-	};
-}
-function readyAadProjection(input) {
-	return {
-		version: MATERIAL_AAD_VERSION,
-		stage: "activation_ready",
-		activation_binding: input.kind === "server_activation_committed" ? activationBindingAadProjection(input.candidate.activationBinding) : activeManifestBindingAadProjection(input),
-		server_activation: input.kind === "server_activation_committed" ? input.serverActivation : input.activation.serverActivation
-	};
-}
-function importedReadyAadProjection(input) {
-	return {
-		version: MATERIAL_AAD_VERSION,
-		stage: "activation_ready",
-		activation_binding: activationBindingAadProjection(input.activationBinding),
-		server_activation: input.serverActivation
-	};
-}
 function additionalData(projection) {
 	return new TextEncoder().encode(alphabetizeStringify(projection));
 }
-function activeMaterialMatchesPresignaturePoolIdentity(material, poolIdentity) {
-	const scope = material.binding.routerAbEcdsaDerivationNormalSigning.scope;
-	const materialActivation = routerAbMpcMaterialActivationRefToWire(material.binding.materialActivation);
-	return scope.wallet_id === poolIdentity.walletId && base64UrlEncode(routerAbEcdsaDerivationNormalSigningScopeCanonicalBytesV1(scope)) === poolIdentity.signingScopeB64u && base64UrlEncode(canonicalRouterAbMpcMaterialActivationRefBytes(materialActivation)) === poolIdentity.materialActivationB64u && scope.signing_worker.key_epoch === poolIdentity.keyEpoch && scope.activation_epoch === poolIdentity.activationEpoch && materialActivation.activation_id === poolIdentity.materialActivationId && materialActivation.capability === poolIdentity.capability && materialActivation.key_binding === poolIdentity.keyBinding && materialActivation.material_owner === poolIdentity.walletId;
+async function generateMaterialSealingKey() {
+	return await crypto.subtle.generateKey({
+		name: "AES-GCM",
+		length: 256
+	}, false, ["encrypt", "decrypt"]);
 }
-function parseDurableClientPresignatureRecordId(value) {
-	if (typeof value !== "string" || !/^ecdsa-client-presignature-[A-Za-z0-9_-]+$/.test(value)) throw new Error("ECDSA durable presignature record id is invalid");
-	return value;
+async function encryptStateBlob(input) {
+	const plaintext = decodeCanonicalStateBlob(input.stateBlobB64u, "ECDSA state blob");
+	const iv12 = crypto.getRandomValues(new Uint8Array(12));
+	const aad = additionalData(input.aadProjection);
+	try {
+		const ciphertext = new Uint8Array(await crypto.subtle.encrypt({
+			name: "AES-GCM",
+			iv: iv12,
+			additionalData: aad
+		}, input.key, plaintext));
+		try {
+			return {
+				iv12B64u: parseEcdsaIv12B64u(base64UrlEncode(iv12)),
+				ciphertextB64u: parseEcdsaCiphertextB64u(base64UrlEncode(ciphertext)),
+				digestB64u: base64UrlEncode(await sha256Bytes(ciphertext))
+			};
+		} finally {
+			ciphertext.fill(0);
+		}
+	} finally {
+		plaintext.fill(0);
+		aad.fill(0);
+	}
 }
-function parsePresignatureTimestamp(value, label) {
-	if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) throw new Error(`${label} is invalid`);
-	return value;
+async function ciphertextDigestB64u(ciphertextB64u) {
+	const ciphertext = base64UrlDecode(ciphertextB64u);
+	try {
+		return base64UrlEncode(await sha256Bytes(ciphertext));
+	} finally {
+		ciphertext.fill(0);
+	}
 }
-function rawRecordId(value) {
-	if (!value || typeof value !== "object" || !("record_id" in value)) return null;
-	const recordId = value.record_id;
-	return typeof recordId === "string" ? recordId : null;
+async function decryptStateBlob(input) {
+	const iv12 = base64UrlDecode(input.iv12B64u);
+	const ciphertext = base64UrlDecode(input.ciphertextB64u);
+	const aad = additionalData(input.aadProjection);
+	let plaintext = null;
+	try {
+		plaintext = new Uint8Array(await crypto.subtle.decrypt({
+			name: "AES-GCM",
+			iv: iv12,
+			additionalData: aad
+		}, input.key, ciphertext));
+		if (plaintext.length === 0) throw new Error("decrypted ECDSA state blob must not be empty");
+		return base64UrlEncode(plaintext);
+	} finally {
+		iv12.fill(0);
+		ciphertext.fill(0);
+		aad.fill(0);
+		plaintext?.fill(0);
+	}
 }
-function supportsStrictIndexedDbDurability() {
-	return typeof IDBTransaction !== "undefined" && "durability" in IDBTransaction.prototype;
+function parseManifestIdentity(value) {
+	const record = requireRecord(value, "ECDSA manifest identity");
+	requireExactKeys$1(record, "ECDSA manifest identity", ["manifestId", "manifestRevision"]);
+	return buildEcdsaManifestIdentity({
+		manifestId: parseEcdsaCapabilityManifestId(record.manifestId),
+		manifestRevision: parseEcdsaCapabilityManifestRevision(record.manifestRevision)
+	});
 }
-async function deleteExpiredClientPresignatureRows(context, walletId, nowMs) {
-	let cursor = await context.store(PRESIGNATURE_STORE).index(SEAMS_WALLET_INDEXES.walletExpiresAt).openCursor(IDBKeyRange.bound([walletId, 0], [walletId, nowMs]));
-	let deletedCount = 0;
-	while (cursor && deletedCount < MAX_EXPIRED_CLIENT_PRESIGNATURE_DELETIONS_PER_TRANSACTION) {
-		await cursor.delete();
-		deletedCount += 1;
-		cursor = await cursor.continue();
+function parseManifestExpectation(value) {
+	const record = requireRecord(value, "ECDSA manifest expectation");
+	switch (record.kind) {
+		case "no_current_manifest":
+			requireExactKeys$1(record, "ECDSA no-current manifest expectation", ["kind"]);
+			return buildNoCurrentEcdsaManifestExpectation();
+		case "exact_manifest":
+			requireExactKeys$1(record, "ECDSA exact manifest expectation", [
+				"kind",
+				"manifestId",
+				"manifestRevision"
+			]);
+			return buildExactEcdsaManifestExpectation(buildEcdsaManifestIdentity({
+				manifestId: parseEcdsaCapabilityManifestId(record.manifestId),
+				manifestRevision: parseEcdsaCapabilityManifestRevision(record.manifestRevision)
+			}));
+		default: throw new Error("ECDSA manifest expectation kind is invalid");
 	}
-	return deletedCount;
 }
-function presignatureAadProjection(metadata) {
-	return {
-		domain: CLIENT_PRESIGNATURE_AAD_DOMAIN,
-		version: 1,
-		pool_identity: metadata.poolIdentity,
-		durable_material_ref: metadata.durableMaterialRef,
-		presignature_id: metadata.presignatureId,
-		group_public_key33_b64u: metadata.groupPublicKey33B64u,
-		big_r33_b64u: metadata.bigR33B64u,
-		created_at_ms: metadata.createdAtMs,
-		expires_at_ms: metadata.expiresAtMs,
-		sealing_key_id: metadata.sealingKeyId
-	};
-}
-function parseSealedAvailableClientPresignatureRow(value) {
-	const record = requireRecord$1(value, "ECDSA durable presignature row");
-	requireExactKeys$1(record, "ECDSA durable presignature row", [
-		"kind",
-		"record_id",
-		"pool_identity",
-		"pool_identity_key",
-		"wallet_id",
-		"material_activation_id",
-		"durable_material_ref",
-		"presignature_id",
-		"group_public_key33_b64u",
-		"big_r33_b64u",
-		"created_at_ms",
-		"expires_at_ms",
-		"sealed"
-	]);
-	if (record.kind !== "sealed_available_client_presignature_v1") throw new Error("ECDSA durable presignature row kind is invalid");
-	const poolIdentityRecord = requireRecord$1(record.pool_identity, "ECDSA durable presignature pool identity");
-	requireExactKeys$1(poolIdentityRecord, "ECDSA durable presignature pool identity", [
-		"activationEpoch",
-		"capability",
-		"keyBinding",
-		"keyEpoch",
-		"materialActivationB64u",
-		"materialActivationId",
-		"pairRole",
-		"protocolId",
-		"relayerUrl",
-		"signingScopeB64u",
-		"walletId"
-	]);
-	const poolIdentity = parseEcdsaClientPresignPoolIdentity(poolIdentityRecord);
-	const recordId = parseDurableClientPresignatureRecordId(record.record_id);
-	const poolIdentityKeyValue = String(record.pool_identity_key ?? "");
-	if (poolIdentityKeyValue !== ecdsaClientPresignPoolKey(poolIdentity)) throw new Error("ECDSA durable presignature pool identity index is inconsistent");
-	const walletId = String(record.wallet_id ?? "").trim();
-	const materialActivationId = String(record.material_activation_id ?? "").trim();
-	if (!walletId || walletId !== poolIdentity.walletId) throw new Error("ECDSA durable presignature wallet binding is inconsistent");
-	if (!materialActivationId || materialActivationId !== poolIdentity.materialActivationId) throw new Error("ECDSA durable presignature activation binding is inconsistent");
-	const durableMaterialRef = parseEcdsaRoleLocalPersistedMaterialRef(record.durable_material_ref);
-	if (durableMaterialRef.materialActivation.activationId !== poolIdentity.materialActivationId || durableMaterialRef.materialActivation.capability !== poolIdentity.capability || durableMaterialRef.materialActivation.keyBinding !== poolIdentity.keyBinding || durableMaterialRef.materialActivation.materialOwner !== poolIdentity.walletId) throw new Error("ECDSA durable presignature material binding is inconsistent");
-	const presignatureId = String(record.presignature_id ?? "").trim();
-	if (!presignatureId) throw new Error("ECDSA durable presignature id is invalid");
-	const groupPublicKey33B64u = parseEcdsaClientVerifyingPublicKey33B64u(record.group_public_key33_b64u);
-	const bigR33B64u = parseEcdsaClientVerifyingPublicKey33B64u(record.big_r33_b64u);
-	const createdAtMs = parsePresignatureTimestamp(record.created_at_ms, "created_at_ms");
-	const expiresAtMs = parsePresignatureTimestamp(record.expires_at_ms, "expires_at_ms");
-	if (createdAtMs > Date.now() + MAX_DURABLE_CLIENT_PRESIGNATURE_FUTURE_SKEW_MS) throw new Error("ECDSA durable presignature creation timestamp is in the future");
-	if (expiresAtMs <= createdAtMs) throw new Error("ECDSA durable presignature expiry must follow creation");
-	if (expiresAtMs - createdAtMs > 7776e6) throw new Error("ECDSA durable presignature lifetime exceeds the maximum");
-	const sealed = requireRecord$1(record.sealed, "ECDSA durable presignature sealed payload");
-	requireExactKeys$1(sealed, "ECDSA durable presignature sealed payload", [
-		"kind",
-		"sealing_key_id",
-		"iv12_b64u",
-		"ciphertext_b64u",
-		"ciphertext_digest_b64u"
-	]);
-	if (sealed.kind !== "ecdsa_activation_aes_gcm_v1") throw new Error("ECDSA durable presignature sealing kind is invalid");
-	return {
-		kind: "sealed_available_client_presignature_v1",
-		record_id: recordId,
-		pool_identity: poolIdentity,
-		pool_identity_key: poolIdentityKeyValue,
-		wallet_id: walletId,
-		material_activation_id: materialActivationId,
-		durable_material_ref: durableMaterialRef,
-		presignature_id: presignatureId,
-		group_public_key33_b64u: groupPublicKey33B64u,
-		big_r33_b64u: bigR33B64u,
-		created_at_ms: createdAtMs,
-		expires_at_ms: expiresAtMs,
-		sealed: {
-			kind: "ecdsa_activation_aes_gcm_v1",
-			sealing_key_id: parseEcdsaMaterialSealingKeyId(sealed.sealing_key_id),
-			iv12_b64u: parseEcdsaIv12B64u(sealed.iv12_b64u),
-			ciphertext_b64u: parseEcdsaCiphertextB64u(sealed.ciphertext_b64u),
-			ciphertext_digest_b64u: parseEcdsaCiphertextDigest(sealed.ciphertext_digest_b64u)
-		}
-	};
-}
-function metadataFromPresignatureRow(row) {
-	return {
-		kind: "sealed_available_client_presignature_v1",
-		recordId: row.record_id,
-		poolIdentity: row.pool_identity,
-		durableMaterialRef: row.durable_material_ref,
-		presignatureId: row.presignature_id,
-		groupPublicKey33B64u: row.group_public_key33_b64u,
-		bigR33B64u: row.big_r33_b64u,
-		createdAtMs: row.created_at_ms,
-		expiresAtMs: row.expires_at_ms,
-		sealingKeyId: row.sealed.sealing_key_id
-	};
-}
-async function encryptPresignatureBytes(input) {
-	const iv12 = crypto.getRandomValues(new Uint8Array(AES_GCM_IV_BYTES));
-	const aad = additionalData(presignatureAadProjection(input.metadata));
-	try {
-		const ciphertext = new Uint8Array(await crypto.subtle.encrypt({
-			name: "AES-GCM",
-			iv: iv12,
-			additionalData: aad
-		}, input.key, input.plaintext97));
-		try {
-			const ciphertextB64u = base64UrlEncode(ciphertext);
-			return {
-				iv12B64u: parseEcdsaIv12B64u(base64UrlEncode(iv12)),
-				ciphertextB64u: parseEcdsaCiphertextB64u(ciphertextB64u),
-				ciphertextDigestB64u: parseEcdsaCiphertextDigest(base64UrlEncode(await sha256Bytes(ciphertext)))
-			};
-		} finally {
-			ciphertext.fill(0);
-		}
-	} finally {
-		iv12.fill(0);
-		aad.fill(0);
-		input.plaintext97.fill(0);
-	}
-}
-async function decryptPresignatureBytes(input) {
-	const iv12 = base64UrlDecode(input.sealed.iv12_b64u);
-	const ciphertext = base64UrlDecode(input.sealed.ciphertext_b64u);
-	const aad = additionalData(presignatureAadProjection(input.metadata));
-	let plaintext = null;
-	try {
-		if (base64UrlEncode(await sha256Bytes(ciphertext)) !== input.sealed.ciphertext_digest_b64u) throw new Error("ECDSA durable presignature ciphertext digest mismatch");
-		plaintext = new Uint8Array(await crypto.subtle.decrypt({
-			name: "AES-GCM",
-			iv: iv12,
-			additionalData: aad
-		}, input.key, ciphertext));
-		if (plaintext.length !== 97) throw new Error("ECDSA durable presignature plaintext length is invalid");
-		return plaintext.slice();
-	} finally {
-		iv12.fill(0);
-		ciphertext.fill(0);
-		aad.fill(0);
-		plaintext?.fill(0);
-	}
-}
-async function generateMaterialSealingKey() {
-	return await crypto.subtle.generateKey({
-		name: "AES-GCM",
-		length: 256
-	}, false, ["encrypt", "decrypt"]);
-}
-async function encryptStateBlob(input) {
-	const plaintext = decodeCanonicalStateBlob(input.stateBlobB64u, "ECDSA state blob");
-	const iv12 = crypto.getRandomValues(new Uint8Array(AES_GCM_IV_BYTES));
-	const aad = additionalData(input.aadProjection);
-	try {
-		const ciphertext = new Uint8Array(await crypto.subtle.encrypt({
-			name: "AES-GCM",
-			iv: iv12,
-			additionalData: aad
-		}, input.key, plaintext));
-		try {
-			return {
-				iv12B64u: parseEcdsaIv12B64u(base64UrlEncode(iv12)),
-				ciphertextB64u: parseEcdsaCiphertextB64u(base64UrlEncode(ciphertext)),
-				digestB64u: base64UrlEncode(await sha256Bytes(ciphertext))
-			};
-		} finally {
-			ciphertext.fill(0);
-		}
-	} finally {
-		plaintext.fill(0);
-		aad.fill(0);
-	}
-}
-async function ciphertextDigestB64u(ciphertextB64u) {
-	const ciphertext = base64UrlDecode(ciphertextB64u);
-	try {
-		return base64UrlEncode(await sha256Bytes(ciphertext));
-	} finally {
-		ciphertext.fill(0);
-	}
-}
-async function decryptStateBlob(input) {
-	const iv12 = base64UrlDecode(input.iv12B64u);
-	const ciphertext = base64UrlDecode(input.ciphertextB64u);
-	const aad = additionalData(input.aadProjection);
-	let plaintext = null;
-	try {
-		plaintext = new Uint8Array(await crypto.subtle.decrypt({
-			name: "AES-GCM",
-			iv: iv12,
-			additionalData: aad
-		}, input.key, ciphertext));
-		if (plaintext.length === 0) throw new Error("decrypted ECDSA state blob must not be empty");
-		return base64UrlEncode(plaintext);
-	} finally {
-		iv12.fill(0);
-		ciphertext.fill(0);
-		aad.fill(0);
-		plaintext?.fill(0);
-	}
-}
-function parseManifestIdentity(value) {
-	const record = requireRecord$1(value, "ECDSA manifest identity");
-	requireExactKeys$1(record, "ECDSA manifest identity", ["manifestId", "manifestRevision"]);
-	return buildEcdsaManifestIdentity({
-		manifestId: parseEcdsaCapabilityManifestId(record.manifestId),
-		manifestRevision: parseEcdsaCapabilityManifestRevision(record.manifestRevision)
-	});
-}
-function parseManifestExpectation(value) {
-	const record = requireRecord$1(value, "ECDSA manifest expectation");
-	switch (record.kind) {
-		case "no_current_manifest":
-			requireExactKeys$1(record, "ECDSA no-current manifest expectation", ["kind"]);
-			return buildNoCurrentEcdsaManifestExpectation();
-		case "exact_manifest":
-			requireExactKeys$1(record, "ECDSA exact manifest expectation", [
-				"kind",
-				"manifestId",
-				"manifestRevision"
-			]);
-			return buildExactEcdsaManifestExpectation(buildEcdsaManifestIdentity({
-				manifestId: parseEcdsaCapabilityManifestId(record.manifestId),
-				manifestRevision: parseEcdsaCapabilityManifestRevision(record.manifestRevision)
-			}));
-		default: throw new Error("ECDSA manifest expectation kind is invalid");
-	}
-}
-function parseChainTarget$1(value) {
-	const record = requireRecord$1(value, "ECDSA capability target");
-	switch (record.kind) {
-		case "evm":
-			requireExactKeys$1(record, "ECDSA EVM capability target", [
-				"kind",
-				"namespace",
-				"chainId",
-				"networkSlug"
-			]);
-			return thresholdEcdsaChainTargetFromRequest({
-				kind: record.kind,
-				namespace: record.namespace,
-				chainId: record.chainId,
-				networkSlug: record.networkSlug
-			});
-		case "tempo":
-			requireExactKeys$1(record, "ECDSA Tempo capability target", [
-				"kind",
-				"chainId",
-				"networkSlug"
-			]);
-			return thresholdEcdsaChainTargetFromRequest({
-				kind: record.kind,
-				chainId: record.chainId,
-				networkSlug: record.networkSlug
-			});
-		default: throw new Error("ECDSA capability target kind is invalid");
-	}
+function parseChainTarget$1(value) {
+	const record = requireRecord(value, "ECDSA capability target");
+	switch (record.kind) {
+		case "evm":
+			requireExactKeys$1(record, "ECDSA EVM capability target", [
+				"kind",
+				"namespace",
+				"chainId",
+				"networkSlug"
+			]);
+			return thresholdEcdsaChainTargetFromRequest({
+				kind: record.kind,
+				namespace: record.namespace,
+				chainId: record.chainId,
+				networkSlug: record.networkSlug
+			});
+		case "tempo":
+			requireExactKeys$1(record, "ECDSA Tempo capability target", [
+				"kind",
+				"chainId",
+				"networkSlug"
+			]);
+			return thresholdEcdsaChainTargetFromRequest({
+				kind: record.kind,
+				chainId: record.chainId,
+				networkSlug: record.networkSlug
+			});
+		default: throw new Error("ECDSA capability target kind is invalid");
+	}
 }
 function parseCapabilityScope(value) {
-	const record = requireRecord$1(value, "ECDSA capability scope");
+	const record = requireRecord(value, "ECDSA capability scope");
 	requireExactKeys$1(record, "ECDSA capability scope", ["kind", "targetMemberships"]);
 	if (record.kind !== "evm_family") throw new Error("ECDSA capability scope kind is invalid");
 	const targetValues = requireArray(record.targetMemberships, "ECDSA capability target memberships");
@@ -3064,7 +2772,7 @@ function parseCapabilityScope(value) {
 	return buildEcdsaCapabilityScope({ targetMemberships: [first, ...rest] });
 }
 function parseRoleLocalBinding(value) {
-	const record = requireRecord$1(value, "ECDSA role-local material binding");
+	const record = requireRecord(value, "ECDSA role-local material binding");
 	requireExactKeys$1(record, "ECDSA role-local material binding", [
 		"kind",
 		"keyHandle",
@@ -3088,7 +2796,7 @@ function parseRoleLocalBinding(value) {
 	});
 }
 function parsePreparedSigner(value) {
-	const record = requireRecord$1(value, "prepared ECDSA signer");
+	const record = requireRecord(value, "prepared ECDSA signer");
 	requireExactKeys$1(record, "prepared ECDSA signer", [
 		"kind",
 		"capability",
@@ -3115,7 +2823,7 @@ function parsePreparedSigner(value) {
 	});
 }
 function parseEncryptedPendingCandidate(value) {
-	const record = requireRecord$1(value, "encrypted ECDSA pending candidate");
+	const record = requireRecord(value, "encrypted ECDSA pending candidate");
 	requireExactKeys$1(record, "encrypted ECDSA pending candidate", [
 		"kind",
 		"sealingKeyId",
@@ -3132,7 +2840,7 @@ function parseEncryptedPendingCandidate(value) {
 	});
 }
 function parseActivationBinding(value) {
-	const record = requireRecord$1(value, "ECDSA activation binding");
+	const record = requireRecord(value, "ECDSA activation binding");
 	requireExactKeys$1(record, "ECDSA activation binding", [
 		"kind",
 		"targetManifest",
@@ -3151,7 +2859,7 @@ function parseActivationBinding(value) {
 	});
 }
 function parsePreparedCandidate(value) {
-	const record = requireRecord$1(value, "prepared ECDSA activation candidate");
+	const record = requireRecord(value, "prepared ECDSA activation candidate");
 	requireExactKeys$1(record, "prepared ECDSA activation candidate", [
 		"kind",
 		"activationBinding",
@@ -3164,7 +2872,7 @@ function parsePreparedCandidate(value) {
 	});
 }
 function parseExpectedServerGeneration(value) {
-	const record = requireRecord$1(value, "ECDSA server generation expectation");
+	const record = requireRecord(value, "ECDSA server generation expectation");
 	switch (record.kind) {
 		case "no_current_generation":
 			requireExactKeys$1(record, "ECDSA no-current server generation expectation", ["kind"]);
@@ -3176,7 +2884,7 @@ function parseExpectedServerGeneration(value) {
 	}
 }
 function parsePreparedJournal(value) {
-	const record = requireRecord$1(value, "prepared ECDSA activation journal");
+	const record = requireRecord(value, "prepared ECDSA activation journal");
 	requireExactKeys$1(record, "prepared ECDSA activation journal", [
 		"kind",
 		"journalId",
@@ -3186,7 +2894,7 @@ function parsePreparedJournal(value) {
 		"createdAt"
 	]);
 	if (record.kind !== "activation_prepared") throw new Error("prepared ECDSA activation journal kind is invalid");
-	const command = requireRecord$1(record.activationCommand, "ECDSA activation command");
+	const command = requireRecord(record.activationCommand, "ECDSA activation command");
 	requireExactKeys$1(command, "ECDSA activation command", [
 		"kind",
 		"correlationId",
@@ -3236,34 +2944,18 @@ function preparedJournalValueFromCommitted(record) {
 }
 function preparedJournalProjection(journal) {
 	if (journal.kind === "activation_prepared") return journal;
-	switch (journal.expectedManifest.kind) {
-		case "no_current_manifest":
-			if (journal.activationCommand.expectedGeneration.kind !== "no_current_generation") throw new Error("Initial ECDSA activation cannot expect a server generation");
-			return buildPreparedEcdsaActivationJournal({
-				journalId: journal.journalId,
-				expectedManifest: journal.expectedManifest,
-				expectedGeneration: journal.activationCommand.expectedGeneration,
-				candidate: journal.candidate,
-				requestDigest: journal.activationCommand.requestDigest,
-				canonicalRequest: journal.activationCommand.canonicalRequest,
-				createdAt: journal.createdAt
-			});
-		case "exact_manifest":
-			if (journal.activationCommand.expectedGeneration.kind !== "exact_generation") throw new Error("Replacement ECDSA activation requires an exact server generation");
-			return buildPreparedEcdsaActivationJournal({
-				journalId: journal.journalId,
-				expectedManifest: journal.expectedManifest,
-				expectedGeneration: journal.activationCommand.expectedGeneration,
-				candidate: journal.candidate,
-				requestDigest: journal.activationCommand.requestDigest,
-				canonicalRequest: journal.activationCommand.canonicalRequest,
-				createdAt: journal.createdAt
-			});
-		default: return assertNever$1(journal.expectedManifest);
-	}
+	return buildPreparedJournalForExpectations({
+		journalId: journal.journalId,
+		expectedManifest: journal.expectedManifest,
+		expectedGeneration: journal.activationCommand.expectedGeneration,
+		candidate: journal.candidate,
+		requestDigest: journal.activationCommand.requestDigest,
+		canonicalRequest: journal.activationCommand.canonicalRequest,
+		createdAt: journal.createdAt
+	});
 }
 function parseCommittedJournal(value) {
-	const record = requireRecord$1(value, "server-committed ECDSA activation journal");
+	const record = requireRecord(value, "server-committed ECDSA activation journal");
 	requireExactKeys$1(record, "server-committed ECDSA activation journal", [
 		"kind",
 		"journalId",
@@ -3275,16 +2967,25 @@ function parseCommittedJournal(value) {
 	]);
 	if (record.kind !== "server_activation_committed") throw new Error("server-committed ECDSA activation journal kind is invalid");
 	const preparedJournal = parsePreparedJournal(preparedJournalValueFromCommitted(record));
-	const serverActivation = requireRecord$1(record.serverActivation, "ECDSA server activation commit");
-	requireExactKeys$1(serverActivation, "ECDSA server activation commit", [
-		"kind",
-		"correlationId",
+	const serverActivation = parseServerActivationRecord(record.serverActivation);
+	const committed = buildServerCommittedEcdsaActivationJournal({
+		preparedJournal,
+		serverCommit: serverActivation.serverCommit
+	});
+	if (!serverActivationRecordMatches(committed.serverActivation, serverActivation.record)) throw new Error("ECDSA server activation commit fields are inconsistent");
+	return committed;
+}
+function parseServerActivationRecord(value) {
+	const record = requireRecord(value, "ECDSA server activation commit");
+	requireExactKeys$1(record, "ECDSA server activation commit", [
+		"kind",
+		"correlationId",
 		"activationRequestDigest",
 		"serverGeneration",
 		"serverActivationReceipt"
 	]);
-	if (serverActivation.kind !== "ecdsa_server_activation_commit") throw new Error("ECDSA server activation commit kind is invalid");
-	const receipt = requireRecord$1(serverActivation.serverActivationReceipt, "ECDSA server activation receipt");
+	if (record.kind !== "ecdsa_server_activation_commit") throw new Error("ECDSA server activation commit kind is invalid");
+	const receipt = requireRecord(record.serverActivationReceipt, "ECDSA server activation receipt");
 	requireExactKeys$1(receipt, "ECDSA server activation receipt", [
 		"kind",
 		"lifecycleId",
@@ -3293,20 +2994,18 @@ function parseCommittedJournal(value) {
 		"protocolReceipt"
 	]);
 	if (receipt.kind !== "ecdsa_server_activation_receipt") throw new Error("ECDSA server activation receipt kind is invalid");
-	const committed = buildServerCommittedEcdsaActivationJournal({
-		preparedJournal,
+	return {
+		record,
 		serverCommit: {
-			correlationId: parseCorrelationId(serverActivation.correlationId),
-			activationRequestDigest: parseDigestB64u(serverActivation.activationRequestDigest),
-			serverGeneration: parseEcdsaServerGeneration(serverActivation.serverGeneration),
+			correlationId: parseCorrelationId(record.correlationId),
+			activationRequestDigest: parseDigestB64u(record.activationRequestDigest),
+			serverGeneration: parseEcdsaServerGeneration(record.serverGeneration),
 			protocolReceipt: receipt.protocolReceipt
 		}
-	});
-	if (!serverActivationRecordMatches(committed.serverActivation, serverActivation)) throw new Error("ECDSA server activation commit fields are inconsistent");
-	return committed;
+	};
 }
 function parseJournal(value) {
-	const record = requireRecord$1(value, "ECDSA activation journal");
+	const record = requireRecord(value, "ECDSA activation journal");
 	switch (record.kind) {
 		case "activation_prepared": return parsePreparedJournal(record);
 		case "server_activation_committed": return parseCommittedJournal(record);
@@ -3314,7 +3013,7 @@ function parseJournal(value) {
 	}
 }
 function parseRegisteredPublicFacts(value) {
-	const record = requireRecord$1(value, "registered ECDSA public facts");
+	const record = requireRecord(value, "registered ECDSA public facts");
 	requireExactKeys$1(record, "registered ECDSA public facts", [
 		"kind",
 		"keyHandle",
@@ -3330,20 +3029,8 @@ function parseRegisteredPublicFacts(value) {
 		thresholdOwnerAddress: record.thresholdOwnerAddress
 	});
 }
-function storedActiveProof(input) {
-	return {
-		activation_binding: input.activationBinding,
-		server_activation: input.serverActivation,
-		registered_public_facts: input.activeManifest.signer.registeredPublicFacts,
-		role_local_public_facts: input.durableMaterial.roleLocalPublicFacts,
-		router_ab_ecdsa_derivation_normal_signing: input.durableMaterial.routerAbEcdsaDerivationNormalSigning,
-		runtime_policy_scope: input.durableMaterial.runtimePolicyScope,
-		ciphertext_digest: input.durableMaterial.ciphertextDigest,
-		committed_at: input.activeManifest.committedAt
-	};
-}
 function parseActiveProof(value) {
-	const record = requireRecord$1(value, "active ECDSA manifest proof");
+	const record = requireRecord(value, "active ECDSA manifest proof");
 	requireExactKeys$1(record, "active ECDSA manifest proof", [
 		"activation_binding",
 		"server_activation",
@@ -3355,34 +3042,12 @@ function parseActiveProof(value) {
 		"committed_at"
 	]);
 	const activationBinding = parseActivationBinding(record.activation_binding);
-	const serverActivationRecord = requireRecord$1(record.server_activation, "ECDSA server activation commit");
-	requireExactKeys$1(serverActivationRecord, "ECDSA server activation commit", [
-		"kind",
-		"correlationId",
-		"activationRequestDigest",
-		"serverGeneration",
-		"serverActivationReceipt"
-	]);
-	if (serverActivationRecord.kind !== "ecdsa_server_activation_commit") throw new Error("ECDSA server activation commit kind is invalid");
-	const receipt = requireRecord$1(serverActivationRecord.serverActivationReceipt, "ECDSA server activation receipt");
-	requireExactKeys$1(receipt, "ECDSA server activation receipt", [
-		"kind",
-		"lifecycleId",
-		"activationDigest",
-		"activatedAt",
-		"protocolReceipt"
-	]);
-	if (receipt.kind !== "ecdsa_server_activation_receipt") throw new Error("ECDSA server activation receipt kind is invalid");
+	const serverActivationRecord = parseServerActivationRecord(record.server_activation);
 	const serverActivation = buildEcdsaServerActivationCommit({
 		activationBinding,
-		serverCommit: {
-			correlationId: parseCorrelationId(serverActivationRecord.correlationId),
-			activationRequestDigest: parseDigestB64u(serverActivationRecord.activationRequestDigest),
-			serverGeneration: parseEcdsaServerGeneration(serverActivationRecord.serverGeneration),
-			protocolReceipt: receipt.protocolReceipt
-		}
+		serverCommit: serverActivationRecord.serverCommit
 	});
-	if (!serverActivationRecordMatches(serverActivation, serverActivationRecord)) throw new Error("ECDSA server activation commit fields are inconsistent");
+	if (!serverActivationRecordMatches(serverActivation, serverActivationRecord.record)) throw new Error("ECDSA server activation commit fields are inconsistent");
 	const durableMaterial = buildDurableEcdsaMaterialBinding({
 		activationBinding,
 		serverActivation,
@@ -3406,34 +3071,8 @@ function parseActiveProof(value) {
 		committedAt
 	};
 }
-function manifestRowCommon(proof, manifestState) {
-	const selector = selectorFromManifest(proof.activeManifest);
-	return {
-		record_version: MANIFEST_RECORD_VERSION,
-		manifest_id: proof.activeManifest.identity.manifestId,
-		manifest_revision: proof.activeManifest.identity.manifestRevision,
-		capability_ref: selector.capability,
-		wallet_id: selector.authority.walletId,
-		authority_digest: selector.authority.authorityDigest,
-		wallet_auth_method_id: selector.authority.walletAuthMethodId,
-		manifest_state: manifestState
-	};
-}
-function storedActiveManifestRow(proof) {
-	return {
-		...manifestRowCommon(proof, "active"),
-		active_proof: storedActiveProof(proof)
-	};
-}
-function storedReplacedManifestRow(previous, replacement) {
-	return {
-		...manifestRowCommon(previous, "replaced"),
-		active_proof: storedActiveProof(previous),
-		replacement_proof: storedActiveProof(replacement)
-	};
-}
 function parseManifestRow(value) {
-	const record = requireRecord$1(value, "ECDSA capability manifest row");
+	const record = requireRecord(value, "ECDSA capability manifest row");
 	const commonKeys = [
 		"record_version",
 		"manifest_id",
@@ -3480,22 +3119,18 @@ function parseManifestRow(value) {
 	}
 }
 function assertManifestRowCommon(record, manifest, selector) {
-	if (record.record_version !== MANIFEST_RECORD_VERSION || parseEcdsaCapabilityManifestId(record.manifest_id) !== manifest.identity.manifestId || parseEcdsaCapabilityManifestRevision(record.manifest_revision) !== manifest.identity.manifestRevision || String(record.capability_ref) !== String(selector.capability) || String(record.wallet_id) !== String(selector.authority.walletId) || String(record.authority_digest) !== String(selector.authority.authorityDigest)) throw new Error("ECDSA capability manifest row identity is inconsistent");
+	if (record.record_version !== "ecdsa_capability_manifest_v3" || parseEcdsaCapabilityManifestId(record.manifest_id) !== manifest.identity.manifestId || parseEcdsaCapabilityManifestRevision(record.manifest_revision) !== manifest.identity.manifestRevision || String(record.capability_ref) !== String(selector.capability) || String(record.wallet_id) !== String(selector.authority.walletId) || String(record.authority_digest) !== String(selector.authority.authorityDigest)) throw new Error("ECDSA capability manifest row identity is inconsistent");
 }
 function storedPointerRow(manifest) {
-	const selector = selectorFromManifest(manifest);
 	return {
 		record_version: POINTER_RECORD_VERSION,
-		capability_ref: selector.capability,
-		wallet_id: selector.authority.walletId,
-		authority_digest: selector.authority.authorityDigest,
-		wallet_auth_method_id: selector.authority.walletAuthMethodId,
+		...selectorColumns(selectorFromManifest(manifest)),
 		manifest_id: manifest.identity.manifestId,
 		manifest_revision: manifest.identity.manifestRevision
 	};
 }
 function parsePointerRow(value) {
-	const record = requireRecord$1(value, "current ECDSA capability pointer");
+	const record = requireRecord(value, "current ECDSA capability pointer");
 	requireExactKeys$1(record, "current ECDSA capability pointer", [
 		"record_version",
 		"capability_ref",
@@ -3506,12 +3141,7 @@ function parsePointerRow(value) {
 		"manifest_revision"
 	]);
 	if (record.record_version !== POINTER_RECORD_VERSION) throw new Error("current ECDSA capability pointer version is invalid");
-	const authority = parseWalletAuthAuthorityRef({
-		kind: "wallet_auth_authority_ref",
-		walletId: record.wallet_id,
-		authorityDigest: record.authority_digest,
-		walletAuthMethodId: record.wallet_auth_method_id
-	});
+	const authority = authorityFromColumns(record);
 	if (!authority) throw new Error("current ECDSA capability pointer authority is invalid");
 	return {
 		selector: {
@@ -3523,22 +3153,18 @@ function parsePointerRow(value) {
 	};
 }
 function storedMaterialRow(material, manifest) {
-	const selector = selectorFromManifest(manifest);
 	return {
 		record_version: MATERIAL_RECORD_VERSION,
 		durable_material_ref: material.binding.durableMaterialRef,
 		binding_digest: material.binding.bindingDigest,
-		capability_ref: selector.capability,
-		wallet_id: selector.authority.walletId,
-		authority_digest: selector.authority.authorityDigest,
-		wallet_auth_method_id: selector.authority.walletAuthMethodId,
+		...selectorColumns(selectorFromManifest(manifest)),
 		sealing_key_id: material.sealingKeyId,
 		iv: material.iv12B64u,
 		ciphertext: material.ciphertextB64u
 	};
 }
 function parseMaterialLocator(value) {
-	const record = requireRecord$1(value, "ECDSA role-local material row");
+	const record = requireRecord(value, "ECDSA role-local material row");
 	requireExactKeys$1(record, "ECDSA role-local material row", [
 		"record_version",
 		"durable_material_ref",
@@ -3552,12 +3178,7 @@ function parseMaterialLocator(value) {
 		"ciphertext"
 	]);
 	if (record.record_version !== MATERIAL_RECORD_VERSION) throw new Error("ECDSA role-local material row version is invalid");
-	const authority = parseWalletAuthAuthorityRef({
-		kind: "wallet_auth_authority_ref",
-		walletId: record.wallet_id,
-		authorityDigest: record.authority_digest,
-		walletAuthMethodId: record.wallet_auth_method_id
-	});
+	const authority = authorityFromColumns(record);
 	if (!authority) throw new Error("ECDSA role-local material authority is invalid");
 	return {
 		durableMaterialRef: parseEcdsaRoleLocalDurableMaterialRef(record.durable_material_ref),
@@ -3569,7 +3190,7 @@ function parseMaterialLocator(value) {
 	};
 }
 function parseMaterialRow(value, activeProof) {
-	const record = requireRecord$1(value, "ECDSA role-local material row");
+	const record = requireRecord(value, "ECDSA role-local material row");
 	const locator = parseMaterialLocator(record);
 	const material = buildValidatedEncryptedEcdsaReadyMaterial({
 		binding: activeProof.durableMaterial,
@@ -3584,19 +3205,15 @@ function materialMatchesManifest(material, manifest) {
 	return material.binding.durableMaterialRef === manifest.durableMaterial.durableMaterialRef && material.binding.bindingDigest === manifest.durableMaterial.bindingDigest && material.binding.lifecycleId === manifest.durableMaterial.lifecycleId && material.binding.ciphertextDigest === manifest.durableMaterial.ciphertextDigest && material.binding.activationDigest === manifest.durableMaterial.activationDigest && material.binding.activatedAt === manifest.durableMaterial.activatedAt && mpcMaterialActivationRefsEqual(material.binding.materialActivation, manifest.durableMaterial.materialActivation) && ecdsaRoleLocalMaterialBindingsMatch(material.binding.roleLocalBinding, manifest.durableMaterial.roleLocalBinding);
 }
 function storedJournalRow(journal) {
-	const selector = selectorFromJournal(journal);
 	return {
 		record_version: JOURNAL_RECORD_VERSION,
 		journal_id: journal.journalId,
-		capability_ref: selector.capability,
-		wallet_id: selector.authority.walletId,
-		authority_digest: selector.authority.authorityDigest,
-		wallet_auth_method_id: selector.authority.walletAuthMethodId,
+		...selectorColumns(selectorFromJournal(journal)),
 		journal
 	};
 }
 function parseJournalRow(value) {
-	const record = requireRecord$1(value, "ECDSA activation commit journal row");
+	const record = requireRecord(value, "ECDSA activation commit journal row");
 	requireExactKeys$1(record, "ECDSA activation commit journal row", [
 		"record_version",
 		"journal_id",
@@ -3628,7 +3245,7 @@ function storedSealingKeyRow(keyId, key) {
 	};
 }
 function parseSealingKeyRow(value) {
-	const record = requireRecord$1(value, "ECDSA material sealing key row");
+	const record = requireRecord(value, "ECDSA material sealing key row");
 	requireExactKeys$1(record, "ECDSA material sealing key row", [
 		"record_version",
 		"key_id",
@@ -3641,1531 +3258,1557 @@ function parseSealingKeyRow(value) {
 		key: record.key
 	};
 }
-async function prepareImportedWalletCustodyEcdsaContinuity(input) {
-	const serverActivation = buildEcdsaServerActivationCommit({
-		activationBinding: input.activationBinding,
-		serverCommit: input.serverCommit
-	});
-	const sealingKeyId = parseEcdsaMaterialSealingKeyId(secureRandomId("ecdsa-material-sealing-key", 32, "ECDSA material sealing key identities"));
-	const sealingKey = await generateMaterialSealingKey();
-	const encrypted = await encryptStateBlob({
-		key: sealingKey,
-		stateBlobB64u: input.readyStateBlobB64u,
-		aadProjection: importedReadyAadProjection({
-			activationBinding: input.activationBinding,
-			serverActivation
-		})
-	});
-	const durableMaterial = buildDurableEcdsaMaterialBinding({
-		activationBinding: input.activationBinding,
-		serverActivation,
-		routerAbEcdsaDerivationNormalSigning: input.routerAbEcdsaDerivationNormalSigning,
-		roleLocalPublicFacts: input.roleLocalPublicFacts,
-		ciphertextDigest: parseEcdsaCiphertextDigest(encrypted.digestB64u),
-		runtimePolicyScope: input.runtimePolicyScope
-	});
-	const readyMaterial = buildValidatedEncryptedEcdsaReadyMaterial({
-		binding: durableMaterial,
-		sealingKeyId,
-		iv12B64u: encrypted.iv12B64u,
-		ciphertextB64u: encrypted.ciphertextB64u
-	});
-	const activeManifest = buildActiveEcdsaCapabilityManifest({
-		activationBinding: input.activationBinding,
-		serverActivation,
-		registeredPublicFacts: input.registeredPublicFacts,
-		durableMaterial,
-		committedAt: input.committedAt
-	});
-	return {
-		activationBinding: input.activationBinding,
-		serverActivation,
-		sealingKey,
-		readyMaterial,
-		activeManifest,
-		roleLocalMaterialRef: {
-			kind: "ecdsa_role_local_persisted_material_ref_v1",
-			durableMaterialRef: readyMaterial.binding.durableMaterialRef,
-			bindingDigest: readyMaterial.binding.bindingDigest,
-			materialActivation: readyMaterial.binding.materialActivation
-		}
-	};
+function assertNever$1(value) {
+	throw new Error(`Unexpected ECDSA persistence branch: ${String(value)}`);
 }
-async function persistPreparedImportedWalletCustodyEcdsaContinuityInTransaction(context, prepared) {
-	const selector = selectorFromManifest(prepared.activeManifest);
-	const pointerStore = context.store(POINTER_STORE);
-	const existingPointer = await pointerStore.get(selectorKey(selector));
-	const activeRows = await context.store(MANIFEST_STORE).index(SEAMS_WALLET_INDEXES.capabilityWalletAuthorityState).getAll([...selectorKey(selector), "active"]);
-	if (existingPointer !== void 0 || activeRows.length !== 0) throw new FinalizationControlError("exact_record_conflict", "ECDSA custody import found an existing active manifest");
-	const activeProof = {
-		activationBinding: prepared.activationBinding,
-		serverActivation: prepared.serverActivation,
-		durableMaterial: prepared.readyMaterial.binding,
-		activeManifest: prepared.activeManifest,
-		committedAt: prepared.activeManifest.committedAt
-	};
-	await context.store(SEALING_KEY_STORE).add(storedSealingKeyRow(prepared.readyMaterial.sealingKeyId, prepared.sealingKey));
-	await context.store(MATERIAL_STORE).add(storedMaterialRow(prepared.readyMaterial, prepared.activeManifest));
-	await context.store(MANIFEST_STORE).add(storedActiveManifestRow(activeProof));
-	await pointerStore.put(storedPointerRow(prepared.activeManifest));
+//#endregion
+//#region src/core/indexedDB/seamsWalletDB/ecdsaClientPresignatures.ts
+const CLIENT_PRESIGNATURE_AAD_DOMAIN = "seams/ecdsa-client-presignature/v1";
+const MAX_EXPIRED_CLIENT_PRESIGNATURE_DELETIONS_PER_TRANSACTION = 32;
+function activeMaterialMatchesPresignature(material, poolIdentity, materialRef) {
+	const scope = material.binding.routerAbEcdsaDerivationNormalSigning.scope;
+	const materialActivation = routerAbMpcMaterialActivationRefToWire(material.binding.materialActivation);
+	return scope.wallet_id === poolIdentity.walletId && base64UrlEncode(routerAbEcdsaDerivationNormalSigningScopeCanonicalBytesV1(scope)) === poolIdentity.signingScopeB64u && base64UrlEncode(canonicalRouterAbMpcMaterialActivationRefBytes(materialActivation)) === poolIdentity.materialActivationB64u && scope.signing_worker.key_epoch === poolIdentity.keyEpoch && scope.activation_epoch === poolIdentity.activationEpoch && materialActivation.activation_id === poolIdentity.materialActivationId && materialActivation.capability === poolIdentity.capability && materialActivation.key_binding === poolIdentity.keyBinding && materialActivation.material_owner === poolIdentity.walletId && material.binding.durableMaterialRef === materialRef.durableMaterialRef && material.binding.bindingDigest === materialRef.bindingDigest && mpcMaterialActivationRefsEqual(material.binding.materialActivation, materialRef.materialActivation);
 }
-function assertActiveProofInput(input) {
-	const parsed = parseActiveProof(storedActiveProof({
-		activationBinding: input.committedJournal.candidate.activationBinding,
-		serverActivation: input.committedJournal.serverActivation,
-		durableMaterial: input.readyMaterial.binding,
-		activeManifest: input.activeManifest,
-		committedAt: input.activeManifest.committedAt
-	}));
-	if (!ecdsaActiveCapabilityManifestsMatch(parsed.activeManifest, input.activeManifest) || !ecdsaDurableMaterialBindingsMatch(parsed.durableMaterial, input.readyMaterial.binding)) throw new Error("ECDSA finalization input does not describe one exact active manifest");
-	return parsed;
+function materialRefMatchesPoolIdentity(materialRef, poolIdentity) {
+	return materialRef.materialActivation.activationId === poolIdentity.materialActivationId && materialRef.materialActivation.capability === poolIdentity.capability && materialRef.materialActivation.keyBinding === poolIdentity.keyBinding && materialRef.materialActivation.materialOwner === poolIdentity.walletId;
 }
-function assertExpectedPointer(expected, pointerRaw, selector) {
-	switch (expected.kind) {
-		case "no_current_manifest":
-			if (pointerRaw !== void 0) throw new FinalizationControlError("exact_record_conflict", "initial ECDSA activation found an existing current pointer");
-			return null;
-		case "exact_manifest": {
-			if (pointerRaw === void 0) throw new FinalizationControlError("exact_record_conflict", "replacement ECDSA activation is missing its expected current pointer");
-			let pointer;
-			try {
-				pointer = parsePointerRow(pointerRaw);
-			} catch (error) {
-				throw new FinalizationControlError("corrupt", errorMessage(error));
-			}
-			if (!selectorsMatch(pointer.selector, selector) || pointer.manifestId !== expected.manifestId || pointer.manifestRevision !== expected.manifestRevision) throw new FinalizationControlError("exact_record_conflict", "replacement ECDSA activation pointer CAS did not match");
-			return pointer;
-		}
-	}
-	return assertNever$1(expected);
+function parseDurableClientPresignatureRecordId(value) {
+	if (typeof value !== "string" || !/^ecdsa-client-presignature-[A-Za-z0-9_-]+$/.test(value)) throw new Error("ECDSA durable presignature record id is invalid");
+	return value;
 }
-function errorMessage(error) {
-	return error instanceof Error ? error.message : String(error);
+function parsePresignatureTimestamp(value, label) {
+	if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) throw new Error(`${label} is invalid`);
+	return value;
 }
-function isConstraintError(error) {
-	return error instanceof DOMException && error.name === "ConstraintError";
+function rawRecordId(value) {
+	if (!value || typeof value !== "object" || !("record_id" in value)) return null;
+	const recordId = value.record_id;
+	return typeof recordId === "string" ? recordId : null;
 }
-function assertNever$1(value) {
-	throw new Error(`Unexpected ECDSA persistence branch: ${String(value)}`);
+function supportsStrictIndexedDbDurability() {
+	return typeof IDBTransaction !== "undefined" && "durability" in IDBTransaction.prototype;
 }
-async function cancelPreparedActivationInTransaction(preparedJournal, context) {
-	const journalStore = context.store(JOURNAL_STORE);
-	const raw = await journalStore.get(preparedJournal.journalId);
-	if (raw === void 0) return { kind: "missing" };
-	let persisted;
-	try {
-		persisted = parseJournalRow(raw);
-	} catch {
-		return { kind: "corrupt" };
-	}
-	if (persisted.journal.journalId !== preparedJournal.journalId) return { kind: "corrupt" };
-	switch (persisted.journal.kind) {
-		case "server_activation_committed": return { kind: "server_activation_committed" };
-		case "activation_prepared":
-			if (!ecdsaActivationCommitJournalsMatch(persisted.journal, preparedJournal)) return { kind: "exact_record_conflict" };
-			await context.store(SEALING_KEY_STORE).delete(persisted.journal.candidate.encryptedPending.sealingKeyId);
-			await journalStore.delete(persisted.journal.journalId);
-			return { kind: "cancelled" };
+async function deleteCursorRows(cursor, limit = Number.POSITIVE_INFINITY) {
+	let deletedCount = 0;
+	while (cursor && deletedCount < limit) {
+		await cursor.delete();
+		deletedCount += 1;
+		cursor = await cursor.continue();
 	}
-	return assertNever$1(persisted.journal);
-}
-async function readPointerRowsForWallet(context, walletId) {
-	return await context.store(POINTER_STORE).index(SEAMS_WALLET_INDEXES.walletId).getAll(walletId);
+	return deletedCount;
 }
-async function readActivationJournalRows(context) {
-	return await context.store(JOURNAL_STORE).getAll();
+async function deleteExpiredClientPresignatureRows(context, walletId, nowMs) {
+	return await deleteCursorRows(await context.store(PRESIGNATURE_STORE).index(SEAMS_WALLET_INDEXES.walletExpiresAt).openCursor(IDBKeyRange.bound([walletId, 0], [walletId, nowMs])), MAX_EXPIRED_CLIENT_PRESIGNATURE_DELETIONS_PER_TRANSACTION);
 }
-var IndexedDbEcdsaCapabilityManifestStore = class {
-	constructor(manager = seamsWalletDB) {
-		this.manager = manager;
+async function readAvailableClientPresignatureRows(context, poolIdentity, nowMs) {
+	await deleteExpiredClientPresignatureRows(context, poolIdentity.walletId, nowMs);
+	const store = context.store(PRESIGNATURE_STORE);
+	const rows = await store.index(SEAMS_WALLET_INDEXES.poolIdentityKey).getAll(ecdsaClientPresignPoolKey(poolIdentity));
+	const available = [];
+	for (const raw of rows) try {
+		const row = parseSealedAvailableClientPresignatureRow(raw);
+		if (row.expires_at_ms <= nowMs) await store.delete(row.record_id);
+		else available.push(row);
+	} catch {
+		const malformedRecordId = rawRecordId(raw);
+		if (malformedRecordId) await store.delete(malformedRecordId);
 	}
-	async admitClientPresignature(input) {
-		if (!supportsStrictIndexedDbDurability()) return { kind: "persistence_unavailable" };
-		const poolIdentity = parseEcdsaClientPresignPoolIdentity(input.poolIdentity);
-		const durableMaterialRef = parseEcdsaRoleLocalPersistedMaterialRef(input.durableMaterialRef);
-		if (durableMaterialRef.materialActivation.activationId !== poolIdentity.materialActivationId || durableMaterialRef.materialActivation.capability !== poolIdentity.capability || durableMaterialRef.materialActivation.keyBinding !== poolIdentity.keyBinding || durableMaterialRef.materialActivation.materialOwner !== poolIdentity.walletId) return { kind: "persistence_unavailable" };
-		if (input.groupPublicKey33.length !== 33 || input.bigR33.length !== 33) return { kind: "persistence_unavailable" };
-		const createdAtMs = parsePresignatureTimestamp(input.createdAtMs, "createdAtMs");
-		const expiresAtMs = parsePresignatureTimestamp(input.expiresAtMs, "expiresAtMs");
-		if (createdAtMs > Date.now() + MAX_DURABLE_CLIENT_PRESIGNATURE_FUTURE_SKEW_MS || expiresAtMs <= createdAtMs || expiresAtMs > createdAtMs + 7776e6) return { kind: "persistence_unavailable" };
-		const presignatureId = String(input.presignatureId || "").trim();
-		if (!presignatureId || input.plaintext97.length !== 97) return { kind: "persistence_unavailable" };
-		let lookup;
-		try {
-			lookup = await this.lookupByMaterialRef(durableMaterialRef);
-		} catch {
-			return { kind: "persistence_unavailable" };
-		}
-		if (lookup.kind !== "active") return { kind: "persistence_unavailable" };
-		if (!activeMaterialMatchesPresignaturePoolIdentity(lookup.material, poolIdentity) || lookup.material.binding.durableMaterialRef !== durableMaterialRef.durableMaterialRef || lookup.material.binding.bindingDigest !== durableMaterialRef.bindingDigest || !mpcMaterialActivationRefsEqual(lookup.material.binding.materialActivation, durableMaterialRef.materialActivation)) return { kind: "persistence_unavailable" };
-		let sealingKey;
-		try {
-			sealingKey = await this.readMaterialSealingKey(lookup.material.sealingKeyId);
-		} catch {
-			return { kind: "persistence_unavailable" };
+	return available;
+}
+function presignatureAadProjection(metadata) {
+	return {
+		domain: CLIENT_PRESIGNATURE_AAD_DOMAIN,
+		version: 1,
+		pool_identity: metadata.poolIdentity,
+		durable_material_ref: metadata.durableMaterialRef,
+		presignature_id: metadata.presignatureId,
+		group_public_key33_b64u: metadata.groupPublicKey33B64u,
+		big_r33_b64u: metadata.bigR33B64u,
+		created_at_ms: metadata.createdAtMs,
+		expires_at_ms: metadata.expiresAtMs,
+		sealing_key_id: metadata.sealingKeyId
+	};
+}
+function parseSealedAvailableClientPresignatureRow(value) {
+	const record = requireRecord(value, "ECDSA durable presignature row");
+	requireExactKeys$1(record, "ECDSA durable presignature row", [
+		"kind",
+		"record_id",
+		"pool_identity",
+		"pool_identity_key",
+		"wallet_id",
+		"material_activation_id",
+		"durable_material_ref",
+		"presignature_id",
+		"group_public_key33_b64u",
+		"big_r33_b64u",
+		"created_at_ms",
+		"expires_at_ms",
+		"sealed"
+	]);
+	if (record.kind !== "sealed_available_client_presignature_v1") throw new Error("ECDSA durable presignature row kind is invalid");
+	const poolIdentityRecord = requireRecord(record.pool_identity, "ECDSA durable presignature pool identity");
+	requireExactKeys$1(poolIdentityRecord, "ECDSA durable presignature pool identity", [
+		"activationEpoch",
+		"capability",
+		"keyBinding",
+		"keyEpoch",
+		"materialActivationB64u",
+		"materialActivationId",
+		"pairRole",
+		"protocolId",
+		"relayerUrl",
+		"signingScopeB64u",
+		"walletId"
+	]);
+	const poolIdentity = parseEcdsaClientPresignPoolIdentity(poolIdentityRecord);
+	const recordId = parseDurableClientPresignatureRecordId(record.record_id);
+	const poolIdentityKeyValue = String(record.pool_identity_key ?? "");
+	if (poolIdentityKeyValue !== ecdsaClientPresignPoolKey(poolIdentity)) throw new Error("ECDSA durable presignature pool identity index is inconsistent");
+	const walletId = String(record.wallet_id ?? "").trim();
+	const materialActivationId = String(record.material_activation_id ?? "").trim();
+	if (!walletId || walletId !== poolIdentity.walletId) throw new Error("ECDSA durable presignature wallet binding is inconsistent");
+	if (!materialActivationId || materialActivationId !== poolIdentity.materialActivationId) throw new Error("ECDSA durable presignature activation binding is inconsistent");
+	const durableMaterialRef = parseEcdsaRoleLocalPersistedMaterialRef(record.durable_material_ref);
+	if (!materialRefMatchesPoolIdentity(durableMaterialRef, poolIdentity)) throw new Error("ECDSA durable presignature material binding is inconsistent");
+	const presignatureId = String(record.presignature_id ?? "").trim();
+	if (!presignatureId) throw new Error("ECDSA durable presignature id is invalid");
+	const groupPublicKey33B64u = parseEcdsaClientVerifyingPublicKey33B64u(record.group_public_key33_b64u);
+	const bigR33B64u = parseEcdsaClientVerifyingPublicKey33B64u(record.big_r33_b64u);
+	const createdAtMs = parsePresignatureTimestamp(record.created_at_ms, "created_at_ms");
+	const expiresAtMs = parsePresignatureTimestamp(record.expires_at_ms, "expires_at_ms");
+	if (createdAtMs > Date.now() + 3e5) throw new Error("ECDSA durable presignature creation timestamp is in the future");
+	if (expiresAtMs <= createdAtMs) throw new Error("ECDSA durable presignature expiry must follow creation");
+	if (expiresAtMs - createdAtMs > 7776e6) throw new Error("ECDSA durable presignature lifetime exceeds the maximum");
+	const sealed = requireRecord(record.sealed, "ECDSA durable presignature sealed payload");
+	requireExactKeys$1(sealed, "ECDSA durable presignature sealed payload", [
+		"kind",
+		"sealing_key_id",
+		"iv12_b64u",
+		"ciphertext_b64u",
+		"ciphertext_digest_b64u"
+	]);
+	if (sealed.kind !== "ecdsa_activation_aes_gcm_v1") throw new Error("ECDSA durable presignature sealing kind is invalid");
+	return {
+		kind: "sealed_available_client_presignature_v1",
+		record_id: recordId,
+		pool_identity: poolIdentity,
+		pool_identity_key: poolIdentityKeyValue,
+		wallet_id: walletId,
+		material_activation_id: materialActivationId,
+		durable_material_ref: durableMaterialRef,
+		presignature_id: presignatureId,
+		group_public_key33_b64u: groupPublicKey33B64u,
+		big_r33_b64u: bigR33B64u,
+		created_at_ms: createdAtMs,
+		expires_at_ms: expiresAtMs,
+		sealed: {
+			kind: "ecdsa_activation_aes_gcm_v1",
+			sealing_key_id: parseEcdsaMaterialSealingKeyId(sealed.sealing_key_id),
+			iv12_b64u: parseEcdsaIv12B64u(sealed.iv12_b64u),
+			ciphertext_b64u: parseEcdsaCiphertextB64u(sealed.ciphertext_b64u),
+			ciphertext_digest_b64u: parseEcdsaCiphertextDigest(sealed.ciphertext_digest_b64u)
 		}
-		if (!sealingKey) return { kind: "persistence_unavailable" };
-		const recordId = parseDurableClientPresignatureRecordId(secureRandomId("ecdsa-client-presignature", 32, "ECDSA durable presignature record"));
-		const groupPublicKey33B64u = parseEcdsaClientVerifyingPublicKey33B64u(base64UrlEncode(input.groupPublicKey33));
-		const bigR33B64u = parseEcdsaClientVerifyingPublicKey33B64u(base64UrlEncode(input.bigR33));
-		const metadata = {
-			kind: "sealed_available_client_presignature_v1",
-			recordId,
-			poolIdentity,
-			durableMaterialRef,
-			presignatureId,
-			groupPublicKey33B64u,
-			bigR33B64u,
-			createdAtMs,
-			expiresAtMs,
-			sealingKeyId: lookup.material.sealingKeyId
+	};
+}
+function metadataFromPresignatureRow(row) {
+	return {
+		kind: "sealed_available_client_presignature_v1",
+		recordId: row.record_id,
+		poolIdentity: row.pool_identity,
+		durableMaterialRef: row.durable_material_ref,
+		presignatureId: row.presignature_id,
+		groupPublicKey33B64u: row.group_public_key33_b64u,
+		bigR33B64u: row.big_r33_b64u,
+		createdAtMs: row.created_at_ms,
+		expiresAtMs: row.expires_at_ms,
+		sealingKeyId: row.sealed.sealing_key_id
+	};
+}
+async function encryptPresignatureBytes(input) {
+	const iv12 = crypto.getRandomValues(new Uint8Array(12));
+	const aad = additionalData(presignatureAadProjection(input.metadata));
+	try {
+		const ciphertext = new Uint8Array(await crypto.subtle.encrypt({
+			name: "AES-GCM",
+			iv: iv12,
+			additionalData: aad
+		}, input.key, input.plaintext97));
+		try {
+			const ciphertextB64u = base64UrlEncode(ciphertext);
+			return {
+				iv12B64u: parseEcdsaIv12B64u(base64UrlEncode(iv12)),
+				ciphertextB64u: parseEcdsaCiphertextB64u(ciphertextB64u),
+				ciphertextDigestB64u: parseEcdsaCiphertextDigest(base64UrlEncode(await sha256Bytes(ciphertext)))
+			};
+		} finally {
+			ciphertext.fill(0);
+		}
+	} finally {
+		iv12.fill(0);
+		aad.fill(0);
+		input.plaintext97.fill(0);
+	}
+}
+async function decryptPresignatureBytes(input) {
+	const iv12 = base64UrlDecode(input.sealed.iv12_b64u);
+	const ciphertext = base64UrlDecode(input.sealed.ciphertext_b64u);
+	const aad = additionalData(presignatureAadProjection(input.metadata));
+	let plaintext = null;
+	try {
+		if (base64UrlEncode(await sha256Bytes(ciphertext)) !== input.sealed.ciphertext_digest_b64u) throw new Error("ECDSA durable presignature ciphertext digest mismatch");
+		plaintext = new Uint8Array(await crypto.subtle.decrypt({
+			name: "AES-GCM",
+			iv: iv12,
+			additionalData: aad
+		}, input.key, ciphertext));
+		if (plaintext.length !== 97) throw new Error("ECDSA durable presignature plaintext length is invalid");
+		return plaintext.slice();
+	} finally {
+		iv12.fill(0);
+		ciphertext.fill(0);
+		aad.fill(0);
+		plaintext?.fill(0);
+	}
+}
+async function retireClientPresignaturesForActivationInTransaction(context, walletId, materialActivationId) {
+	const store = context.store(PRESIGNATURE_STORE);
+	const rows = await store.index(SEAMS_WALLET_INDEXES.walletMaterialActivationId).getAll([walletId, materialActivationId]);
+	for (const raw of rows) {
+		const recordId = rawRecordId(raw);
+		if (recordId) await store.delete(recordId);
+	}
+}
+//#endregion
+//#region src/core/indexedDB/seamsWalletDB/ecdsaCapabilityManifestLookups.ts
+async function persistenceDigest(category, selector, detail) {
+	return parseDigestB64u(base64UrlEncode(await sha256BytesUtf8(alphabetizeStringify({
+		category,
+		...selectorColumns(selector),
+		detail
+	}))));
+}
+async function journalConstraintConflict(selector, error) {
+	return {
+		kind: "exact_record_conflict",
+		conflictDigest: await persistenceDigest("journal_constraint_conflict", selector, ecdsaManifestErrorMessage(error))
+	};
+}
+function retryCorrelation() {
+	return parseCorrelationId(secureRandomId("ecdsa-persistence-retry", 16, "ECDSA persistence retry correlations"));
+}
+function ecdsaManifestErrorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function isConstraintError(error) {
+	return error instanceof DOMException && error.name === "ConstraintError";
+}
+async function readPointerRowsForWallet(context, walletId) {
+	return await context.store(POINTER_STORE).index(SEAMS_WALLET_INDEXES.walletId).getAll(walletId);
+}
+async function readActivationJournalRows(context) {
+	return await context.store(JOURNAL_STORE).getAll();
+}
+async function readActiveManifestRows(context, selector) {
+	return await context.store(MANIFEST_STORE).index(SEAMS_WALLET_INDEXES.capabilityWalletAuthorityState).getAll([...selectorKey(selector), "active"]);
+}
+function activeLookupUsesMaterialActivation(lookup, materialActivation) {
+	return mpcMaterialActivationRefsEqual(lookup.manifest.activation.materialActivation, materialActivation) && mpcMaterialActivationRefsEqual(lookup.manifest.durableMaterial.materialActivation, materialActivation) && mpcMaterialActivationRefsEqual(lookup.material.binding.materialActivation, materialActivation);
+}
+function materialRefOpenFailure(failure) {
+	switch (failure.kind) {
+		case "missing":
+		case "retired": return { kind: "missing" };
+		case "exact_binding_mismatch": return { kind: "binding_mismatch" };
+		case "exact_record_conflict":
+		case "corrupt": return { kind: "corrupt" };
+		case "persistence_unavailable": return { kind: "persistence_unavailable" };
+	}
+	return assertNever$1(failure);
+}
+async function lookupInTransaction(context, selector) {
+	const pointerRaw = await context.store(POINTER_STORE).get(selectorKey(selector));
+	if (pointerRaw === void 0) return await lookupWithoutPointer(context, selector);
+	let pointer;
+	try {
+		pointer = parsePointerRow(pointerRaw);
+	} catch (error) {
+		return {
+			kind: "corrupt",
+			detail: ecdsaManifestErrorMessage(error)
 		};
-		let encrypted;
+	}
+	if (!selectorsMatch(pointer.selector, selector)) return {
+		kind: "exact_binding_mismatch",
+		detail: "current ECDSA pointer belongs to a different exact authority"
+	};
+	const manifestRaw = await context.store(MANIFEST_STORE).get(pointer.manifestId);
+	if (manifestRaw === void 0) return {
+		kind: "exact_record_conflict",
+		detail: "current ECDSA pointer references a missing manifest"
+	};
+	let parsedManifest;
+	try {
+		parsedManifest = parseManifestRow(manifestRaw);
+	} catch (error) {
+		return {
+			kind: "corrupt",
+			detail: ecdsaManifestErrorMessage(error)
+		};
+	}
+	if (!selectorsMatch(parsedManifest.selector, selector)) return {
+		kind: "exact_binding_mismatch",
+		detail: "current ECDSA manifest belongs to a different exact authority"
+	};
+	if (parsedManifest.manifest.identity.manifestId !== pointer.manifestId || parsedManifest.manifest.identity.manifestRevision !== pointer.manifestRevision) return {
+		kind: "exact_record_conflict",
+		detail: "current ECDSA pointer does not match its manifest identity"
+	};
+	if (parsedManifest.state === "replaced") return {
+		kind: "retired",
+		manifest: parsedManifest.manifest
+	};
+	const activeRows = await readActiveManifestRows(context, selector);
+	if (activeRows.length !== 1) return {
+		kind: "exact_record_conflict",
+		detail: "exact ECDSA authority has multiple current manifests"
+	};
+	let indexedActive;
+	try {
+		indexedActive = parseManifestRow(activeRows[0]);
+	} catch (error) {
+		return {
+			kind: "corrupt",
+			detail: ecdsaManifestErrorMessage(error)
+		};
+	}
+	if (indexedActive.state !== "active" || indexedActive.manifest.identity.manifestId !== pointer.manifestId) return {
+		kind: "exact_record_conflict",
+		detail: "exact ECDSA current index disagrees with its pointer"
+	};
+	const materialRaw = await context.store(MATERIAL_STORE).get(parsedManifest.manifest.durableMaterial.durableMaterialRef);
+	if (materialRaw === void 0) return {
+		kind: "missing",
+		subject: "material",
+		detail: "active ECDSA manifest is missing its ready material"
+	};
+	let material;
+	try {
+		material = parseMaterialRow(materialRaw, parsedManifest.activeProof);
+	} catch (error) {
+		return {
+			kind: "corrupt",
+			detail: ecdsaManifestErrorMessage(error)
+		};
+	}
+	if (!materialMatchesManifest(material, parsedManifest.manifest)) return {
+		kind: "exact_binding_mismatch",
+		detail: "active ECDSA material does not match its manifest"
+	};
+	const sealingKeyRaw = await context.store(SEALING_KEY_STORE).get(material.sealingKeyId);
+	if (sealingKeyRaw === void 0) return {
+		kind: "missing",
+		subject: "material",
+		detail: "active ECDSA material is missing its sealing key"
+	};
+	try {
+		if (parseSealingKeyRow(sealingKeyRaw).keyId !== material.sealingKeyId) return {
+			kind: "exact_binding_mismatch",
+			detail: "active ECDSA material sealing key id does not match"
+		};
+	} catch (error) {
+		return {
+			kind: "corrupt",
+			detail: ecdsaManifestErrorMessage(error)
+		};
+	}
+	if (await ciphertextDigestB64u(material.ciphertextB64u) !== material.binding.ciphertextDigest) return {
+		kind: "corrupt",
+		detail: "active ECDSA material ciphertext digest is invalid"
+	};
+	return {
+		kind: "active",
+		manifest: parsedManifest.manifest,
+		material
+	};
+}
+async function lookupWithoutPointer(context, selector) {
+	const rows = await context.store(MANIFEST_STORE).index(SEAMS_WALLET_INDEXES.capabilityWallet).getAll([String(selector.capability), String(selector.authority.walletId)]);
+	if (rows.length === 0) return {
+		kind: "missing",
+		subject: "capability",
+		detail: "no ECDSA capability manifest exists"
+	};
+	let hasDifferentAuthority = false;
+	let hasExactAuthority = false;
+	let hasSameMethodUnderAnotherDigest = false;
+	for (const raw of rows) {
+		let parsed;
 		try {
-			encrypted = await encryptPresignatureBytes({
-				key: sealingKey,
-				plaintext97: input.plaintext97,
-				metadata
-			});
-		} catch {
-			input.plaintext97.fill(0);
-			return { kind: "persistence_unavailable" };
+			parsed = parseManifestRow(raw);
+		} catch (error) {
+			return {
+				kind: "corrupt",
+				detail: ecdsaManifestErrorMessage(error)
+			};
+		}
+		if (selectorsMatch(parsed.selector, selector)) {
+			hasExactAuthority = true;
+			continue;
+		}
+		hasDifferentAuthority = true;
+		if (parsed.selector.authority.walletAuthMethodId === selector.authority.walletAuthMethodId) hasSameMethodUnderAnotherDigest = true;
+	}
+	if (hasExactAuthority) return {
+		kind: "exact_record_conflict",
+		detail: "exact ECDSA authority has manifest history without a current pointer"
+	};
+	if (hasSameMethodUnderAnotherDigest) return {
+		kind: "exact_binding_mismatch",
+		detail: "ECDSA capability exists for this method under a different authority digest"
+	};
+	if (hasDifferentAuthority) return {
+		kind: "missing",
+		subject: "capability",
+		detail: "no ECDSA capability manifest exists for this exact authority"
+	};
+	return {
+		kind: "missing",
+		subject: "capability",
+		detail: "no exact ECDSA capability manifest exists"
+	};
+}
+//#endregion
+//#region src/core/indexedDB/seamsWalletDB/ecdsaCapabilityManifestStore.ts
+const MATERIAL_AAD_VERSION = 1;
+function activeManifestMatchesWalletCustodyImport(manifest, input, serverActivation) {
+	const binding = input.activationBinding;
+	return walletAuthAuthorityRefsMatch(manifest.signer.authority, binding.signer.authority) && ecdsaCapabilityScopesMatch(manifest.signer.scope, binding.signer.scope) && manifest.signer.walletId === binding.signer.walletId && manifest.signer.capability === binding.signer.capability && manifest.signer.materialOwner === binding.signer.materialOwner && manifest.signer.signingRootId === binding.signer.signingRootId && manifest.signer.signingRootVersion === binding.signer.signingRootVersion && ecdsaRegisteredPublicFactsMatch(manifest.signer.registeredPublicFacts, input.registeredPublicFacts) && ecdsaServerActivationCommitsMatch(manifest.activation.serverActivation, serverActivation) && mpcMaterialActivationRefsEqual(manifest.activation.materialActivation, routerAbMpcMaterialActivationRefFromWire(serverActivation.serverActivationReceipt.protocolReceipt.ecdsa_activation.material_activation)) && manifest.durableMaterial.bindingDigest === binding.bindingDigest && manifest.durableMaterial.durableMaterialRef === binding.durableMaterialRef && ecdsaRoleLocalMaterialBindingsMatch(manifest.durableMaterial.roleLocalBinding, binding.roleLocalBinding) && ecdsaRoleLocalPublicFactsMatch(manifest.durableMaterial.roleLocalPublicFacts, input.roleLocalPublicFacts) && sameRouterAbEcdsaDerivationNormalSigningStateV1(manifest.durableMaterial.routerAbEcdsaDerivationNormalSigning, input.routerAbEcdsaDerivationNormalSigning) && runtimePolicyScopesMatch(manifest.durableMaterial.runtimePolicyScope, normalizeRuntimePolicyScope(input.runtimePolicyScope));
+}
+var FinalizationControlError = class extends Error {
+	constructor(kind, message) {
+		super(message);
+		this.name = "FinalizationControlError";
+		this.kind = kind;
+	}
+};
+function activationBindingAadProjection(binding) {
+	return {
+		target_manifest: binding.targetManifest,
+		signer: {
+			capability: binding.signer.capability,
+			signer_id: binding.signer.signerId,
+			wallet_id: binding.signer.walletId,
+			authority: binding.signer.authority,
+			scope: binding.signer.scope,
+			material_owner: binding.signer.materialOwner,
+			signing_root_id: binding.signer.signingRootId,
+			signing_root_version: binding.signer.signingRootVersion
+		},
+		role_local_binding: binding.roleLocalBinding,
+		binding_digest: binding.bindingDigest,
+		durable_material_ref: binding.durableMaterialRef
+	};
+}
+function pendingAadProjection(input) {
+	if ("activationBinding" in input) return {
+		version: MATERIAL_AAD_VERSION,
+		stage: "activation_prepared",
+		journal_id: input.journalId,
+		expected_manifest: input.expectedManifest,
+		activation_command: {
+			kind: "ecdsa_server_activation_command",
+			correlationId: input.journalId,
+			expectedGeneration: input.expectedGeneration,
+			requestDigest: input.requestDigest,
+			canonicalRequest: input.canonicalRequest
+		},
+		activation_binding: activationBindingAadProjection(input.activationBinding),
+		created_at: input.createdAt
+	};
+	return {
+		version: MATERIAL_AAD_VERSION,
+		stage: "activation_prepared",
+		journal_id: input.journalId,
+		expected_manifest: input.expectedManifest,
+		activation_command: input.activationCommand,
+		activation_binding: activationBindingAadProjection(input.candidate.activationBinding),
+		created_at: input.createdAt
+	};
+}
+function readyAadProjection(input) {
+	if (input.kind === "server_activation_committed") return readyAadProjectionFor(input.candidate.activationBinding, input.serverActivation);
+	return readyAadProjectionFor({
+		targetManifest: input.identity,
+		signer: input.signer,
+		roleLocalBinding: input.durableMaterial.roleLocalBinding,
+		bindingDigest: input.durableMaterial.bindingDigest,
+		durableMaterialRef: input.durableMaterial.durableMaterialRef
+	}, input.activation.serverActivation);
+}
+function readyAadProjectionFor(activationBinding, serverActivation) {
+	return {
+		version: MATERIAL_AAD_VERSION,
+		stage: "activation_ready",
+		activation_binding: activationBindingAadProjection(activationBinding),
+		server_activation: serverActivation
+	};
+}
+function storedActiveProof(input) {
+	return {
+		activation_binding: input.activationBinding,
+		server_activation: input.serverActivation,
+		registered_public_facts: input.activeManifest.signer.registeredPublicFacts,
+		role_local_public_facts: input.durableMaterial.roleLocalPublicFacts,
+		router_ab_ecdsa_derivation_normal_signing: input.durableMaterial.routerAbEcdsaDerivationNormalSigning,
+		runtime_policy_scope: input.durableMaterial.runtimePolicyScope,
+		ciphertext_digest: input.durableMaterial.ciphertextDigest,
+		committed_at: input.activeManifest.committedAt
+	};
+}
+function manifestRowCommon(proof, manifestState) {
+	return {
+		record_version: MANIFEST_RECORD_VERSION,
+		manifest_id: proof.activeManifest.identity.manifestId,
+		manifest_revision: proof.activeManifest.identity.manifestRevision,
+		...selectorColumns(selectorFromManifest(proof.activeManifest)),
+		manifest_state: manifestState
+	};
+}
+function storedActiveManifestRow(proof) {
+	return {
+		...manifestRowCommon(proof, "active"),
+		active_proof: storedActiveProof(proof)
+	};
+}
+function storedReplacedManifestRow(previous, replacement) {
+	return {
+		...manifestRowCommon(previous, "replaced"),
+		active_proof: storedActiveProof(previous),
+		replacement_proof: storedActiveProof(replacement)
+	};
+}
+async function prepareImportedWalletCustodyEcdsaContinuity(input) {
+	const serverActivation = buildEcdsaServerActivationCommit({
+		activationBinding: input.activationBinding,
+		serverCommit: input.serverCommit
+	});
+	const sealingKeyId = parseEcdsaMaterialSealingKeyId(secureRandomId("ecdsa-material-sealing-key", 32, "ECDSA material sealing key identities"));
+	const sealingKey = await generateMaterialSealingKey();
+	const encrypted = await encryptStateBlob({
+		key: sealingKey,
+		stateBlobB64u: input.readyStateBlobB64u,
+		aadProjection: readyAadProjectionFor(input.activationBinding, serverActivation)
+	});
+	const durableMaterial = buildDurableEcdsaMaterialBinding({
+		activationBinding: input.activationBinding,
+		serverActivation,
+		routerAbEcdsaDerivationNormalSigning: input.routerAbEcdsaDerivationNormalSigning,
+		roleLocalPublicFacts: input.roleLocalPublicFacts,
+		ciphertextDigest: parseEcdsaCiphertextDigest(encrypted.digestB64u),
+		runtimePolicyScope: input.runtimePolicyScope
+	});
+	const readyMaterial = buildValidatedEncryptedEcdsaReadyMaterial({
+		binding: durableMaterial,
+		sealingKeyId,
+		iv12B64u: encrypted.iv12B64u,
+		ciphertextB64u: encrypted.ciphertextB64u
+	});
+	const activeManifest = buildActiveEcdsaCapabilityManifest({
+		activationBinding: input.activationBinding,
+		serverActivation,
+		registeredPublicFacts: input.registeredPublicFacts,
+		durableMaterial,
+		committedAt: input.committedAt
+	});
+	return {
+		activationBinding: input.activationBinding,
+		serverActivation,
+		sealingKey,
+		readyMaterial,
+		activeManifest,
+		roleLocalMaterialRef: {
+			kind: "ecdsa_role_local_persisted_material_ref_v1",
+			durableMaterialRef: readyMaterial.binding.durableMaterialRef,
+			bindingDigest: readyMaterial.binding.bindingDigest,
+			materialActivation: readyMaterial.binding.materialActivation
 		}
-		const row = {
-			kind: "sealed_available_client_presignature_v1",
-			record_id: recordId,
-			pool_identity: poolIdentity,
-			pool_identity_key: ecdsaClientPresignPoolKey(poolIdentity),
-			wallet_id: poolIdentity.walletId,
-			material_activation_id: poolIdentity.materialActivationId,
-			durable_material_ref: durableMaterialRef,
-			presignature_id: presignatureId,
-			group_public_key33_b64u: groupPublicKey33B64u,
-			big_r33_b64u: bigR33B64u,
-			created_at_ms: createdAtMs,
-			expires_at_ms: expiresAtMs,
-			sealed: {
-				kind: "ecdsa_activation_aes_gcm_v1",
-				sealing_key_id: lookup.material.sealingKeyId,
-				iv12_b64u: encrypted.iv12B64u,
-				ciphertext_b64u: encrypted.ciphertextB64u,
-				ciphertext_digest_b64u: encrypted.ciphertextDigestB64u
+	};
+}
+async function persistPreparedImportedWalletCustodyEcdsaContinuityInTransaction(context, prepared) {
+	const selector = selectorFromManifest(prepared.activeManifest);
+	const pointerStore = context.store(POINTER_STORE);
+	const existingPointer = await pointerStore.get(selectorKey(selector));
+	const activeRows = await readActiveManifestRows(context, selector);
+	if (existingPointer !== void 0 || activeRows.length !== 0) throw new FinalizationControlError("exact_record_conflict", "ECDSA custody import found an existing active manifest");
+	const activeProof = {
+		activationBinding: prepared.activationBinding,
+		serverActivation: prepared.serverActivation,
+		durableMaterial: prepared.readyMaterial.binding,
+		activeManifest: prepared.activeManifest,
+		committedAt: prepared.activeManifest.committedAt
+	};
+	await context.store(SEALING_KEY_STORE).add(storedSealingKeyRow(prepared.readyMaterial.sealingKeyId, prepared.sealingKey));
+	await context.store(MATERIAL_STORE).add(storedMaterialRow(prepared.readyMaterial, prepared.activeManifest));
+	await context.store(MANIFEST_STORE).add(storedActiveManifestRow(activeProof));
+	await pointerStore.put(storedPointerRow(prepared.activeManifest));
+}
+function assertActiveProofInput(input) {
+	const parsed = parseActiveProof(storedActiveProof({
+		activationBinding: input.committedJournal.candidate.activationBinding,
+		serverActivation: input.committedJournal.serverActivation,
+		durableMaterial: input.readyMaterial.binding,
+		activeManifest: input.activeManifest,
+		committedAt: input.activeManifest.committedAt
+	}));
+	if (!ecdsaActiveCapabilityManifestsMatch(parsed.activeManifest, input.activeManifest) || !ecdsaDurableMaterialBindingsMatch(parsed.durableMaterial, input.readyMaterial.binding)) throw new Error("ECDSA finalization input does not describe one exact active manifest");
+	return parsed;
+}
+function assertExpectedPointer(expected, pointerRaw, selector) {
+	switch (expected.kind) {
+		case "no_current_manifest":
+			if (pointerRaw !== void 0) throw new FinalizationControlError("exact_record_conflict", "initial ECDSA activation found an existing current pointer");
+			return null;
+		case "exact_manifest": {
+			if (pointerRaw === void 0) throw new FinalizationControlError("exact_record_conflict", "replacement ECDSA activation is missing its expected current pointer");
+			let pointer;
+			try {
+				pointer = parsePointerRow(pointerRaw);
+			} catch (error) {
+				throw new FinalizationControlError("corrupt", ecdsaManifestErrorMessage(error));
 			}
-		};
-		try {
-			const result = await this.manager.runTransaction([PRESIGNATURE_STORE, MATERIAL_STORE], "readwrite", async (context) => {
-				const nowMs = Date.now();
-				await deleteExpiredClientPresignatureRows(context, poolIdentity.walletId, nowMs);
-				const store = context.store(PRESIGNATURE_STORE);
-				const rows = await store.index(SEAMS_WALLET_INDEXES.poolIdentityKey).getAll(row.pool_identity_key);
-				let availableCount = 0;
-				for (const raw of rows) try {
-					const existing = parseSealedAvailableClientPresignatureRow(raw);
-					if (existing.expires_at_ms <= nowMs) await store.delete(existing.record_id);
-					else availableCount += 1;
-				} catch {
-					const malformedRecordId = rawRecordId(raw);
-					if (malformedRecordId) await store.delete(malformedRecordId);
-				}
-				if (availableCount >= 5) return { kind: "capacity_full" };
-				const materialRow = await context.store(MATERIAL_STORE).get(durableMaterialRef.durableMaterialRef);
-				if (materialRow === void 0) return { kind: "persistence_unavailable" };
-				try {
-					const locator = parseMaterialLocator(materialRow);
-					const materialRecord = requireRecord$1(materialRow, "ECDSA role-local material row");
-					if (locator.durableMaterialRef !== durableMaterialRef.durableMaterialRef || locator.bindingDigest !== durableMaterialRef.bindingDigest || locator.selector.capability !== lookup.manifest.signer.capability || String(locator.selector.authority.walletId) !== poolIdentity.walletId || parseEcdsaMaterialSealingKeyId(materialRecord.sealing_key_id) !== lookup.material.sealingKeyId) return { kind: "persistence_unavailable" };
-				} catch {
-					return { kind: "persistence_unavailable" };
-				}
-				await store.put(row);
-				return { kind: "stored" };
-			}, { durability: "strict" });
-			return result.kind === "stored" ? {
-				kind: "stored",
-				metadata
-			} : result;
-		} catch {
-			return { kind: "persistence_ambiguous" };
-		}
-	}
-	async listAvailableClientPresignatures(poolIdentityInput) {
-		if (!supportsStrictIndexedDbDurability()) return [];
-		const poolIdentity = parseEcdsaClientPresignPoolIdentity(poolIdentityInput);
-		const nowMs = Date.now();
-		try {
-			return await this.manager.runTransaction([PRESIGNATURE_STORE], "readwrite", async (context) => {
-				await deleteExpiredClientPresignatureRows(context, poolIdentity.walletId, nowMs);
-				const store = context.store(PRESIGNATURE_STORE);
-				const rows = await store.index(SEAMS_WALLET_INDEXES.poolIdentityKey).getAll(ecdsaClientPresignPoolKey(poolIdentity));
-				const metadata = [];
-				for (const raw of rows) try {
-					const row = parseSealedAvailableClientPresignatureRow(raw);
-					if (row.expires_at_ms <= nowMs) {
-						await store.delete(row.record_id);
-						continue;
-					}
-					metadata.push(metadataFromPresignatureRow(row));
-				} catch {
-					const malformedRecordId = rawRecordId(raw);
-					if (malformedRecordId) await store.delete(malformedRecordId);
-				}
-				return metadata.sort((left, right) => left.createdAtMs - right.createdAtMs);
-			});
-		} catch {
-			return [];
-		}
-	}
-	async takeClientPresignature(input) {
-		if (!supportsStrictIndexedDbDurability()) return { kind: "persistence_unavailable" };
-		const recordId = parseDurableClientPresignatureRecordId(input.recordId);
-		const poolIdentity = parseEcdsaClientPresignPoolIdentity(input.poolIdentity);
-		let row;
-		try {
-			const claimed = await this.manager.runTransaction([PRESIGNATURE_STORE], "readwrite", async (context) => {
-				const store = context.store(PRESIGNATURE_STORE);
-				const raw = await store.get(recordId);
-				if (raw === void 0) return { kind: "claimed_elsewhere" };
-				let parsed;
-				try {
-					parsed = parseSealedAvailableClientPresignatureRow(raw);
-				} catch {
-					const malformedRecordId = rawRecordId(raw);
-					if (malformedRecordId) await store.delete(malformedRecordId);
-					return { kind: "corrupt" };
-				}
-				if (!equalEcdsaClientPresignPoolIdentity(parsed.pool_identity, poolIdentity)) {
-					await store.delete(recordId);
-					return { kind: "binding_rejected" };
-				}
-				if (parsed.expires_at_ms <= Date.now()) {
-					await store.delete(recordId);
-					return { kind: "expired" };
-				}
-				await store.delete(recordId);
-				return {
-					kind: "claimed",
-					row: parsed
-				};
-			}, { durability: "strict" });
-			if (claimed.kind !== "claimed") return { kind: claimed.kind };
-			row = claimed.row;
-		} catch {
-			return { kind: "persistence_unavailable" };
-		}
-		let lookup;
-		try {
-			lookup = await this.lookupByMaterialRef(row.durable_material_ref);
-		} catch {
-			return { kind: "persistence_unavailable" };
-		}
-		if (lookup.kind !== "active" || !activeMaterialMatchesPresignaturePoolIdentity(lookup.material, poolIdentity) || lookup.material.sealingKeyId !== row.sealed.sealing_key_id || lookup.material.binding.durableMaterialRef !== row.durable_material_ref.durableMaterialRef || lookup.material.binding.bindingDigest !== row.durable_material_ref.bindingDigest || !mpcMaterialActivationRefsEqual(lookup.material.binding.materialActivation, row.durable_material_ref.materialActivation)) return { kind: "binding_rejected" };
-		let sealingKey;
-		try {
-			sealingKey = await this.readMaterialSealingKey(row.sealed.sealing_key_id);
-		} catch {
-			return { kind: "persistence_unavailable" };
-		}
-		if (!sealingKey) return { kind: "corrupt" };
-		const metadata = metadataFromPresignatureRow(row);
-		try {
-			return {
-				kind: "opened",
-				metadata,
-				plaintext97: await decryptPresignatureBytes({
-					key: sealingKey,
-					metadata,
-					sealed: row.sealed
-				})
-			};
-		} catch {
-			return { kind: "corrupt" };
+			if (!selectorsMatch(pointer.selector, selector) || pointer.manifestId !== expected.manifestId || pointer.manifestRevision !== expected.manifestRevision) throw new FinalizationControlError("exact_record_conflict", "replacement ECDSA activation pointer CAS did not match");
+			return pointer;
 		}
 	}
-	async deleteClientPresignature(input) {
-		const recordId = parseDurableClientPresignatureRecordId(input.recordId);
-		const poolIdentity = parseEcdsaClientPresignPoolIdentity(input.poolIdentity);
-		await this.manager.runTransaction([PRESIGNATURE_STORE], "readwrite", async (context) => {
-			const store = context.store(PRESIGNATURE_STORE);
-			const raw = await store.get(recordId);
-			if (raw === void 0) return;
-			if (equalEcdsaClientPresignPoolIdentity(parseSealedAvailableClientPresignatureRow(raw).pool_identity, poolIdentity)) await store.delete(recordId);
-		});
-	}
-	async deleteClientPresignatures(target) {
-		return await this.manager.runTransaction([PRESIGNATURE_STORE], "readwrite", async (context) => {
-			const store = context.store(PRESIGNATURE_STORE);
-			let deletedCount = 0;
-			switch (target.kind) {
-				case "wallet": {
-					const walletId = String(target.walletId).trim();
-					if (!walletId) throw new Error("ECDSA durable presignature wallet id is required");
-					let cursor = await store.index(SEAMS_WALLET_INDEXES.walletId).openCursor(walletId);
-					while (cursor) {
-						await cursor.delete();
-						deletedCount += 1;
-						cursor = await cursor.continue();
-					}
-					break;
-				}
-				case "all": {
-					let cursor = await store.openCursor();
-					while (cursor) {
-						await cursor.delete();
-						deletedCount += 1;
-						cursor = await cursor.continue();
-					}
-					break;
-				}
-			}
-			return deletedCount;
-		});
+	return assertNever$1(expected);
+}
+async function cancelPreparedActivationInTransaction(preparedJournal, context) {
+	const journalStore = context.store(JOURNAL_STORE);
+	const raw = await journalStore.get(preparedJournal.journalId);
+	if (raw === void 0) return { kind: "missing" };
+	let persisted;
+	try {
+		persisted = parseJournalRow(raw);
+	} catch {
+		return { kind: "corrupt" };
 	}
-	async listActiveWalletCapabilitySubjects(walletIdInput) {
-		const parsedWalletId = parseWalletId(walletIdInput);
-		if (!parsedWalletId.ok) return { kind: "invalid_current_state" };
-		let rows;
-		try {
-			rows = await this.manager.runTransaction([POINTER_STORE], "readonly", (context) => readPointerRowsForWallet(context, parsedWalletId.value));
-		} catch {
-			return { kind: "persistence_unavailable" };
-		}
-		const selectors = [];
-		try {
-			for (const row of rows) {
-				const pointer = parsePointerRow(row);
-				if (pointer.selector.authority.walletId === parsedWalletId.value) selectors.push(pointer.selector);
-			}
-		} catch {
-			return { kind: "invalid_current_state" };
-		}
-		const subjects = [];
-		for (const selector of selectors) {
-			const lookup = await this.lookup(selector);
-			if (lookup.kind === "persistence_unavailable") return { kind: "persistence_unavailable" };
-			if (lookup.kind !== "active") return { kind: "invalid_current_state" };
-			subjects.push({
-				capability: lookup.manifest.signer.capability,
-				authority: lookup.manifest.signer.authority,
-				ecdsaThresholdKeyId: lookup.manifest.durableMaterial.roleLocalBinding.ecdsaThresholdKeyId
-			});
-		}
-		return {
-			kind: "resolved",
-			subjects
-		};
+	if (persisted.journal.journalId !== preparedJournal.journalId) return { kind: "corrupt" };
+	switch (persisted.journal.kind) {
+		case "server_activation_committed": return { kind: "server_activation_committed" };
+		case "activation_prepared":
+			if (!ecdsaActivationCommitJournalsMatch(persisted.journal, preparedJournal)) return { kind: "exact_record_conflict" };
+			await context.store(SEALING_KEY_STORE).delete(persisted.journal.candidate.encryptedPending.sealingKeyId);
+			await journalStore.delete(persisted.journal.journalId);
+			return { kind: "cancelled" };
 	}
-	async listWalletActivationJournalSelectors(walletIdInput) {
-		const parsedWalletId = parseWalletId(walletIdInput);
-		if (!parsedWalletId.ok) return { kind: "invalid_current_state" };
-		let rows;
-		try {
-			rows = await this.manager.runTransaction([JOURNAL_STORE], "readonly", readActivationJournalRows);
-		} catch {
-			return { kind: "persistence_unavailable" };
-		}
-		const selectors = [];
-		try {
-			for (const row of rows) {
-				const signer = parseJournalRow(row).journal.candidate.activationBinding.signer;
-				if (signer.authority.walletId !== parsedWalletId.value) continue;
-				selectors.push({
-					capability: signer.capability,
-					authority: signer.authority
-				});
-			}
-		} catch {
-			return { kind: "invalid_current_state" };
-		}
+	return assertNever$1(persisted.journal);
+}
+function persistPreparedContinuity(manager, prepared) {
+	return manager.runTransaction([
+		MANIFEST_STORE,
+		POINTER_STORE,
+		MATERIAL_STORE,
+		SEALING_KEY_STORE
+	], "readwrite", (context) => persistPreparedImportedWalletCustodyEcdsaContinuityInTransaction(context, prepared));
+}
+async function importCommittedActivation(store, input, persist) {
+	const serverActivation = buildEcdsaServerActivationCommit({
+		activationBinding: input.activationBinding,
+		serverCommit: input.serverCommit
+	});
+	const selector = selectorFromSigner(input.activationBinding.signer);
+	const existing = await store.lookup(selector);
+	if (existing.kind === "active") {
+		if (activeManifestMatchesWalletCustodyImport(existing.manifest, input, serverActivation)) return {
+			kind: "committed",
+			manifest: existing.manifest,
+			material: existing.material
+		};
 		return {
-			kind: "resolved",
-			selectors
+			kind: "exact_record_conflict",
+			selector,
+			conflictDigest: await persistenceDigest("custody_import_conflict", selector, "ECDSA custody import conflicts with the active manifest")
 		};
 	}
-	async prepareActivation(input) {
-		const selector = {
-			capability: input.activationBinding.signer.capability,
-			authority: input.activationBinding.signer.authority
+	try {
+		const prepared = await prepareImportedWalletCustodyEcdsaContinuity(input);
+		await persist(prepared);
+		return {
+			kind: "committed",
+			manifest: prepared.activeManifest,
+			material: prepared.readyMaterial
 		};
-		try {
-			const keyId = parseEcdsaMaterialSealingKeyId(secureRandomId("ecdsa-material-key", 32, "ECDSA activation material sealing key"));
-			const key = await generateMaterialSealingKey();
-			const encrypted = await encryptStateBlob({
-				key,
-				stateBlobB64u: input.pendingPayloadB64u,
-				aadProjection: pendingAadProjection(input)
-			});
-			const journal = buildPreparedJournalFromEncryptedCandidate({
-				preparation: input,
-				encryptedPending: buildEncryptedEcdsaPendingCandidate({
-					sealingKeyId: keyId,
-					iv12B64u: encrypted.iv12B64u,
-					ciphertextB64u: encrypted.ciphertextB64u,
-					ciphertextDigest: parseEcdsaPendingCiphertextDigest(encrypted.digestB64u)
-				})
-			});
-			await this.manager.runTransaction([SEALING_KEY_STORE, JOURNAL_STORE], "readwrite", async (context) => {
-				await context.store(SEALING_KEY_STORE).add(storedSealingKeyRow(keyId, key));
-				await context.store(JOURNAL_STORE).add(storedJournalRow(journal));
-			});
-			return {
-				kind: "stored",
-				journal
-			};
-		} catch (error) {
-			if (isConstraintError(error)) return {
-				kind: "exact_record_conflict",
-				conflictDigest: await persistenceDigest("journal_constraint_conflict", selector, errorMessage(error))
-			};
-			if (error instanceof DOMException && error.name === "OperationError") return {
-				kind: "corrupt",
-				corruptionDigest: await persistenceDigest("journal_encryption_failed", selector, errorMessage(error))
-			};
-			if (error instanceof Error && !(error instanceof DOMException)) return {
-				kind: "corrupt",
-				corruptionDigest: await persistenceDigest("journal_preparation_invalid", selector, error.message)
+	} catch (error) {
+		if (error instanceof FinalizationControlError || isConstraintError(error)) {
+			const replay = await store.lookup(selector);
+			if (replay.kind === "active" && activeManifestMatchesWalletCustodyImport(replay.manifest, input, serverActivation)) return {
+				kind: "committed",
+				manifest: replay.manifest,
+				material: replay.material
 			};
 			return {
-				kind: "persistence_unavailable",
-				retryCorrelation: retryCorrelation()
+				kind: "exact_record_conflict",
+				selector,
+				conflictDigest: await persistenceDigest("custody_import_conflict", selector, ecdsaManifestErrorMessage(error))
 			};
 		}
+		return {
+			kind: "corrupt",
+			selector,
+			corruptionDigest: await persistenceDigest("custody_import_corrupt", selector, ecdsaManifestErrorMessage(error))
+		};
 	}
-	async recordServerActivation(input) {
-		let committedJournal;
-		try {
-			committedJournal = buildServerCommittedEcdsaActivationJournal(input);
-		} catch (error) {
-			return {
-				kind: "corrupt",
-				corruptionDigest: await persistenceDigest("server_activation_commit_corrupt", selectorFromJournal(input.preparedJournal), errorMessage(error))
-			};
-		}
-		return await this.putActivationJournal(committedJournal);
+}
+var IndexedDbEcdsaCapabilityManifestStore = class {
+	constructor(manager = seamsWalletDB) {
+		this.manager = manager;
 	}
-	async putActivationJournal(journalInput) {
-		let journal;
-		try {
-			journal = parseCommittedJournal(journalInput);
-			if (await ciphertextDigestB64u(journal.candidate.encryptedPending.ciphertextB64u) !== journal.candidate.encryptedPending.ciphertextDigest) throw new Error("ECDSA pending material ciphertext digest is invalid");
-		} catch (error) {
-			return {
-				kind: "corrupt",
-				corruptionDigest: await persistenceDigest("journal_input_corrupt", selectorFromJournal(journalInput), errorMessage(error))
-			};
-		}
-		const selector = selectorFromJournal(journal);
+	async admitClientPresignature(input) {
+		if (!supportsStrictIndexedDbDurability()) return { kind: "persistence_unavailable" };
+		const poolIdentity = parseEcdsaClientPresignPoolIdentity(input.poolIdentity);
+		const durableMaterialRef = parseEcdsaRoleLocalPersistedMaterialRef(input.durableMaterialRef);
+		if (!materialRefMatchesPoolIdentity(durableMaterialRef, poolIdentity)) return { kind: "persistence_unavailable" };
+		if (input.groupPublicKey33.length !== 33 || input.bigR33.length !== 33) return { kind: "persistence_unavailable" };
+		const createdAtMs = parsePresignatureTimestamp(input.createdAtMs, "createdAtMs");
+		const expiresAtMs = parsePresignatureTimestamp(input.expiresAtMs, "expiresAtMs");
+		if (createdAtMs > Date.now() + 3e5 || expiresAtMs <= createdAtMs || expiresAtMs > createdAtMs + 7776e6) return { kind: "persistence_unavailable" };
+		const presignatureId = String(input.presignatureId || "").trim();
+		if (!presignatureId || input.plaintext97.length !== 97) return { kind: "persistence_unavailable" };
+		let lookup;
 		try {
-			const sealingKey = await this.readMaterialSealingKey(journal.candidate.encryptedPending.sealingKeyId);
-			if (!sealingKey) throw new FinalizationControlError("corrupt", "ECDSA activation journal references a missing sealing key");
-			await decryptStateBlob({
-				key: sealingKey,
-				iv12B64u: journal.candidate.encryptedPending.iv12B64u,
-				ciphertextB64u: journal.candidate.encryptedPending.ciphertextB64u,
-				aadProjection: pendingAadProjection(journal)
-			});
-			await this.manager.runTransaction([SEALING_KEY_STORE, JOURNAL_STORE], "readwrite", async (context) => {
-				const sealingKeyRaw = await context.store(SEALING_KEY_STORE).get(journal.candidate.encryptedPending.sealingKeyId);
-				if (sealingKeyRaw === void 0) throw new FinalizationControlError("corrupt", "ECDSA activation journal references a missing sealing key");
-				try {
-					parseSealingKeyRow(sealingKeyRaw);
-				} catch (error) {
-					throw new FinalizationControlError("corrupt", errorMessage(error));
-				}
-				const journalStore = context.store(JOURNAL_STORE);
-				const existingRaw = await journalStore.get(journal.journalId);
-				if (existingRaw === void 0) throw new FinalizationControlError("exact_record_conflict", "ECDSA committed activation is missing its prepared journal");
-				let existing;
-				try {
-					existing = parseJournalRow(existingRaw);
-				} catch (error) {
-					throw new FinalizationControlError("corrupt", errorMessage(error));
-				}
-				if (!selectorsMatch(existing.selector, selector) || existing.journal.kind === "activation_prepared" && !ecdsaActivationCommitJournalsMatch(existing.journal, preparedJournalProjection(journal)) || existing.journal.kind === "server_activation_committed" && !ecdsaActivationCommitJournalsMatch(existing.journal, journal)) throw new FinalizationControlError("exact_record_conflict", "ECDSA activation journal conflicts with its existing correlation");
-				await journalStore.put(storedJournalRow(journal));
-			});
-			return {
-				kind: "stored",
-				journal
-			};
-		} catch (error) {
-			if (error instanceof FinalizationControlError) {
-				const digest = await persistenceDigest(error.kind === "corrupt" ? "journal_corrupt" : "journal_conflict", selector, error.message);
-				return error.kind === "corrupt" ? {
-					kind: "corrupt",
-					corruptionDigest: digest
-				} : {
-					kind: "exact_record_conflict",
-					conflictDigest: digest
-				};
-			}
-			if (isConstraintError(error)) return {
-				kind: "exact_record_conflict",
-				conflictDigest: await persistenceDigest("journal_constraint_conflict", selector, errorMessage(error))
-			};
-			if (error instanceof DOMException && error.name === "OperationError") return {
-				kind: "corrupt",
-				corruptionDigest: await persistenceDigest("journal_ciphertext_corrupt", selector, errorMessage(error))
-			};
-			return {
-				kind: "persistence_unavailable",
-				retryCorrelation: retryCorrelation()
-			};
+			lookup = await this.lookupByMaterialRef(durableMaterialRef);
+		} catch {
+			return { kind: "persistence_unavailable" };
 		}
-	}
-	async readActivationJournal(journalIdInput) {
-		const journalId = parseCorrelationId(journalIdInput);
+		if (lookup.kind !== "active") return { kind: "persistence_unavailable" };
+		if (!activeMaterialMatchesPresignature(lookup.material, poolIdentity, durableMaterialRef)) return { kind: "persistence_unavailable" };
+		let sealingKey;
 		try {
-			const raw = await this.manager.runTransaction([JOURNAL_STORE], "readonly", async (context) => await context.store(JOURNAL_STORE).get(journalId));
-			if (raw === void 0) return { kind: "missing" };
-			try {
-				const parsed = parseJournalRow(raw);
-				return parsed.journal.journalId === journalId ? {
-					kind: "found",
-					journal: parsed.journal
-				} : { kind: "corrupt" };
-			} catch {
-				return { kind: "corrupt" };
-			}
+			sealingKey = await this.readMaterialSealingKey(lookup.material.sealingKeyId);
 		} catch {
 			return { kind: "persistence_unavailable" };
 		}
-	}
-	async discoverActivationJournal(selectorInput) {
-		let selector;
+		if (!sealingKey) return { kind: "persistence_unavailable" };
+		const recordId = parseDurableClientPresignatureRecordId(secureRandomId("ecdsa-client-presignature", 32, "ECDSA durable presignature record"));
+		const groupPublicKey33B64u = parseEcdsaClientVerifyingPublicKey33B64u(base64UrlEncode(input.groupPublicKey33));
+		const bigR33B64u = parseEcdsaClientVerifyingPublicKey33B64u(base64UrlEncode(input.bigR33));
+		const metadata = {
+			kind: "sealed_available_client_presignature_v1",
+			recordId,
+			poolIdentity,
+			durableMaterialRef,
+			presignatureId,
+			groupPublicKey33B64u,
+			bigR33B64u,
+			createdAtMs,
+			expiresAtMs,
+			sealingKeyId: lookup.material.sealingKeyId
+		};
+		let encrypted;
 		try {
-			selector = normalizeSelector(selectorInput);
+			encrypted = await encryptPresignatureBytes({
+				key: sealingKey,
+				plaintext97: input.plaintext97,
+				metadata
+			});
 		} catch {
-			return { kind: "corrupt" };
+			input.plaintext97.fill(0);
+			return { kind: "persistence_unavailable" };
 		}
-		try {
-			const raw = await this.manager.runTransaction([JOURNAL_STORE], "readonly", async (context) => await context.store(JOURNAL_STORE).index(SEAMS_WALLET_INDEXES.capabilityWalletAuthority).get(selectorKey(selector)));
-			if (raw === void 0) return { kind: "missing" };
-			try {
-				const parsed = parseJournalRow(raw);
-				return selectorsMatch(parsed.selector, selector) ? {
-					kind: "found",
-					journal: parsed.journal
-				} : { kind: "corrupt" };
-			} catch {
-				return { kind: "corrupt" };
+		const row = {
+			kind: "sealed_available_client_presignature_v1",
+			record_id: recordId,
+			pool_identity: poolIdentity,
+			pool_identity_key: ecdsaClientPresignPoolKey(poolIdentity),
+			wallet_id: poolIdentity.walletId,
+			material_activation_id: poolIdentity.materialActivationId,
+			durable_material_ref: durableMaterialRef,
+			presignature_id: presignatureId,
+			group_public_key33_b64u: groupPublicKey33B64u,
+			big_r33_b64u: bigR33B64u,
+			created_at_ms: createdAtMs,
+			expires_at_ms: expiresAtMs,
+			sealed: {
+				kind: "ecdsa_activation_aes_gcm_v1",
+				sealing_key_id: lookup.material.sealingKeyId,
+				iv12_b64u: encrypted.iv12B64u,
+				ciphertext_b64u: encrypted.ciphertextB64u,
+				ciphertext_digest_b64u: encrypted.ciphertextDigestB64u
 			}
-		} catch {
-			return { kind: "persistence_unavailable" };
-		}
-	}
-	async cancelPreparedActivation(preparedJournal) {
-		try {
-			return await this.manager.runTransaction([SEALING_KEY_STORE, JOURNAL_STORE], "readwrite", cancelPreparedActivationInTransaction.bind(void 0, preparedJournal));
-		} catch {
-			return { kind: "persistence_unavailable" };
-		}
-	}
-	async openPreparedActivation(journalIdInput) {
-		const read = await this.readActivationJournal(journalIdInput);
-		if (read.kind !== "found") return read;
-		const encryptedPending = read.journal.candidate.encryptedPending;
+		};
 		try {
-			if (await ciphertextDigestB64u(encryptedPending.ciphertextB64u) !== encryptedPending.ciphertextDigest) return { kind: "corrupt" };
-			const sealingKey = await this.readMaterialSealingKey(encryptedPending.sealingKeyId);
-			if (!sealingKey) return { kind: "corrupt" };
-			return {
-				kind: "found",
-				journal: read.journal,
-				pendingPayloadB64u: await decryptStateBlob({
-					key: sealingKey,
-					iv12B64u: encryptedPending.iv12B64u,
-					ciphertextB64u: encryptedPending.ciphertextB64u,
-					aadProjection: pendingAadProjection(read.journal)
-				})
-			};
+			const result = await this.manager.runTransaction([PRESIGNATURE_STORE, MATERIAL_STORE], "readwrite", async (context) => {
+				if ((await readAvailableClientPresignatureRows(context, poolIdentity, Date.now())).length >= 5) return { kind: "capacity_full" };
+				const materialRow = await context.store(MATERIAL_STORE).get(durableMaterialRef.durableMaterialRef);
+				if (materialRow === void 0) return { kind: "persistence_unavailable" };
+				try {
+					const locator = parseMaterialLocator(materialRow);
+					const materialRecord = requireRecord(materialRow, "ECDSA role-local material row");
+					if (locator.durableMaterialRef !== durableMaterialRef.durableMaterialRef || locator.bindingDigest !== durableMaterialRef.bindingDigest || locator.selector.capability !== lookup.manifest.signer.capability || String(locator.selector.authority.walletId) !== poolIdentity.walletId || parseEcdsaMaterialSealingKeyId(materialRecord.sealing_key_id) !== lookup.material.sealingKeyId) return { kind: "persistence_unavailable" };
+				} catch {
+					return { kind: "persistence_unavailable" };
+				}
+				await context.store(PRESIGNATURE_STORE).put(row);
+				return { kind: "stored" };
+			}, { durability: "strict" });
+			return result.kind === "stored" ? {
+				kind: "stored",
+				metadata
+			} : result;
 		} catch {
-			return { kind: "corrupt" };
+			return { kind: "persistence_ambiguous" };
 		}
 	}
-	async lookup(selectorInput) {
-		const selector = normalizeSelector(selectorInput);
-		let observation;
+	async listAvailableClientPresignatures(poolIdentityInput) {
+		if (!supportsStrictIndexedDbDurability()) return [];
+		const poolIdentity = parseEcdsaClientPresignPoolIdentity(poolIdentityInput);
+		const nowMs = Date.now();
 		try {
-			observation = await this.manager.runTransaction([
-				MANIFEST_STORE,
-				POINTER_STORE,
-				MATERIAL_STORE,
-				SEALING_KEY_STORE
-			], "readonly", async (context) => await lookupInTransaction(context, selector));
+			return await this.manager.runTransaction([PRESIGNATURE_STORE], "readwrite", async (context) => {
+				return (await readAvailableClientPresignatureRows(context, poolIdentity, nowMs)).map(metadataFromPresignatureRow).sort((left, right) => left.createdAtMs - right.createdAtMs);
+			});
 		} catch {
-			return {
-				kind: "persistence_unavailable",
-				selector,
-				retryCorrelation: retryCorrelation()
-			};
-		}
-		switch (observation.kind) {
-			case "active": return observation;
-			case "retired": return observation;
-			case "missing": return {
-				kind: "missing",
-				selector,
-				subject: observation.subject
-			};
-			case "exact_binding_mismatch": return {
-				kind: "exact_binding_mismatch",
-				selector,
-				failureDigest: await persistenceDigest(observation.kind, selector, observation.detail)
-			};
-			case "exact_record_conflict": return {
-				kind: "exact_record_conflict",
-				selector,
-				conflictDigest: await persistenceDigest(observation.kind, selector, observation.detail)
-			};
-			case "corrupt": return {
-				kind: "corrupt",
-				selector,
-				corruptionDigest: await persistenceDigest(observation.kind, selector, observation.detail)
-			};
+			return [];
 		}
-		return assertNever$1(observation);
 	}
-	async lookupByMaterialActivation(input) {
-		const walletIdResult = parseWalletId(input.walletId);
-		const materialActivationResult = parseMpcMaterialActivationRef(input.materialActivation);
-		const capability = materialActivationResult.ok ? materialActivationResult.value.capability : input.materialActivation.capability;
-		if (!walletIdResult.ok || !materialActivationResult.ok) return {
-			kind: "corrupt",
-			capability
-		};
-		const walletId = walletIdResult.value;
-		const materialActivation = materialActivationResult.value;
-		let rows;
+	async takeClientPresignature(input) {
+		if (!supportsStrictIndexedDbDurability()) return { kind: "persistence_unavailable" };
+		const recordId = parseDurableClientPresignatureRecordId(input.recordId);
+		const poolIdentity = parseEcdsaClientPresignPoolIdentity(input.poolIdentity);
+		let row;
 		try {
-			rows = await this.manager.runTransaction([POINTER_STORE], "readonly", async (context) => await readPointerRowsForWallet(context, walletId));
+			const claimed = await this.manager.runTransaction([PRESIGNATURE_STORE], "readwrite", async (context) => {
+				const store = context.store(PRESIGNATURE_STORE);
+				const raw = await store.get(recordId);
+				if (raw === void 0) return { kind: "claimed_elsewhere" };
+				let parsed;
+				try {
+					parsed = parseSealedAvailableClientPresignatureRow(raw);
+				} catch {
+					const malformedRecordId = rawRecordId(raw);
+					if (malformedRecordId) await store.delete(malformedRecordId);
+					return { kind: "corrupt" };
+				}
+				if (!equalEcdsaClientPresignPoolIdentity(parsed.pool_identity, poolIdentity)) {
+					await store.delete(recordId);
+					return { kind: "binding_rejected" };
+				}
+				if (parsed.expires_at_ms <= Date.now()) {
+					await store.delete(recordId);
+					return { kind: "expired" };
+				}
+				await store.delete(recordId);
+				return {
+					kind: "claimed",
+					row: parsed
+				};
+			}, { durability: "strict" });
+			if (claimed.kind !== "claimed") return { kind: claimed.kind };
+			row = claimed.row;
 		} catch {
-			return {
-				kind: "persistence_unavailable",
-				capability
-			};
+			return { kind: "persistence_unavailable" };
 		}
-		const selectors = [];
+		let lookup;
 		try {
-			for (const row of rows) {
-				const pointer = parsePointerRow(row);
-				if (pointer.selector.authority.walletId === walletId) selectors.push(pointer.selector);
-			}
+			lookup = await this.lookupByMaterialRef(row.durable_material_ref);
 		} catch {
-			return {
-				kind: "corrupt",
-				capability
-			};
-		}
-		if (selectors.length === 0) return {
-			kind: "missing",
-			subject: "capability",
-			capability
-		};
-		const exact = [];
-		for (const selector of selectors) {
-			const lookup = await this.lookup(selector);
-			switch (lookup.kind) {
-				case "active":
-					if (mpcMaterialActivationRefsEqual(lookup.manifest.activation.materialActivation, materialActivation) && mpcMaterialActivationRefsEqual(lookup.manifest.durableMaterial.materialActivation, materialActivation) && mpcMaterialActivationRefsEqual(lookup.material.binding.materialActivation, materialActivation)) exact.push(lookup);
-					break;
-				case "retired": break;
-				case "missing": return {
-					kind: "missing",
-					subject: lookup.subject,
-					capability
-				};
-				case "exact_binding_mismatch":
-				case "exact_record_conflict":
-				case "corrupt":
-				case "persistence_unavailable": return {
-					kind: lookup.kind,
-					capability
-				};
-			}
-		}
-		const requested = input.authority;
-		if (requested) {
-			const selected = exact.filter((candidate) => walletAuthAuthorityRefsMatch(candidate.manifest.signer.authority, requested));
-			if (selected.length > 1) return {
-				kind: "exact_record_conflict",
-				capability
-			};
-			return selected[0] ?? {
-				kind: "exact_binding_mismatch",
-				capability
-			};
+			return { kind: "persistence_unavailable" };
 		}
-		if (exact.length > 1) return {
-			kind: "ambiguous_authority",
-			capability,
-			authorities: exact.map((candidate) => candidate.manifest.signer.authority)
-		};
-		return exact[0] ?? {
-			kind: "exact_binding_mismatch",
-			capability
-		};
-	}
-	async openActiveMaterial(selectorInput) {
-		const selector = normalizeSelector(selectorInput);
-		const lookup = await this.lookup(selector);
-		if (lookup.kind !== "active") return lookup;
-		return await this.openActiveMaterialLookup(lookup);
-	}
-	async lookupByMaterialRef(materialRefInput) {
-		const materialRef = parseEcdsaRoleLocalPersistedMaterialRef(materialRefInput);
-		const capability = materialRef.materialActivation.capability;
-		let raw;
+		if (lookup.kind !== "active" || !activeMaterialMatchesPresignature(lookup.material, poolIdentity, row.durable_material_ref) || lookup.material.sealingKeyId !== row.sealed.sealing_key_id) return { kind: "binding_rejected" };
+		let sealingKey;
 		try {
-			raw = await this.manager.runTransaction([MATERIAL_STORE], "readonly", async (context) => await context.store(MATERIAL_STORE).get(materialRef.durableMaterialRef));
+			sealingKey = await this.readMaterialSealingKey(row.sealed.sealing_key_id);
 		} catch {
-			return {
-				kind: "persistence_unavailable",
-				capability
-			};
+			return { kind: "persistence_unavailable" };
 		}
-		if (raw === void 0) return await this.lookupMissingMaterialByRef(materialRef);
-		let locator;
+		if (!sealingKey) return { kind: "corrupt" };
+		const metadata = metadataFromPresignatureRow(row);
 		try {
-			locator = parseMaterialLocator(raw);
-		} catch {
 			return {
-				kind: "corrupt",
-				capability
-			};
-		}
-		if (locator.durableMaterialRef !== materialRef.durableMaterialRef || locator.bindingDigest !== materialRef.bindingDigest) return {
-			kind: "exact_binding_mismatch",
-			capability
-		};
-		const lookup = await this.lookup(locator.selector);
-		switch (lookup.kind) {
-			case "active":
-				if (lookup.manifest.durableMaterial.durableMaterialRef !== materialRef.durableMaterialRef || lookup.manifest.durableMaterial.bindingDigest !== materialRef.bindingDigest || !mpcMaterialActivationRefsEqual(lookup.manifest.activation.materialActivation, materialRef.materialActivation) || !mpcMaterialActivationRefsEqual(lookup.manifest.durableMaterial.materialActivation, materialRef.materialActivation) || !mpcMaterialActivationRefsEqual(lookup.material.binding.materialActivation, materialRef.materialActivation)) return {
-					kind: "exact_binding_mismatch",
-					capability
-				};
-				return lookup;
-			case "retired": return lookup;
-			case "missing": return {
-				kind: "missing",
-				subject: lookup.subject,
-				capability
-			};
-			case "exact_binding_mismatch":
-			case "exact_record_conflict":
-			case "corrupt":
-			case "persistence_unavailable": return {
-				kind: lookup.kind,
-				capability
+				kind: "opened",
+				metadata,
+				plaintext97: await decryptPresignatureBytes({
+					key: sealingKey,
+					metadata,
+					sealed: row.sealed
+				})
 			};
+		} catch {
+			return { kind: "corrupt" };
 		}
-		return assertNever$1(lookup);
 	}
-	async lookupMissingMaterialByRef(materialRef) {
-		const capability = materialRef.materialActivation.capability;
+	async deleteClientPresignature(input) {
+		const recordId = parseDurableClientPresignatureRecordId(input.recordId);
+		const poolIdentity = parseEcdsaClientPresignPoolIdentity(input.poolIdentity);
+		await this.manager.runTransaction([PRESIGNATURE_STORE], "readwrite", async (context) => {
+			const store = context.store(PRESIGNATURE_STORE);
+			const raw = await store.get(recordId);
+			if (raw === void 0) return;
+			if (equalEcdsaClientPresignPoolIdentity(parseSealedAvailableClientPresignatureRow(raw).pool_identity, poolIdentity)) await store.delete(recordId);
+		});
+	}
+	async deleteClientPresignatures(target) {
+		return await this.manager.runTransaction([PRESIGNATURE_STORE], "readwrite", async (context) => {
+			const store = context.store(PRESIGNATURE_STORE);
+			let deletedCount = 0;
+			switch (target.kind) {
+				case "wallet": {
+					const walletId = String(target.walletId).trim();
+					if (!walletId) throw new Error("ECDSA durable presignature wallet id is required");
+					deletedCount = await deleteCursorRows(await store.index(SEAMS_WALLET_INDEXES.walletId).openCursor(walletId));
+					break;
+				}
+				case "all":
+					deletedCount = await deleteCursorRows(await store.openCursor());
+					break;
+			}
+			return deletedCount;
+		});
+	}
+	async listActiveWalletCapabilitySubjects(walletIdInput) {
+		const parsedWalletId = parseWalletId(walletIdInput);
+		if (!parsedWalletId.ok) return { kind: "invalid_current_state" };
 		let rows;
 		try {
-			rows = await this.manager.runTransaction([MANIFEST_STORE], "readonly", async (context) => await context.store(MANIFEST_STORE).getAll());
+			rows = await this.manager.runTransaction([POINTER_STORE], "readonly", (context) => readPointerRowsForWallet(context, parsedWalletId.value));
 		} catch {
-			return {
-				kind: "persistence_unavailable",
-				capability
-			};
+			return { kind: "persistence_unavailable" };
 		}
-		const exact = [];
-		let bindingMismatch = false;
-		for (const raw of rows) {
-			let parsed;
-			try {
-				parsed = parseManifestRow(raw);
-			} catch {
-				return {
-					kind: "corrupt",
-					capability
-				};
-			}
-			const durableMaterial = parsed.activeProof.durableMaterial;
-			if (durableMaterial.durableMaterialRef !== materialRef.durableMaterialRef) continue;
-			if (durableMaterial.bindingDigest !== materialRef.bindingDigest || !mpcMaterialActivationRefsEqual(durableMaterial.materialActivation, materialRef.materialActivation)) {
-				bindingMismatch = true;
-				continue;
+		const selectors = [];
+		try {
+			for (const row of rows) {
+				const pointer = parsePointerRow(row);
+				if (pointer.selector.authority.walletId === parsedWalletId.value) selectors.push(pointer.selector);
 			}
-			exact.push(parsed);
+		} catch {
+			return { kind: "invalid_current_state" };
+		}
+		const subjects = [];
+		for (const selector of selectors) {
+			const lookup = await this.lookup(selector);
+			if (lookup.kind === "persistence_unavailable") return { kind: "persistence_unavailable" };
+			if (lookup.kind !== "active") return { kind: "invalid_current_state" };
+			subjects.push({
+				capability: lookup.manifest.signer.capability,
+				authority: lookup.manifest.signer.authority,
+				ecdsaThresholdKeyId: lookup.manifest.durableMaterial.roleLocalBinding.ecdsaThresholdKeyId
+			});
 		}
-		if (exact.length > 1) return {
-			kind: "exact_record_conflict",
-			capability
-		};
-		const [matched] = exact;
-		if (!matched) return bindingMismatch ? {
-			kind: "exact_binding_mismatch",
-			capability
-		} : {
-			kind: "missing",
-			subject: "material",
-			capability
-		};
-		if (matched.state === "replaced") return {
-			kind: "retired",
-			manifest: matched.manifest
-		};
 		return {
-			kind: "missing",
-			subject: "material",
-			capability
+			kind: "resolved",
+			subjects
 		};
 	}
-	async openActiveMaterialLookup(lookup) {
-		const selector = selectorFromManifest(lookup.manifest);
-		try {
-			if (await ciphertextDigestB64u(lookup.material.ciphertextB64u) !== lookup.material.binding.ciphertextDigest) throw new Error("active ECDSA material ciphertext digest is invalid");
-			const sealingKey = await this.readMaterialSealingKey(lookup.material.sealingKeyId);
-			if (!sealingKey) throw new Error("active ECDSA material sealing key is missing");
-			return {
-				kind: "active",
-				manifest: lookup.manifest,
-				readyStateBlobB64u: await decryptStateBlob({
-					key: sealingKey,
-					iv12B64u: lookup.material.iv12B64u,
-					ciphertextB64u: lookup.material.ciphertextB64u,
-					aadProjection: readyAadProjection(lookup.manifest)
-				})
-			};
-		} catch (error) {
-			return {
-				kind: "corrupt",
-				selector,
-				corruptionDigest: await persistenceDigest("active_material_open_corrupt", selector, errorMessage(error))
-			};
-		}
-	}
-	async openActiveMaterialByRef(materialRefInput) {
-		let lookup;
+	async listWalletActivationJournalSelectors(walletIdInput) {
+		const parsedWalletId = parseWalletId(walletIdInput);
+		if (!parsedWalletId.ok) return { kind: "invalid_current_state" };
+		let rows;
 		try {
-			lookup = await this.lookupByMaterialRef(materialRefInput);
+			rows = await this.manager.runTransaction([JOURNAL_STORE], "readonly", readActivationJournalRows);
 		} catch {
-			return { kind: "corrupt" };
+			return { kind: "persistence_unavailable" };
 		}
-		switch (lookup.kind) {
-			case "active": {
-				const opened = await this.openActiveMaterialLookup(lookup);
-				switch (opened.kind) {
-					case "active": return opened;
-					case "missing":
-					case "retired": return { kind: "missing" };
-					case "exact_binding_mismatch": return { kind: "binding_mismatch" };
-					case "exact_record_conflict":
-					case "corrupt": return { kind: "corrupt" };
-					case "persistence_unavailable": return { kind: "persistence_unavailable" };
-				}
-				return assertNever$1(opened);
+		const selectors = [];
+		try {
+			for (const row of rows) {
+				const signer = parseJournalRow(row).journal.candidate.activationBinding.signer;
+				if (signer.authority.walletId !== parsedWalletId.value) continue;
+				selectors.push(selectorFromSigner(signer));
 			}
-			case "missing":
-			case "retired": return { kind: "missing" };
-			case "exact_binding_mismatch": return { kind: "binding_mismatch" };
-			case "exact_record_conflict":
-			case "corrupt": return { kind: "corrupt" };
-			case "persistence_unavailable": return { kind: "persistence_unavailable" };
+		} catch {
+			return { kind: "invalid_current_state" };
 		}
-		return assertNever$1(lookup);
+		return {
+			kind: "resolved",
+			selectors
+		};
 	}
-	async sealAndFinalizeActivation(input) {
-		const selector = selectorFromJournal(input.committedJournal);
+	async prepareActivation(input) {
+		const selector = selectorFromSigner(input.activationBinding.signer);
 		try {
-			const parsedJournal = parseCommittedJournal(input.committedJournal);
-			const sealingKeyId = parsedJournal.candidate.encryptedPending.sealingKeyId;
-			const sealingKey = await this.readMaterialSealingKey(sealingKeyId);
-			if (!sealingKey) throw new Error("ECDSA activation material sealing key is missing");
+			const keyId = parseEcdsaMaterialSealingKeyId(secureRandomId("ecdsa-material-key", 32, "ECDSA activation material sealing key"));
+			const key = await generateMaterialSealingKey();
 			const encrypted = await encryptStateBlob({
-				key: sealingKey,
-				stateBlobB64u: input.readyStateBlobB64u,
-				aadProjection: readyAadProjection(parsedJournal)
-			});
-			const durableMaterial = buildDurableEcdsaMaterialBinding({
-				activationBinding: parsedJournal.candidate.activationBinding,
-				serverActivation: parsedJournal.serverActivation,
-				routerAbEcdsaDerivationNormalSigning: input.routerAbEcdsaDerivationNormalSigning,
-				roleLocalPublicFacts: buildEcdsaRoleLocalPublicFacts(input.roleLocalPublicFacts),
-				ciphertextDigest: parseEcdsaCiphertextDigest(encrypted.digestB64u),
-				runtimePolicyScope: input.runtimePolicyScope
-			});
-			const readyMaterial = buildValidatedEncryptedEcdsaReadyMaterial({
-				binding: durableMaterial,
-				sealingKeyId,
-				iv12B64u: encrypted.iv12B64u,
-				ciphertextB64u: encrypted.ciphertextB64u
+				key,
+				stateBlobB64u: input.pendingPayloadB64u,
+				aadProjection: pendingAadProjection(input)
 			});
-			const activeManifest = buildActiveEcdsaCapabilityManifest({
-				activationBinding: parsedJournal.candidate.activationBinding,
-				serverActivation: parsedJournal.serverActivation,
-				registeredPublicFacts: input.registeredPublicFacts,
-				durableMaterial,
-				committedAt: input.committedAt
+			const journal = buildPreparedJournalFromEncryptedCandidate({
+				preparation: input,
+				encryptedPending: buildEncryptedEcdsaPendingCandidate({
+					sealingKeyId: keyId,
+					iv12B64u: encrypted.iv12B64u,
+					ciphertextB64u: encrypted.ciphertextB64u,
+					ciphertextDigest: parseEcdsaPendingCiphertextDigest(encrypted.digestB64u)
+				})
 			});
-			return await this.finalizeActivation({
-				committedJournal: parsedJournal,
-				readyMaterial,
-				activeManifest
+			await this.manager.runTransaction([SEALING_KEY_STORE, JOURNAL_STORE], "readwrite", async (context) => {
+				await context.store(SEALING_KEY_STORE).add(storedSealingKeyRow(keyId, key));
+				await context.store(JOURNAL_STORE).add(storedJournalRow(journal));
 			});
-		} catch (error) {
 			return {
-				kind: "corrupt",
-				selector,
-				corruptionDigest: await persistenceDigest("activation_seal_corrupt", selector, errorMessage(error))
-			};
-		}
-	}
-	async importCommittedWalletCustodyActivation(input) {
-		const serverActivation = buildEcdsaServerActivationCommit({
-			activationBinding: input.activationBinding,
-			serverCommit: input.serverCommit
-		});
-		const selector = {
-			capability: input.activationBinding.signer.capability,
-			authority: input.activationBinding.signer.authority
-		};
-		const existing = await this.lookup(selector);
-		if (existing.kind === "active") {
-			if (activeManifestMatchesWalletCustodyImport({
-				manifest: existing.manifest,
-				activationBinding: input.activationBinding,
-				serverActivation,
-				registeredPublicFacts: input.registeredPublicFacts,
-				roleLocalPublicFacts: input.roleLocalPublicFacts,
-				routerAbEcdsaDerivationNormalSigning: input.routerAbEcdsaDerivationNormalSigning,
-				runtimePolicyScope: input.runtimePolicyScope
-			})) return {
-				kind: "committed",
-				manifest: existing.manifest,
-				material: existing.material
+				kind: "stored",
+				journal
 			};
-			return {
-				kind: "exact_record_conflict",
-				selector,
-				conflictDigest: await persistenceDigest("custody_import_conflict", selector, "ECDSA custody import conflicts with the active manifest")
+		} catch (error) {
+			if (isConstraintError(error)) return await journalConstraintConflict(selector, error);
+			if (error instanceof DOMException && error.name === "OperationError") return {
+				kind: "corrupt",
+				corruptionDigest: await persistenceDigest("journal_encryption_failed", selector, ecdsaManifestErrorMessage(error))
 			};
-		}
-		try {
-			const prepared = await prepareImportedWalletCustodyEcdsaContinuity(input);
-			await this.manager.runTransaction([
-				MANIFEST_STORE,
-				POINTER_STORE,
-				MATERIAL_STORE,
-				SEALING_KEY_STORE
-			], "readwrite", (context) => persistPreparedImportedWalletCustodyEcdsaContinuityInTransaction(context, prepared));
-			return {
-				kind: "committed",
-				manifest: prepared.activeManifest,
-				material: prepared.readyMaterial
+			if (error instanceof Error && !(error instanceof DOMException)) return {
+				kind: "corrupt",
+				corruptionDigest: await persistenceDigest("journal_preparation_invalid", selector, error.message)
 			};
-		} catch (error) {
-			if (error instanceof FinalizationControlError || isConstraintError(error)) {
-				const replay = await this.lookup(selector);
-				if (replay.kind === "active" && activeManifestMatchesWalletCustodyImport({
-					manifest: replay.manifest,
-					activationBinding: input.activationBinding,
-					serverActivation,
-					registeredPublicFacts: input.registeredPublicFacts,
-					roleLocalPublicFacts: input.roleLocalPublicFacts,
-					routerAbEcdsaDerivationNormalSigning: input.routerAbEcdsaDerivationNormalSigning,
-					runtimePolicyScope: input.runtimePolicyScope
-				})) return {
-					kind: "committed",
-					manifest: replay.manifest,
-					material: replay.material
-				};
-				return {
-					kind: "exact_record_conflict",
-					selector,
-					conflictDigest: await persistenceDigest("custody_import_conflict", selector, errorMessage(error))
-				};
-			}
 			return {
-				kind: "corrupt",
-				selector,
-				corruptionDigest: await persistenceDigest("custody_import_corrupt", selector, errorMessage(error))
+				kind: "persistence_unavailable",
+				retryCorrelation: retryCorrelation()
 			};
 		}
 	}
-	async persistPreparedWalletCustodyEcdsaContinuity(prepared) {
-		await this.manager.runTransaction([
-			MANIFEST_STORE,
-			POINTER_STORE,
-			MATERIAL_STORE,
-			SEALING_KEY_STORE
-		], "readwrite", (context) => persistPreparedImportedWalletCustodyEcdsaContinuityInTransaction(context, prepared));
-	}
-	async readMaterialSealingKey(keyIdInput) {
-		const keyId = parseEcdsaMaterialSealingKeyId(keyIdInput);
-		const raw = await this.manager.runTransaction([SEALING_KEY_STORE], "readonly", async (context) => await context.store(SEALING_KEY_STORE).get(keyId));
-		if (raw === void 0) return null;
-		const parsed = parseSealingKeyRow(raw);
-		if (parsed.keyId !== keyId) throw new Error("ECDSA material sealing key row identity is inconsistent");
-		return parsed.key;
+	async recordServerActivation(input) {
+		let committedJournal;
+		try {
+			committedJournal = buildServerCommittedEcdsaActivationJournal(input);
+		} catch (error) {
+			return {
+				kind: "corrupt",
+				corruptionDigest: await persistenceDigest("server_activation_commit_corrupt", selectorFromJournal(input.preparedJournal), ecdsaManifestErrorMessage(error))
+			};
+		}
+		return await this.putActivationJournal(committedJournal);
 	}
-	async finalizeActivation(input) {
-		let activeProof;
+	async putActivationJournal(journalInput) {
+		let journal;
 		try {
-			activeProof = assertActiveProofInput(input);
+			journal = parseCommittedJournal(journalInput);
+			if (await ciphertextDigestB64u(journal.candidate.encryptedPending.ciphertextB64u) !== journal.candidate.encryptedPending.ciphertextDigest) throw new Error("ECDSA pending material ciphertext digest is invalid");
 		} catch (error) {
-			const selector = selectorFromJournal(input.committedJournal);
 			return {
 				kind: "corrupt",
-				selector,
-				corruptionDigest: await persistenceDigest("finalization_input_corrupt", selector, errorMessage(error))
+				corruptionDigest: await persistenceDigest("journal_input_corrupt", selectorFromJournal(journalInput), ecdsaManifestErrorMessage(error))
 			};
 		}
-		const selector = selectorFromManifest(activeProof.activeManifest);
+		const selector = selectorFromJournal(journal);
 		try {
-			if (await ciphertextDigestB64u(input.readyMaterial.ciphertextB64u) !== input.readyMaterial.binding.ciphertextDigest) throw new FinalizationControlError("corrupt", "ECDSA ready material ciphertext digest is invalid");
-			const sealingKey = await this.readMaterialSealingKey(input.readyMaterial.sealingKeyId);
-			if (!sealingKey) throw new FinalizationControlError("corrupt", "ECDSA ready material sealing key is missing");
+			const sealingKey = await this.readMaterialSealingKey(journal.candidate.encryptedPending.sealingKeyId);
+			if (!sealingKey) throw new FinalizationControlError("corrupt", "ECDSA activation journal references a missing sealing key");
 			await decryptStateBlob({
 				key: sealingKey,
-				iv12B64u: input.readyMaterial.iv12B64u,
-				ciphertextB64u: input.readyMaterial.ciphertextB64u,
-				aadProjection: readyAadProjection(input.committedJournal)
+				iv12B64u: journal.candidate.encryptedPending.iv12B64u,
+				ciphertextB64u: journal.candidate.encryptedPending.ciphertextB64u,
+				aadProjection: pendingAadProjection(journal)
 			});
-			await this.manager.runTransaction([
-				MANIFEST_STORE,
-				POINTER_STORE,
-				MATERIAL_STORE,
-				JOURNAL_STORE,
-				SEALING_KEY_STORE,
-				PRESIGNATURE_STORE
-			], "readwrite", async (context) => {
-				await finalizeInTransaction(context, input, activeProof, selector);
+			await this.manager.runTransaction([SEALING_KEY_STORE, JOURNAL_STORE], "readwrite", async (context) => {
+				const sealingKeyRaw = await context.store(SEALING_KEY_STORE).get(journal.candidate.encryptedPending.sealingKeyId);
+				if (sealingKeyRaw === void 0) throw new FinalizationControlError("corrupt", "ECDSA activation journal references a missing sealing key");
+				try {
+					parseSealingKeyRow(sealingKeyRaw);
+				} catch (error) {
+					throw new FinalizationControlError("corrupt", ecdsaManifestErrorMessage(error));
+				}
+				const journalStore = context.store(JOURNAL_STORE);
+				const existingRaw = await journalStore.get(journal.journalId);
+				if (existingRaw === void 0) throw new FinalizationControlError("exact_record_conflict", "ECDSA committed activation is missing its prepared journal");
+				let existing;
+				try {
+					existing = parseJournalRow(existingRaw);
+				} catch (error) {
+					throw new FinalizationControlError("corrupt", ecdsaManifestErrorMessage(error));
+				}
+				if (!selectorsMatch(existing.selector, selector) || existing.journal.kind === "activation_prepared" && !ecdsaActivationCommitJournalsMatch(existing.journal, preparedJournalProjection(journal)) || existing.journal.kind === "server_activation_committed" && !ecdsaActivationCommitJournalsMatch(existing.journal, journal)) throw new FinalizationControlError("exact_record_conflict", "ECDSA activation journal conflicts with its existing correlation");
+				await journalStore.put(storedJournalRow(journal));
 			});
 			return {
-				kind: "committed",
-				manifest: activeProof.activeManifest,
-				material: input.readyMaterial
+				kind: "stored",
+				journal
 			};
 		} catch (error) {
 			if (error instanceof FinalizationControlError) {
-				const digest = await persistenceDigest(error.kind === "corrupt" ? "finalization_corrupt" : "finalization_conflict", selector, error.message);
+				const digest = await persistenceDigest(error.kind === "corrupt" ? "journal_corrupt" : "journal_conflict", selector, error.message);
 				return error.kind === "corrupt" ? {
 					kind: "corrupt",
-					selector,
 					corruptionDigest: digest
 				} : {
 					kind: "exact_record_conflict",
-					selector,
 					conflictDigest: digest
 				};
 			}
-			if (isConstraintError(error)) return {
-				kind: "exact_record_conflict",
-				selector,
-				conflictDigest: await persistenceDigest("finalization_constraint_conflict", selector, errorMessage(error))
+			if (isConstraintError(error)) return await journalConstraintConflict(selector, error);
+			if (error instanceof DOMException && error.name === "OperationError") return {
+				kind: "corrupt",
+				corruptionDigest: await persistenceDigest("journal_ciphertext_corrupt", selector, ecdsaManifestErrorMessage(error))
 			};
 			return {
 				kind: "persistence_unavailable",
-				selector,
 				retryCorrelation: retryCorrelation()
 			};
 		}
 	}
-};
-function buildWalletCustodyEcdsaContinuityImportInput(input) {
-	const authority = parseWalletAuthAuthorityRef(input.authority);
-	if (!authority || String(authority.walletId) !== String(input.walletId)) throw new Error("ECDSA custody import authority is invalid");
-	const publicCapability = parseRouterAbEcdsaDerivationPublicCapabilityV1(input.publicCapability);
-	const receipt = parseRouterAbEcdsaRegistrationActivationReceiptV1(input.activationReceipt);
-	const materialActivation = routerAbMpcMaterialActivationRefFromWire(receipt.ecdsa_activation.material_activation);
-	if (!mpcMaterialActivationRefsEqual(materialActivation, routerAbMpcMaterialActivationRefFromWire(publicCapability.material_activation))) throw new Error("ECDSA custody continuity changed the material activation");
-	const participantIds = [toParticipantId(input.participantIds[0]), toParticipantId(input.participantIds[1])];
-	const roleLocalBinding = buildEcdsaRoleLocalMaterialBinding({
-		keyHandle: parseEcdsaKeyHandle(input.keyHandle),
-		ecdsaThresholdKeyId: parseEcdsaThresholdKeyId(input.ecdsaThresholdKeyId),
-		clientVerifyingPublicKey33B64u: parseEcdsaClientVerifyingPublicKey33B64u(input.publicFacts.derivationClientSharePublicKey33B64u),
-		participantIds,
-		relayerKeyId: parseEcdsaRelayerKeyId(input.relayerKeyId)
-	});
-	const signer = buildPreparedEvmFamilySigner({
-		capability: materialActivation.capability,
-		signerId: parseEvmFamilyEcdsaSignerId(secureRandomId("ecdsa-signer", 32, "ECDSA custody signer identities")),
-		authority,
-		scope: buildEcdsaCapabilityScope({ targetMemberships: input.chainTargets }),
-		materialOwner: materialActivation.materialOwner,
-		signingRootId: parseSdkEcdsaDerivationSigningRootId(input.signingRootId),
-		signingRootVersion: parseSdkEcdsaDerivationSigningRootVersion(input.signingRootVersion)
-	});
-	const activationBinding = buildEcdsaActivationBinding({
-		targetManifest: buildEcdsaManifestIdentity({
-			manifestId: parseEcdsaCapabilityManifestId(secureRandomId("ecdsa-manifest", 32, "ECDSA custody manifest identities")),
-			manifestRevision: parseEcdsaCapabilityManifestRevision(1)
-		}),
-		signer,
-		roleLocalBinding,
-		bindingDigest: parseEcdsaRoleLocalBindingDigest(input.publicFacts.contextBinding32B64u),
-		durableMaterialRef: parseEcdsaRoleLocalDurableMaterialRef(secureRandomId("ecdsa-role-local-material", 32, "ECDSA custody material identities"))
-	});
-	const ethereumAddress = input.publicFacts.ethereumAddress;
-	const registeredPublicFacts = buildVerifiedEcdsaPublicFacts({
-		keyHandle: toEvmFamilyEcdsaKeyHandle(input.keyHandle),
-		publicKeyB64u: input.publicFacts.groupPublicKey33B64u,
-		participantIds,
-		thresholdOwnerAddress: ethereumAddress
-	});
-	const roleLocalPublicFacts = buildEcdsaRoleLocalPublicFacts({
-		walletId: authority.walletId,
-		chainTarget: input.chainTargets[0],
-		keyHandle: roleLocalBinding.keyHandle,
-		ecdsaThresholdKeyId: roleLocalBinding.ecdsaThresholdKeyId,
-		signingRootId: signer.signingRootId,
-		signingRootVersion: signer.signingRootVersion,
-		applicationBindingDigestB64u: publicCapability.context.application_binding_digest_b64u,
-		clientParticipantId: participantIds[0],
-		relayerParticipantId: participantIds[1],
-		participantIds,
-		contextBinding32B64u: input.publicFacts.contextBinding32B64u,
-		derivationClientSharePublicKey33B64u: input.publicFacts.derivationClientSharePublicKey33B64u,
-		relayerPublicKey33B64u: input.publicFacts.relayerPublicKey33B64u,
-		groupPublicKey33B64u: input.publicFacts.groupPublicKey33B64u,
-		ethereumAddress,
-		publicCapability
-	});
-	const normalSigning = {
-		kind: "router_ab_ecdsa_derivation_normal_signing_v1",
-		scope: {
-			wallet_id: String(authority.walletId),
-			ecdsa_threshold_key_id: String(roleLocalBinding.ecdsaThresholdKeyId),
-			signing_root_id: String(signer.signingRootId),
-			signing_root_version: String(signer.signingRootVersion),
-			context: receipt.ecdsa_activation.context,
-			public_identity: receipt.ecdsa_activation.public_identity,
-			material_activation: receipt.ecdsa_activation.material_activation,
-			signing_worker: receipt.ecdsa_activation.signing_worker,
-			activation_epoch: receipt.ecdsa_activation.activation_epoch
+	async readActivationJournal(journalIdInput) {
+		const journalId = parseCorrelationId(journalIdInput);
+		try {
+			const raw = await this.manager.runTransaction([JOURNAL_STORE], "readonly", async (context) => await context.store(JOURNAL_STORE).get(journalId));
+			if (raw === void 0) return { kind: "missing" };
+			try {
+				const parsed = parseJournalRow(raw);
+				return parsed.journal.journalId === journalId ? {
+					kind: "found",
+					journal: parsed.journal
+				} : { kind: "corrupt" };
+			} catch {
+				return { kind: "corrupt" };
+			}
+		} catch {
+			return { kind: "persistence_unavailable" };
 		}
-	};
-	return {
-		activationBinding,
-		serverCommit: {
-			correlationId: receipt.activation_correlation_id,
-			activationRequestDigest: parseDigestB64u(base64UrlEncode(Uint8Array.from(receipt.activation_request_digest.bytes))),
-			serverGeneration: receipt.server_generation,
-			protocolReceipt: receipt
-		},
-		readyStateBlobB64u: input.readyStateBlobB64u,
-		registeredPublicFacts,
-		roleLocalPublicFacts,
-		routerAbEcdsaDerivationNormalSigning: normalSigning,
-		runtimePolicyScope: normalizeRuntimePolicyScope(input.runtimePolicyScope),
-		committedAt: parseIsoTimestamp(new Date(receipt.ecdsa_activation.activated_at_ms).toISOString())
-	};
-}
-async function prepareWalletCustodyEcdsaContinuity(input) {
-	return prepareImportedWalletCustodyEcdsaContinuity(buildWalletCustodyEcdsaContinuityImportInput(input));
-}
-async function importWalletCustodyEcdsaContinuity(input) {
-	const preparedInput = buildWalletCustodyEcdsaContinuityImportInput(input);
-	const serverActivation = buildEcdsaServerActivationCommit({
-		activationBinding: preparedInput.activationBinding,
-		serverCommit: preparedInput.serverCommit
-	});
-	const selector = {
-		capability: preparedInput.activationBinding.signer.capability,
-		authority: preparedInput.activationBinding.signer.authority
-	};
-	const existing = await input.store.lookup(selector);
-	if (existing.kind === "active") {
-		if (activeManifestMatchesWalletCustodyImport({
-			manifest: existing.manifest,
-			activationBinding: preparedInput.activationBinding,
-			serverActivation,
-			registeredPublicFacts: preparedInput.registeredPublicFacts,
-			roleLocalPublicFacts: preparedInput.roleLocalPublicFacts,
-			routerAbEcdsaDerivationNormalSigning: preparedInput.routerAbEcdsaDerivationNormalSigning,
-			runtimePolicyScope: preparedInput.runtimePolicyScope
-		})) return {
-			kind: "committed",
-			manifest: existing.manifest,
-			material: existing.material
-		};
-		return {
-			kind: "exact_record_conflict",
-			selector,
-			conflictDigest: await persistenceDigest("custody_import_conflict", selector, "ECDSA custody import conflicts with the active manifest")
-		};
 	}
-	try {
-		const prepared = await prepareImportedWalletCustodyEcdsaContinuity(preparedInput);
-		await input.store.persistPreparedWalletCustodyEcdsaContinuity(prepared);
-		return {
-			kind: "committed",
-			manifest: prepared.activeManifest,
-			material: prepared.readyMaterial
-		};
-	} catch (error) {
-		if (error instanceof FinalizationControlError || isConstraintError(error)) {
-			const replay = await input.store.lookup(selector);
-			if (replay.kind === "active" && activeManifestMatchesWalletCustodyImport({
-				manifest: replay.manifest,
-				activationBinding: preparedInput.activationBinding,
-				serverActivation,
-				registeredPublicFacts: preparedInput.registeredPublicFacts,
-				roleLocalPublicFacts: preparedInput.roleLocalPublicFacts,
-				routerAbEcdsaDerivationNormalSigning: preparedInput.routerAbEcdsaDerivationNormalSigning,
-				runtimePolicyScope: preparedInput.runtimePolicyScope
-			})) return {
-				kind: "committed",
-				manifest: replay.manifest,
-				material: replay.material
+	async discoverActivationJournal(selectorInput) {
+		let selector;
+		try {
+			selector = normalizeSelector(selectorInput);
+		} catch {
+			return { kind: "corrupt" };
+		}
+		try {
+			const raw = await this.manager.runTransaction([JOURNAL_STORE], "readonly", async (context) => await context.store(JOURNAL_STORE).index(SEAMS_WALLET_INDEXES.capabilityWalletAuthority).get(selectorKey(selector)));
+			if (raw === void 0) return { kind: "missing" };
+			try {
+				const parsed = parseJournalRow(raw);
+				return selectorsMatch(parsed.selector, selector) ? {
+					kind: "found",
+					journal: parsed.journal
+				} : { kind: "corrupt" };
+			} catch {
+				return { kind: "corrupt" };
+			}
+		} catch {
+			return { kind: "persistence_unavailable" };
+		}
+	}
+	async cancelPreparedActivation(preparedJournal) {
+		try {
+			return await this.manager.runTransaction([SEALING_KEY_STORE, JOURNAL_STORE], "readwrite", cancelPreparedActivationInTransaction.bind(void 0, preparedJournal));
+		} catch {
+			return { kind: "persistence_unavailable" };
+		}
+	}
+	async openPreparedActivation(journalIdInput) {
+		const read = await this.readActivationJournal(journalIdInput);
+		if (read.kind !== "found") return read;
+		const encryptedPending = read.journal.candidate.encryptedPending;
+		try {
+			if (await ciphertextDigestB64u(encryptedPending.ciphertextB64u) !== encryptedPending.ciphertextDigest) return { kind: "corrupt" };
+			const sealingKey = await this.readMaterialSealingKey(encryptedPending.sealingKeyId);
+			if (!sealingKey) return { kind: "corrupt" };
+			return {
+				kind: "found",
+				journal: read.journal,
+				pendingPayloadB64u: await decryptStateBlob({
+					key: sealingKey,
+					iv12B64u: encryptedPending.iv12B64u,
+					ciphertextB64u: encryptedPending.ciphertextB64u,
+					aadProjection: pendingAadProjection(read.journal)
+				})
 			};
+		} catch {
+			return { kind: "corrupt" };
+		}
+	}
+	async lookup(selectorInput) {
+		const selector = normalizeSelector(selectorInput);
+		let observation;
+		try {
+			observation = await this.manager.runTransaction([
+				MANIFEST_STORE,
+				POINTER_STORE,
+				MATERIAL_STORE,
+				SEALING_KEY_STORE
+			], "readonly", async (context) => await lookupInTransaction(context, selector));
+		} catch {
 			return {
+				kind: "persistence_unavailable",
+				selector,
+				retryCorrelation: retryCorrelation()
+			};
+		}
+		switch (observation.kind) {
+			case "active": return observation;
+			case "retired": return observation;
+			case "missing": return {
+				kind: "missing",
+				selector,
+				subject: observation.subject
+			};
+			case "exact_binding_mismatch": return {
+				kind: "exact_binding_mismatch",
+				selector,
+				failureDigest: await persistenceDigest(observation.kind, selector, observation.detail)
+			};
+			case "exact_record_conflict": return {
 				kind: "exact_record_conflict",
 				selector,
-				conflictDigest: await persistenceDigest("custody_import_conflict", selector, errorMessage(error))
+				conflictDigest: await persistenceDigest(observation.kind, selector, observation.detail)
+			};
+			case "corrupt": return {
+				kind: "corrupt",
+				selector,
+				corruptionDigest: await persistenceDigest(observation.kind, selector, observation.detail)
 			};
 		}
-		return {
-			kind: "corrupt",
-			selector,
-			corruptionDigest: await persistenceDigest("custody_import_corrupt", selector, errorMessage(error))
-		};
-	}
-}
-async function assertSharedWalletAuthorityMembership(input) {
-	const repositories = new SeamsWalletRepositories(seamsWalletDB);
-	for (const walletAuthMethodId of input.walletAuthMethodIds) {
-		const authMethod = await repositories.getWalletAuthMethodV2(String(walletAuthMethodId));
-		if (!authMethod || authMethod.status !== "active" || authMethod.walletId !== input.walletId || authMethod.walletAuthorityId !== input.walletAuthorityId) throw new Error(`ECDSA custody continuity method ${String(walletAuthMethodId)} is not an active member of the wallet authority`);
+		return assertNever$1(observation);
 	}
-}
-/**
-* R109C: give an added auth method its own encrypted access projection over the
-* activation the wallet already has. The activation is not re-created and the
-* source credential's authority is not widened; only a second method-bound
-* record over the same material appears.
-*
-* The membership check is the whole safety argument. Copying access to a method
-* on another wallet authority would hand that credential custody it was never
-* granted, so both methods are read back and required to be active members of
-* the exact same authority before anything is opened.
-*/
-async function copyWalletCustodyEcdsaContinuityToAuthMethod(input) {
-	if (input.targetAuthority.walletId !== input.walletId || input.targetAuthority.walletAuthMethodId === input.sourceWalletAuthMethodId) throw new Error("ECDSA custody continuity target is invalid");
-	await assertSharedWalletAuthorityMembership({
-		walletId: input.walletId,
-		walletAuthorityId: input.walletAuthorityId,
-		walletAuthMethodIds: [input.sourceWalletAuthMethodId, input.targetAuthority.walletAuthMethodId]
-	});
-	const store = new IndexedDbEcdsaCapabilityManifestStore();
-	const listed = await store.listActiveWalletCapabilitySubjects(input.walletId);
-	if (listed.kind !== "resolved") throw new Error(`ECDSA custody continuity inventory is ${listed.kind}`);
-	if (listed.subjects.length === 0) return;
-	const sources = listed.subjects.filter((subject) => subject.authority.walletAuthMethodId === input.sourceWalletAuthMethodId);
-	if (sources.length === 0) throw new Error(`ECDSA custody continuity found no active capability for source method ${String(input.sourceWalletAuthMethodId)} among [${listed.subjects.map((subject) => String(subject.authority.walletAuthMethodId)).join(", ")}]`);
-	for (const source of sources) {
-		const sourceLookup = await store.lookup(source);
-		if (sourceLookup.kind !== "active") throw new Error(`ECDSA custody continuity source is ${sourceLookup.kind}`);
-		const targetSelector = {
-			capability: source.capability,
-			authority: input.targetAuthority
+	async lookupByMaterialActivation(input) {
+		const walletIdResult = parseWalletId(input.walletId);
+		const materialActivationResult = parseMpcMaterialActivationRef(input.materialActivation);
+		const capability = materialActivationResult.ok ? materialActivationResult.value.capability : input.materialActivation.capability;
+		if (!walletIdResult.ok || !materialActivationResult.ok) return {
+			kind: "corrupt",
+			capability
 		};
-		const targetLookup = await store.lookup(targetSelector);
-		if (targetLookup.kind === "active") {
-			const targetMaterial = targetLookup.manifest.durableMaterial;
-			const sourceMaterial = sourceLookup.manifest.durableMaterial;
-			if (targetMaterial.activationDigest !== sourceMaterial.activationDigest || targetMaterial.bindingDigest !== sourceMaterial.bindingDigest || targetMaterial.roleLocalBinding.ecdsaThresholdKeyId !== sourceMaterial.roleLocalBinding.ecdsaThresholdKeyId || !ecdsaRoleLocalMaterialBindingsMatch(targetMaterial.roleLocalBinding, sourceMaterial.roleLocalBinding) || !ecdsaRoleLocalPublicFactsMatch(targetMaterial.roleLocalPublicFacts, sourceMaterial.roleLocalPublicFacts) || !ecdsaRegisteredPublicFactsMatch(targetLookup.manifest.signer.registeredPublicFacts, sourceLookup.manifest.signer.registeredPublicFacts)) throw new Error("ECDSA custody continuity target conflicts with source material");
-			continue;
+		const walletId = walletIdResult.value;
+		const materialActivation = materialActivationResult.value;
+		let rows;
+		try {
+			rows = await this.manager.runTransaction([POINTER_STORE], "readonly", async (context) => await readPointerRowsForWallet(context, walletId));
+		} catch {
+			return {
+				kind: "persistence_unavailable",
+				capability
+			};
 		}
-		if (targetLookup.kind !== "missing") throw new Error(`ECDSA custody continuity target is ${targetLookup.kind}`);
-		const opened = await store.openActiveMaterialLookup(sourceLookup);
-		if (opened.kind !== "active") throw new Error(`ECDSA custody continuity material is ${opened.kind}`);
-		const manifest = opened.manifest;
-		const publicFacts = manifest.durableMaterial.roleLocalPublicFacts;
-		const imported = await importWalletCustodyEcdsaContinuity({
-			store,
-			authority: input.targetAuthority,
-			chainTargets: manifest.signer.scope.targetMemberships,
-			walletId: String(input.walletId),
-			keyHandle: publicFacts.keyHandle,
-			ecdsaThresholdKeyId: String(publicFacts.ecdsaThresholdKeyId),
-			signingRootId: String(publicFacts.signingRootId),
-			signingRootVersion: String(publicFacts.signingRootVersion),
-			relayerKeyId: String(manifest.durableMaterial.roleLocalBinding.relayerKeyId),
-			participantIds: publicFacts.participantIds,
-			publicCapability: publicFacts.publicCapability,
-			activationReceipt: manifest.activation.serverActivation.serverActivationReceipt.protocolReceipt,
-			runtimePolicyScope: manifest.durableMaterial.runtimePolicyScope,
-			readyStateBlobB64u: opened.readyStateBlobB64u,
-			publicFacts: {
-				contextBinding32B64u: publicFacts.contextBinding32B64u,
-				derivationClientSharePublicKey33B64u: publicFacts.derivationClientSharePublicKey33B64u,
-				clientVerifyingShare33B64u: publicFacts.publicCapability.public_identity.derivation_client_share_public_key33_b64u,
-				relayerPublicKey33B64u: publicFacts.relayerPublicKey33B64u,
-				groupPublicKey33B64u: publicFacts.groupPublicKey33B64u,
-				ethereumAddress: publicFacts.ethereumAddress,
-				clientShareRetryCounter: publicFacts.publicCapability.public_identity.client_share_retry_counter,
-				relayerShareRetryCounter: publicFacts.publicCapability.public_identity.server_share_retry_counter
+		const selectors = [];
+		try {
+			for (const row of rows) {
+				const pointer = parsePointerRow(row);
+				if (pointer.selector.authority.walletId === walletId) selectors.push(pointer.selector);
 			}
-		});
-		if (imported.kind !== "committed") throw new Error(`ECDSA custody continuity import is ${imported.kind}`);
-	}
-}
-async function lookupInTransaction(context, selector) {
-	const pointerRaw = await context.store(POINTER_STORE).get(selectorKey(selector));
-	if (pointerRaw === void 0) return await lookupWithoutPointer(context, selector);
-	let pointer;
-	try {
-		pointer = parsePointerRow(pointerRaw);
-	} catch (error) {
-		return {
-			kind: "corrupt",
-			detail: errorMessage(error)
+		} catch {
+			return {
+				kind: "corrupt",
+				capability
+			};
+		}
+		if (selectors.length === 0) return {
+			kind: "missing",
+			subject: "capability",
+			capability
 		};
-	}
-	if (!selectorsMatch(pointer.selector, selector)) return {
-		kind: "exact_binding_mismatch",
-		detail: "current ECDSA pointer belongs to a different exact authority"
-	};
-	const manifestRaw = await context.store(MANIFEST_STORE).get(pointer.manifestId);
-	if (manifestRaw === void 0) return {
-		kind: "exact_record_conflict",
-		detail: "current ECDSA pointer references a missing manifest"
-	};
-	let parsedManifest;
-	try {
-		parsedManifest = parseManifestRow(manifestRaw);
-	} catch (error) {
-		return {
-			kind: "corrupt",
-			detail: errorMessage(error)
+		const exact = [];
+		for (const selector of selectors) {
+			const lookup = await this.lookup(selector);
+			switch (lookup.kind) {
+				case "active":
+					if (activeLookupUsesMaterialActivation(lookup, materialActivation)) exact.push(lookup);
+					break;
+				case "retired": break;
+				case "missing": return {
+					kind: "missing",
+					subject: lookup.subject,
+					capability
+				};
+				case "exact_binding_mismatch":
+				case "exact_record_conflict":
+				case "corrupt":
+				case "persistence_unavailable": return {
+					kind: lookup.kind,
+					capability
+				};
+			}
+		}
+		const requested = input.authority;
+		if (requested) {
+			const selected = exact.filter((candidate) => walletAuthAuthorityRefsMatch(candidate.manifest.signer.authority, requested));
+			if (selected.length > 1) return {
+				kind: "exact_record_conflict",
+				capability
+			};
+			return selected[0] ?? {
+				kind: "exact_binding_mismatch",
+				capability
+			};
+		}
+		if (exact.length > 1) return {
+			kind: "ambiguous_authority",
+			capability,
+			authorities: exact.map((candidate) => candidate.manifest.signer.authority)
+		};
+		return exact[0] ?? {
+			kind: "exact_binding_mismatch",
+			capability
 		};
 	}
-	if (!selectorsMatch(parsedManifest.selector, selector)) return {
-		kind: "exact_binding_mismatch",
-		detail: "current ECDSA manifest belongs to a different exact authority"
-	};
-	if (parsedManifest.manifest.identity.manifestId !== pointer.manifestId || parsedManifest.manifest.identity.manifestRevision !== pointer.manifestRevision) return {
-		kind: "exact_record_conflict",
-		detail: "current ECDSA pointer does not match its manifest identity"
-	};
-	if (parsedManifest.state === "replaced") return {
-		kind: "retired",
-		manifest: parsedManifest.manifest
-	};
-	const activeRows = await context.store(MANIFEST_STORE).index(SEAMS_WALLET_INDEXES.capabilityWalletAuthorityState).getAll([...selectorKey(selector), "active"]);
-	if (activeRows.length !== 1) return {
-		kind: "exact_record_conflict",
-		detail: "exact ECDSA authority has multiple current manifests"
-	};
-	let indexedActive;
-	try {
-		indexedActive = parseManifestRow(activeRows[0]);
-	} catch (error) {
-		return {
-			kind: "corrupt",
-			detail: errorMessage(error)
+	async openActiveMaterial(selectorInput) {
+		const selector = normalizeSelector(selectorInput);
+		const lookup = await this.lookup(selector);
+		if (lookup.kind !== "active") return lookup;
+		return await this.openActiveMaterialLookup(lookup);
+	}
+	async lookupByMaterialRef(materialRefInput) {
+		const materialRef = parseEcdsaRoleLocalPersistedMaterialRef(materialRefInput);
+		const capability = materialRef.materialActivation.capability;
+		let raw;
+		try {
+			raw = await this.manager.runTransaction([MATERIAL_STORE], "readonly", async (context) => await context.store(MATERIAL_STORE).get(materialRef.durableMaterialRef));
+		} catch {
+			return {
+				kind: "persistence_unavailable",
+				capability
+			};
+		}
+		if (raw === void 0) return await this.lookupMissingMaterialByRef(materialRef);
+		let locator;
+		try {
+			locator = parseMaterialLocator(raw);
+		} catch {
+			return {
+				kind: "corrupt",
+				capability
+			};
+		}
+		if (locator.durableMaterialRef !== materialRef.durableMaterialRef || locator.bindingDigest !== materialRef.bindingDigest) return {
+			kind: "exact_binding_mismatch",
+			capability
 		};
+		const lookup = await this.lookup(locator.selector);
+		switch (lookup.kind) {
+			case "active":
+				if (lookup.manifest.durableMaterial.durableMaterialRef !== materialRef.durableMaterialRef || lookup.manifest.durableMaterial.bindingDigest !== materialRef.bindingDigest || !activeLookupUsesMaterialActivation(lookup, materialRef.materialActivation)) return {
+					kind: "exact_binding_mismatch",
+					capability
+				};
+				return lookup;
+			case "retired": return lookup;
+			case "missing": return {
+				kind: "missing",
+				subject: lookup.subject,
+				capability
+			};
+			case "exact_binding_mismatch":
+			case "exact_record_conflict":
+			case "corrupt":
+			case "persistence_unavailable": return {
+				kind: lookup.kind,
+				capability
+			};
+		}
+		return assertNever$1(lookup);
 	}
-	if (indexedActive.state !== "active" || indexedActive.manifest.identity.manifestId !== pointer.manifestId) return {
-		kind: "exact_record_conflict",
-		detail: "exact ECDSA current index disagrees with its pointer"
-	};
-	const materialRaw = await context.store(MATERIAL_STORE).get(parsedManifest.manifest.durableMaterial.durableMaterialRef);
-	if (materialRaw === void 0) return {
-		kind: "missing",
-		subject: "material",
-		detail: "active ECDSA manifest is missing its ready material"
-	};
-	let material;
-	try {
-		material = parseMaterialRow(materialRaw, parsedManifest.activeProof);
-	} catch (error) {
-		return {
-			kind: "corrupt",
-			detail: errorMessage(error)
+	async lookupMissingMaterialByRef(materialRef) {
+		const capability = materialRef.materialActivation.capability;
+		let rows;
+		try {
+			rows = await this.manager.runTransaction([MANIFEST_STORE], "readonly", async (context) => await context.store(MANIFEST_STORE).getAll());
+		} catch {
+			return {
+				kind: "persistence_unavailable",
+				capability
+			};
+		}
+		const exact = [];
+		let bindingMismatch = false;
+		for (const raw of rows) {
+			let parsed;
+			try {
+				parsed = parseManifestRow(raw);
+			} catch {
+				return {
+					kind: "corrupt",
+					capability
+				};
+			}
+			const durableMaterial = parsed.activeProof.durableMaterial;
+			if (durableMaterial.durableMaterialRef !== materialRef.durableMaterialRef) continue;
+			if (durableMaterial.bindingDigest !== materialRef.bindingDigest || !mpcMaterialActivationRefsEqual(durableMaterial.materialActivation, materialRef.materialActivation)) {
+				bindingMismatch = true;
+				continue;
+			}
+			exact.push(parsed);
+		}
+		if (exact.length > 1) return {
+			kind: "exact_record_conflict",
+			capability
 		};
-	}
-	if (!materialMatchesManifest(material, parsedManifest.manifest)) return {
-		kind: "exact_binding_mismatch",
-		detail: "active ECDSA material does not match its manifest"
-	};
-	const sealingKeyRaw = await context.store(SEALING_KEY_STORE).get(material.sealingKeyId);
-	if (sealingKeyRaw === void 0) return {
-		kind: "missing",
-		subject: "material",
-		detail: "active ECDSA material is missing its sealing key"
-	};
-	try {
-		if (parseSealingKeyRow(sealingKeyRaw).keyId !== material.sealingKeyId) return {
+		const [matched] = exact;
+		if (!matched) return bindingMismatch ? {
 			kind: "exact_binding_mismatch",
-			detail: "active ECDSA material sealing key id does not match"
+			capability
+		} : {
+			kind: "missing",
+			subject: "material",
+			capability
+		};
+		if (matched.state === "replaced") return {
+			kind: "retired",
+			manifest: matched.manifest
 		};
-	} catch (error) {
 		return {
-			kind: "corrupt",
-			detail: errorMessage(error)
+			kind: "missing",
+			subject: "material",
+			capability
 		};
 	}
-	if (await ciphertextDigestB64u(material.ciphertextB64u) !== material.binding.ciphertextDigest) return {
-		kind: "corrupt",
-		detail: "active ECDSA material ciphertext digest is invalid"
-	};
-	return {
-		kind: "active",
-		manifest: parsedManifest.manifest,
-		material
-	};
-}
-async function lookupWithoutPointer(context, selector) {
-	const rows = await context.store(MANIFEST_STORE).index(SEAMS_WALLET_INDEXES.capabilityWallet).getAll([String(selector.capability), String(selector.authority.walletId)]);
-	if (rows.length === 0) return {
-		kind: "missing",
-		subject: "capability",
-		detail: "no ECDSA capability manifest exists"
-	};
-	let hasDifferentAuthority = false;
-	let hasExactAuthority = false;
-	let hasSameMethodUnderAnotherDigest = false;
-	for (const raw of rows) {
-		let parsed;
+	async openActiveMaterialLookup(lookup) {
+		const selector = selectorFromManifest(lookup.manifest);
 		try {
-			parsed = parseManifestRow(raw);
+			if (await ciphertextDigestB64u(lookup.material.ciphertextB64u) !== lookup.material.binding.ciphertextDigest) throw new Error("active ECDSA material ciphertext digest is invalid");
+			const sealingKey = await this.readMaterialSealingKey(lookup.material.sealingKeyId);
+			if (!sealingKey) throw new Error("active ECDSA material sealing key is missing");
+			return {
+				kind: "active",
+				manifest: lookup.manifest,
+				readyStateBlobB64u: await decryptStateBlob({
+					key: sealingKey,
+					iv12B64u: lookup.material.iv12B64u,
+					ciphertextB64u: lookup.material.ciphertextB64u,
+					aadProjection: readyAadProjection(lookup.manifest)
+				})
+			};
+		} catch (error) {
+			return {
+				kind: "corrupt",
+				selector,
+				corruptionDigest: await persistenceDigest("active_material_open_corrupt", selector, ecdsaManifestErrorMessage(error))
+			};
+		}
+	}
+	async openActiveMaterialByRef(materialRefInput) {
+		let lookup;
+		try {
+			lookup = await this.lookupByMaterialRef(materialRefInput);
+		} catch {
+			return { kind: "corrupt" };
+		}
+		if (lookup.kind !== "active") return materialRefOpenFailure(lookup);
+		const opened = await this.openActiveMaterialLookup(lookup);
+		return opened.kind === "active" ? opened : materialRefOpenFailure(opened);
+	}
+	async sealAndFinalizeActivation(input) {
+		const selector = selectorFromJournal(input.committedJournal);
+		try {
+			const parsedJournal = parseCommittedJournal(input.committedJournal);
+			const sealingKeyId = parsedJournal.candidate.encryptedPending.sealingKeyId;
+			const sealingKey = await this.readMaterialSealingKey(sealingKeyId);
+			if (!sealingKey) throw new Error("ECDSA activation material sealing key is missing");
+			const encrypted = await encryptStateBlob({
+				key: sealingKey,
+				stateBlobB64u: input.readyStateBlobB64u,
+				aadProjection: readyAadProjection(parsedJournal)
+			});
+			const durableMaterial = buildDurableEcdsaMaterialBinding({
+				activationBinding: parsedJournal.candidate.activationBinding,
+				serverActivation: parsedJournal.serverActivation,
+				routerAbEcdsaDerivationNormalSigning: input.routerAbEcdsaDerivationNormalSigning,
+				roleLocalPublicFacts: buildEcdsaRoleLocalPublicFacts(input.roleLocalPublicFacts),
+				ciphertextDigest: parseEcdsaCiphertextDigest(encrypted.digestB64u),
+				runtimePolicyScope: input.runtimePolicyScope
+			});
+			const readyMaterial = buildValidatedEncryptedEcdsaReadyMaterial({
+				binding: durableMaterial,
+				sealingKeyId,
+				iv12B64u: encrypted.iv12B64u,
+				ciphertextB64u: encrypted.ciphertextB64u
+			});
+			const activeManifest = buildActiveEcdsaCapabilityManifest({
+				activationBinding: parsedJournal.candidate.activationBinding,
+				serverActivation: parsedJournal.serverActivation,
+				registeredPublicFacts: input.registeredPublicFacts,
+				durableMaterial,
+				committedAt: input.committedAt
+			});
+			return await this.finalizeActivation({
+				committedJournal: parsedJournal,
+				readyMaterial,
+				activeManifest
+			});
+		} catch (error) {
+			return {
+				kind: "corrupt",
+				selector,
+				corruptionDigest: await persistenceDigest("activation_seal_corrupt", selector, ecdsaManifestErrorMessage(error))
+			};
+		}
+	}
+	async importCommittedWalletCustodyActivation(input) {
+		return await importCommittedActivation(this, input, (prepared) => persistPreparedContinuity(this.manager, prepared));
+	}
+	async persistPreparedWalletCustodyEcdsaContinuity(prepared) {
+		await persistPreparedContinuity(this.manager, prepared);
+	}
+	async readMaterialSealingKey(keyIdInput) {
+		const keyId = parseEcdsaMaterialSealingKeyId(keyIdInput);
+		const raw = await this.manager.runTransaction([SEALING_KEY_STORE], "readonly", async (context) => await context.store(SEALING_KEY_STORE).get(keyId));
+		if (raw === void 0) return null;
+		const parsed = parseSealingKeyRow(raw);
+		if (parsed.keyId !== keyId) throw new Error("ECDSA material sealing key row identity is inconsistent");
+		return parsed.key;
+	}
+	async finalizeActivation(input) {
+		let activeProof;
+		try {
+			activeProof = assertActiveProofInput(input);
+		} catch (error) {
+			const selector = selectorFromJournal(input.committedJournal);
+			return {
+				kind: "corrupt",
+				selector,
+				corruptionDigest: await persistenceDigest("finalization_input_corrupt", selector, ecdsaManifestErrorMessage(error))
+			};
+		}
+		const selector = selectorFromManifest(activeProof.activeManifest);
+		try {
+			if (await ciphertextDigestB64u(input.readyMaterial.ciphertextB64u) !== input.readyMaterial.binding.ciphertextDigest) throw new FinalizationControlError("corrupt", "ECDSA ready material ciphertext digest is invalid");
+			const sealingKey = await this.readMaterialSealingKey(input.readyMaterial.sealingKeyId);
+			if (!sealingKey) throw new FinalizationControlError("corrupt", "ECDSA ready material sealing key is missing");
+			await decryptStateBlob({
+				key: sealingKey,
+				iv12B64u: input.readyMaterial.iv12B64u,
+				ciphertextB64u: input.readyMaterial.ciphertextB64u,
+				aadProjection: readyAadProjection(input.committedJournal)
+			});
+			await this.manager.runTransaction([
+				MANIFEST_STORE,
+				POINTER_STORE,
+				MATERIAL_STORE,
+				JOURNAL_STORE,
+				SEALING_KEY_STORE,
+				PRESIGNATURE_STORE
+			], "readwrite", async (context) => {
+				await finalizeInTransaction(context, input, activeProof, selector);
+			});
+			return {
+				kind: "committed",
+				manifest: activeProof.activeManifest,
+				material: input.readyMaterial
+			};
 		} catch (error) {
+			if (error instanceof FinalizationControlError) {
+				const digest = await persistenceDigest(error.kind === "corrupt" ? "finalization_corrupt" : "finalization_conflict", selector, error.message);
+				return error.kind === "corrupt" ? {
+					kind: "corrupt",
+					selector,
+					corruptionDigest: digest
+				} : {
+					kind: "exact_record_conflict",
+					selector,
+					conflictDigest: digest
+				};
+			}
+			if (isConstraintError(error)) return {
+				kind: "exact_record_conflict",
+				selector,
+				conflictDigest: await persistenceDigest("finalization_constraint_conflict", selector, ecdsaManifestErrorMessage(error))
+			};
 			return {
-				kind: "corrupt",
-				detail: errorMessage(error)
+				kind: "persistence_unavailable",
+				selector,
+				retryCorrelation: retryCorrelation()
 			};
 		}
-		if (selectorsMatch(parsed.selector, selector)) {
-			hasExactAuthority = true;
-			continue;
-		}
-		hasDifferentAuthority = true;
-		if (parsed.selector.authority.walletAuthMethodId === selector.authority.walletAuthMethodId) hasSameMethodUnderAnotherDigest = true;
-	}
-	if (hasExactAuthority) return {
-		kind: "exact_record_conflict",
-		detail: "exact ECDSA authority has manifest history without a current pointer"
-	};
-	if (hasSameMethodUnderAnotherDigest) return {
-		kind: "exact_binding_mismatch",
-		detail: "ECDSA capability exists for this method under a different authority digest"
-	};
-	if (hasDifferentAuthority) return {
-		kind: "missing",
-		subject: "capability",
-		detail: "no ECDSA capability manifest exists for this exact authority"
-	};
-	return {
-		kind: "missing",
-		subject: "capability",
-		detail: "no exact ECDSA capability manifest exists"
-	};
-}
-async function retireClientPresignaturesForActivationInTransaction(context, walletId, materialActivationId) {
-	const store = context.store(PRESIGNATURE_STORE);
-	const rows = await store.index(SEAMS_WALLET_INDEXES.walletMaterialActivationId).getAll([walletId, materialActivationId]);
-	for (const raw of rows) {
-		const recordId = rawRecordId(raw);
-		if (recordId) await store.delete(recordId);
 	}
-}
+};
 async function finalizeInTransaction(context, input, activeProof, selector) {
 	const journalStore = context.store(JOURNAL_STORE);
 	const journalRaw = await journalStore.get(input.committedJournal.journalId);
@@ -5174,7 +4817,7 @@ async function finalizeInTransaction(context, input, activeProof, selector) {
 	try {
 		persistedJournal = parseJournalRow(journalRaw);
 	} catch (error) {
-		throw new FinalizationControlError("corrupt", errorMessage(error));
+		throw new FinalizationControlError("corrupt", ecdsaManifestErrorMessage(error));
 	}
 	if (persistedJournal.journal.kind !== "server_activation_committed" || !selectorsMatch(persistedJournal.selector, selector) || !ecdsaActivationCommitJournalsMatch(persistedJournal.journal, input.committedJournal)) throw new FinalizationControlError("exact_record_conflict", "ECDSA finalization journal does not match its committed activation");
 	const sealingKeyRaw = await context.store(SEALING_KEY_STORE).get(input.readyMaterial.sealingKeyId);
@@ -5182,13 +4825,13 @@ async function finalizeInTransaction(context, input, activeProof, selector) {
 	try {
 		parseSealingKeyRow(sealingKeyRaw);
 	} catch (error) {
-		throw new FinalizationControlError("corrupt", errorMessage(error));
+		throw new FinalizationControlError("corrupt", ecdsaManifestErrorMessage(error));
 	}
 	const pointerStore = context.store(POINTER_STORE);
 	const pointerRaw = await pointerStore.get(selectorKey(selector));
 	const expected = input.committedJournal.expectedManifest;
 	const currentPointer = assertExpectedPointer(expected, pointerRaw, selector);
-	const activeRows = await context.store(MANIFEST_STORE).index(SEAMS_WALLET_INDEXES.capabilityWalletAuthorityState).getAll([...selectorKey(selector), "active"]);
+	const activeRows = await readActiveManifestRows(context, selector);
 	let previousProof = null;
 	let previousSealingKeyId = null;
 	if (currentPointer === null) {
@@ -5199,7 +4842,7 @@ async function finalizeInTransaction(context, input, activeProof, selector) {
 		try {
 			previousManifest = parseManifestRow(activeRows[0]);
 		} catch (error) {
-			throw new FinalizationControlError("corrupt", errorMessage(error));
+			throw new FinalizationControlError("corrupt", ecdsaManifestErrorMessage(error));
 		}
 		if (previousManifest.state !== "active" || previousManifest.manifest.identity.manifestId !== currentPointer.manifestId) throw new FinalizationControlError("exact_record_conflict", "replacement ECDSA activation current manifest does not match its pointer");
 		if (input.committedJournal.activationCommand.expectedGeneration.kind !== "exact_generation" || previousManifest.activeProof.serverActivation.serverGeneration !== input.committedJournal.activationCommand.expectedGeneration.serverGeneration) throw new FinalizationControlError("exact_record_conflict", "replacement ECDSA activation server generation CAS did not match");
@@ -5211,7 +4854,7 @@ async function finalizeInTransaction(context, input, activeProof, selector) {
 			if (previousMaterial.sealingKeyId === input.readyMaterial.sealingKeyId) throw new Error("replacement ECDSA activation must use a fresh material sealing key");
 			previousSealingKeyId = previousMaterial.sealingKeyId;
 		} catch (error) {
-			throw new FinalizationControlError("corrupt", errorMessage(error));
+			throw new FinalizationControlError("corrupt", ecdsaManifestErrorMessage(error));
 		}
 		previousProof = previousManifest.activeProof;
 	}
@@ -5253,19 +4896,11 @@ async function publishEd25519YaoPublicCapabilityReferenceAndLane(store, referenc
 	await store.upsert(identity);
 	await store.upsertLane(reference);
 }
-function requireRecord(value, label) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${label} must be an object`);
-	return value;
-}
 function requireExactKeys(record, expectedKeys, label) {
 	const actual = Object.keys(record).sort();
 	const expected = [...expectedKeys].sort();
 	if (actual.length !== expected.length || actual.some((key, index) => key !== expected[index])) throw new Error(`${label} contains unexpected fields`);
 }
-function requireNonEmptyString(value, label) {
-	if (typeof value !== "string" || value.trim() !== value || value.length === 0) throw new Error(`${label} must be a non-empty normalized string`);
-	return value;
-}
 function requireNonNegativeInteger(value, label) {
 	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) throw new Error(`${label} must be a non-negative integer`);
 	return value;
@@ -5276,7 +4911,7 @@ function requirePositiveInteger(value, label) {
 }
 function parseSigningLaneAuth(value, label) {
 	const record = requireRecord(value, label);
-	const kind = requireNonEmptyString(record.kind, `${label}.kind`);
+	const kind = requireCanonicalString(record.kind, `${label}.kind`, "must be a non-empty normalized string");
 	switch (kind) {
 		case "passkey":
 			requireExactKeys(record, [
@@ -5286,14 +4921,14 @@ function parseSigningLaneAuth(value, label) {
 			], label);
 			return {
 				kind,
-				rpId: toRpId(requireNonEmptyString(record.rpId, `${label}.rpId`)),
-				credentialIdB64u: requireNonEmptyString(record.credentialIdB64u, `${label}.credentialIdB64u`)
+				rpId: toRpId(requireCanonicalString(record.rpId, `${label}.rpId`, "must be a non-empty normalized string")),
+				credentialIdB64u: requireCanonicalString(record.credentialIdB64u, `${label}.credentialIdB64u`, "must be a non-empty normalized string")
 			};
 		case "email_otp":
 			requireExactKeys(record, ["kind", "providerSubjectId"], label);
 			return {
 				kind,
-				providerSubjectId: requireNonEmptyString(record.providerSubjectId, `${label}.providerSubjectId`)
+				providerSubjectId: requireCanonicalString(record.providerSubjectId, `${label}.providerSubjectId`, "must be a non-empty normalized string")
 			};
 		default: throw new Error(`${label}.kind is invalid`);
 	}
@@ -5314,8 +4949,8 @@ function parsePublicCapabilityIdentity(value, label) {
 	const runtimePolicyScope = normalizeThresholdRuntimePolicyScope(record.runtimePolicyScope);
 	if (!runtimePolicyScope) throw new Error(`${label}.runtimePolicyScope is invalid`);
 	return {
-		walletId: toWalletId(requireNonEmptyString(record.walletId, `${label}.walletId`)),
-		nearAccountId: toAccountId(requireNonEmptyString(record.nearAccountId, `${label}.nearAccountId`)),
+		walletId: toWalletId(requireCanonicalString(record.walletId, `${label}.walletId`, "must be a non-empty normalized string")),
+		nearAccountId: toAccountId(requireCanonicalString(record.nearAccountId, `${label}.nearAccountId`, "must be a non-empty normalized string")),
 		thresholdSessionId: thresholdSessionId.value,
 		runtimePolicyScope,
 		materialActivation: materialActivation.value
@@ -5346,7 +4981,7 @@ function parsePublicCapabilityLane(value, label) {
 	if (signerSlot === null) throw new Error(`${label}.signerSlot is invalid`);
 	const common = {
 		...base,
-		nearEd25519SigningKeyId: nearEd25519SigningKeyIdFromString(requireNonEmptyString(record.nearEd25519SigningKeyId, `${label}.nearEd25519SigningKeyId`)),
+		nearEd25519SigningKeyId: nearEd25519SigningKeyIdFromString(requireCanonicalString(record.nearEd25519SigningKeyId, `${label}.nearEd25519SigningKeyId`, "must be a non-empty normalized string")),
 		signerSlot
 	};
 	switch (auth.kind) {
@@ -5366,7 +5001,7 @@ function parsePublicCapabilityLane(value, label) {
 function parseEd25519YaoPublicCapabilityReferencesV1(value) {
 	const record = requireRecord(value, "Ed25519 Yao public capability references");
 	requireExactKeys(record, ["kind", "identities"], "Ed25519 Yao public capability references");
-	if (record.kind !== "ed25519_yao_public_capability_references_v1") throw new Error("Ed25519 Yao public capability references kind is invalid");
+	if (record.kind !== ED25519_YAO_PUBLIC_CAPABILITY_REFERENCES_KIND_V1) throw new Error("Ed25519 Yao public capability references kind is invalid");
 	if (!Array.isArray(record.identities)) throw new Error("Ed25519 Yao public capability identities must be an array");
 	if (record.identities.length > MAX_PUBLIC_CAPABILITY_REFERENCES) throw new Error("Ed25519 Yao public capability reference capacity is exceeded");
 	const identities = record.identities.map((identity, index) => parsePublicCapabilityIdentity(identity, `Ed25519 Yao public capability identity ${index}`));
@@ -5379,7 +5014,7 @@ function parseEd25519YaoPublicCapabilityReferencesV1(value) {
 function parseEd25519YaoPublicCapabilityLanesV1(value) {
 	const record = requireRecord(value, "Ed25519 Yao public capability lanes");
 	requireExactKeys(record, ["kind", "lanes"], "Ed25519 Yao public capability lanes");
-	if (record.kind !== "ed25519_yao_public_capability_lanes_v1") throw new Error("Ed25519 Yao public capability lanes kind is invalid");
+	if (record.kind !== ED25519_YAO_PUBLIC_CAPABILITY_LANES_KIND_V1) throw new Error("Ed25519 Yao public capability lanes kind is invalid");
 	if (!Array.isArray(record.lanes)) throw new Error("Ed25519 Yao public capability lanes must be an array");
 	if (record.lanes.length > MAX_PUBLIC_CAPABILITY_LANES) throw new Error("Ed25519 Yao public capability lane capacity is exceeded");
 	const lanes = record.lanes.map((lane, index) => parsePublicCapabilityLane(lane, `Ed25519 Yao public capability lane ${index}`));
@@ -5422,7 +5057,7 @@ function clonePublicCapabilityLane(lane) {
 }
 async function upsertEd25519YaoPublicCapabilityReferenceInTransaction(store, identity) {
 	const currentRow = await store.get(ED25519_YAO_PUBLIC_CAPABILITY_REFERENCES_APP_STATE_KEY);
-	if (currentRow !== void 0 && currentRow.key !== "ed25519YaoPublicCapabilityReferencesV1") throw new Error("Ed25519 Yao public capability reference app-state key is inconsistent");
+	if (currentRow !== void 0 && currentRow.key !== ED25519_YAO_PUBLIC_CAPABILITY_REFERENCES_APP_STATE_KEY) throw new Error("Ed25519 Yao public capability reference app-state key is inconsistent");
 	const current = currentRow === void 0 ? emptyPublicCapabilityReferences() : parseEd25519YaoPublicCapabilityReferencesV1(currentRow.value);
 	const normalized = clonePublicCapabilityIdentity(identity);
 	const identities = current.identities.filter((candidate) => String(candidate.walletId) !== String(normalized.walletId) || String(candidate.nearAccountId) !== String(normalized.nearAccountId));
@@ -8313,8 +7948,7 @@ var SeamsWalletRepositories = class {
 		return await this.resolveWalletAuthorityForSelection(walletId, null);
 	}
 	/**
-	* R109C: resolve the authority as a named method rather than as the selected
-	* one.
+	* Resolve the authority as a named method rather than as the selected one.
 	*
 	* Unlocking a sibling is how an added method comes into use - invariant 9
 	* makes lock and unlock the route - and the unlock moves the selection to it.
@@ -8546,6 +8180,55 @@ var SeamsWalletRepositories = class {
 			}));
 		});
 	}
+	/**
+	* Adopts the authority the Gateway returned after this wallet added an ECDSA
+	* signer: the local authority extended with exactly the activation this
+	* device made, nothing else changed. The Gateway promoted the wallet's live
+	* Wallet Sessions to it; the next exact status read carries that promotion
+	* into the local session, which keeps its operation credential.
+	*/
+	async adoptAddedEcdsaSignerAuthority(input) {
+		const parsed = parseWalletAuthorityV1(input.authority);
+		if (!parsed.ok || parsed.value.state !== "active" || !await walletAuthorityDigestsMatchV1(parsed.value)) throw new Error("Added ECDSA signer authority is invalid");
+		const next = parsed.value;
+		const nextEcdsa = next.signerActivations.ecdsa;
+		if (!nextEcdsa || !mpcMaterialActivationRefsEqual(nextEcdsa.materialActivation, input.materialActivation)) throw new Error("Added ECDSA signer authority does not carry the activated signer");
+		await this.manager.runTransaction([SEAMS_WALLET_STORES.walletAuthorities], "readwrite", async (ctx) => {
+			const store = ctx.store(SEAMS_WALLET_STORES.walletAuthorities);
+			const current = parseWalletAuthorityStorageRow(await store.get(next.authorityId));
+			if (!current || current.record.state !== "active") throw new Error("Added ECDSA signer has no active local authority to extend");
+			if (current.record.authorityDigestB64u === next.authorityDigestB64u) return;
+			if (!isEcdsaExtensionOfEd25519WalletAuthority(current.record, next)) throw new Error("Added ECDSA signer authority is not an extension of the local authority");
+			await store.put(walletAuthorityStorageRow(next));
+		});
+	}
+	/**
+	* Replaces the exact active Wallet Session with the one a status read
+	* returned, only while it still binds the wallet's stored authority and its
+	* unlocked selection. The status crosses the network, and a publication
+	* can commit meanwhile: deferred NEAR provisioning extends the authority
+	* and rebinds the session in one transaction. Writing the older status
+	* after it would bind the session to an authority digest no longer stored,
+	* and every exact-session check would refuse it until another status read.
+	*/
+	async replaceExactActiveWalletSessionFromStatus(input) {
+		return await this.manager.runTransaction([
+			SEAMS_WALLET_STORES.walletAuthorities,
+			SEAMS_WALLET_STORES.walletSessionAuthorizations,
+			SEAMS_WALLET_STORES.walletSelections
+		], "readwrite", this.replaceExactActiveWalletSessionFromStatusInTransaction.bind(this, input));
+	}
+	async replaceExactActiveWalletSessionFromStatusInTransaction(input, ctx) {
+		const authority = parseWalletAuthorityStorageRow(await ctx.store(SEAMS_WALLET_STORES.walletAuthorities).get(input.active.authorityId));
+		const selection = parseWalletSelectionStorageRow(await ctx.store(SEAMS_WALLET_STORES.walletSelections).get(input.active.walletId));
+		if (!authority || authority.record.state !== "active" || authority.record.walletId !== input.active.walletId || authority.record.authorityDigestB64u !== input.active.authorityDigestB64u || authority.record.revocationEpoch !== input.active.authorityRevocationEpoch || !selection || selection.record.lockState !== "unlocked" || selection.record.walletAuthMethodId !== input.active.authMethodId) return { kind: "superseded" };
+		await replaceExactActiveWalletSessionAuthorizationInTransaction({
+			ctx,
+			active: input.active,
+			operationCredential: input.operationCredential
+		});
+		return { kind: "replaced" };
+	}
 	async reconcilePendingNearRegistrationAuthority(input) {
 		const authority = await this.getWalletAuthority(input.walletSession.authorityId);
 		if (!authority || authority.state !== "active" || !isActiveEcdsaWalletAuthorityV1(authority)) return;
@@ -10477,6 +10160,12 @@ var UnifiedIndexedDBManager = class {
 	async publishPendingWalletRegistrationCommitAndRetain(input) {
 		return this.seamsWalletRepositories.publishPendingWalletRegistrationCommitAndRetain(input);
 	}
+	async adoptAddedEcdsaSignerAuthority(input) {
+		await this.seamsWalletRepositories.adoptAddedEcdsaSignerAuthority(input);
+	}
+	async replaceExactActiveWalletSessionFromStatus(input) {
+		return await this.seamsWalletRepositories.replaceExactActiveWalletSessionFromStatus(input);
+	}
 	async reconcilePendingNearRegistrationAuthority(input) {
 		await this.seamsWalletRepositories.reconcilePendingNearRegistrationAuthority(input);
 	}
@@ -11262,4 +10951,180 @@ async function loadWalletCustodyEd25519MaterialV1(input) {
 	};
 }
 //#endregion
-export { preparePendingNearRegistration as C, computeWalletEcdsaKeyFactsInventoryChallengeDigestB64u as D, parseRouterAbTraceContextV1 as E, openWalletAuthorityLinkedSignerMaterialV1 as O, planPendingNearRegistration as S, createRouterAbTraceContextV1 as T, WalletSessionAuthorizationUpgradeRequiredError as _, resolveAccountKeyMaterialTarget as a, assertPendingWalletRegistrationIdentity as b, configureIndexedDB as c, publishEd25519YaoPublicCapabilityReferenceAndLane as d, readEmailOtpProviderSubjectForWalletV1 as f, prepareWalletCustodyEcdsaContinuity as g, importWalletCustodyEcdsaContinuity as h, getAccountKeyMaterial as i, parseWalletAuthorityLinkedSignerMaterialRecordV1 as k, createIndexedDBNonceLaneCoordinationStore as l, copyWalletCustodyEcdsaContinuityToAuthMethod as m, loadWalletCustodyEd25519MaterialV1 as n, storeAccountKeyMaterial as o, IndexedDbEcdsaCapabilityManifestStore as p, persistWalletCustodyEd25519MaterialV1 as r, IndexedDBManager as s, deleteWalletCustodyEd25519MaterialV1 as t, IndexedDbEd25519YaoPublicCapabilityReferenceStore as u, walletSessionAuthorizations as v, ROUTER_AB_TRACE_ID_HEADER_V1 as w, parsePendingWalletRegistrationCommitV1 as x, pendingWalletRecoveryCommitIdentityMatches as y };
+//#region src/core/indexedDB/seamsWalletDB/walletCustodyEcdsaContinuity.ts
+function buildWalletCustodyEcdsaContinuityImportInput(input) {
+	const authority = parseWalletAuthAuthorityRef(input.authority);
+	if (!authority || String(authority.walletId) !== String(input.walletId)) throw new Error("ECDSA custody import authority is invalid");
+	const publicCapability = parseRouterAbEcdsaDerivationPublicCapabilityV1(input.publicCapability);
+	const receipt = parseRouterAbEcdsaRegistrationActivationReceiptV1(input.activationReceipt);
+	const materialActivation = routerAbMpcMaterialActivationRefFromWire(receipt.ecdsa_activation.material_activation);
+	if (!mpcMaterialActivationRefsEqual(materialActivation, routerAbMpcMaterialActivationRefFromWire(publicCapability.material_activation))) throw new Error("ECDSA custody continuity changed the material activation");
+	const participantIds = [toParticipantId(input.participantIds[0]), toParticipantId(input.participantIds[1])];
+	const roleLocalBinding = buildEcdsaRoleLocalMaterialBinding({
+		keyHandle: parseEcdsaKeyHandle(input.keyHandle),
+		ecdsaThresholdKeyId: parseEcdsaThresholdKeyId(input.ecdsaThresholdKeyId),
+		clientVerifyingPublicKey33B64u: parseEcdsaClientVerifyingPublicKey33B64u(input.publicFacts.derivationClientSharePublicKey33B64u),
+		participantIds,
+		relayerKeyId: parseEcdsaRelayerKeyId(input.relayerKeyId)
+	});
+	const signer = buildPreparedEvmFamilySigner({
+		capability: materialActivation.capability,
+		signerId: parseEvmFamilyEcdsaSignerId(secureRandomId("ecdsa-signer", 32, "ECDSA custody signer identities")),
+		authority,
+		scope: buildEcdsaCapabilityScope({ targetMemberships: input.chainTargets }),
+		materialOwner: materialActivation.materialOwner,
+		signingRootId: parseSdkEcdsaDerivationSigningRootId(input.signingRootId),
+		signingRootVersion: parseSdkEcdsaDerivationSigningRootVersion(input.signingRootVersion)
+	});
+	const activationBinding = buildEcdsaActivationBinding({
+		targetManifest: buildEcdsaManifestIdentity({
+			manifestId: parseEcdsaCapabilityManifestId(secureRandomId("ecdsa-manifest", 32, "ECDSA custody manifest identities")),
+			manifestRevision: parseEcdsaCapabilityManifestRevision(1)
+		}),
+		signer,
+		roleLocalBinding,
+		bindingDigest: parseEcdsaRoleLocalBindingDigest(input.publicFacts.contextBinding32B64u),
+		durableMaterialRef: parseEcdsaRoleLocalDurableMaterialRef(secureRandomId("ecdsa-role-local-material", 32, "ECDSA custody material identities"))
+	});
+	const ethereumAddress = input.publicFacts.ethereumAddress;
+	const registeredPublicFacts = buildVerifiedEcdsaPublicFacts({
+		keyHandle: toEvmFamilyEcdsaKeyHandle(input.keyHandle),
+		publicKeyB64u: input.publicFacts.groupPublicKey33B64u,
+		participantIds,
+		thresholdOwnerAddress: ethereumAddress
+	});
+	const roleLocalPublicFacts = buildEcdsaRoleLocalPublicFacts({
+		walletId: authority.walletId,
+		chainTarget: input.chainTargets[0],
+		keyHandle: roleLocalBinding.keyHandle,
+		ecdsaThresholdKeyId: roleLocalBinding.ecdsaThresholdKeyId,
+		signingRootId: signer.signingRootId,
+		signingRootVersion: signer.signingRootVersion,
+		applicationBindingDigestB64u: publicCapability.context.application_binding_digest_b64u,
+		clientParticipantId: participantIds[0],
+		relayerParticipantId: participantIds[1],
+		participantIds,
+		contextBinding32B64u: input.publicFacts.contextBinding32B64u,
+		derivationClientSharePublicKey33B64u: input.publicFacts.derivationClientSharePublicKey33B64u,
+		relayerPublicKey33B64u: input.publicFacts.relayerPublicKey33B64u,
+		groupPublicKey33B64u: input.publicFacts.groupPublicKey33B64u,
+		ethereumAddress,
+		publicCapability
+	});
+	const normalSigning = {
+		kind: "router_ab_ecdsa_derivation_normal_signing_v1",
+		scope: {
+			wallet_id: String(authority.walletId),
+			ecdsa_threshold_key_id: String(roleLocalBinding.ecdsaThresholdKeyId),
+			signing_root_id: String(signer.signingRootId),
+			signing_root_version: String(signer.signingRootVersion),
+			context: receipt.ecdsa_activation.context,
+			public_identity: receipt.ecdsa_activation.public_identity,
+			material_activation: receipt.ecdsa_activation.material_activation,
+			signing_worker: receipt.ecdsa_activation.signing_worker,
+			activation_epoch: receipt.ecdsa_activation.activation_epoch
+		}
+	};
+	return {
+		activationBinding,
+		serverCommit: {
+			correlationId: receipt.activation_correlation_id,
+			activationRequestDigest: parseDigestB64u(base64UrlEncode(Uint8Array.from(receipt.activation_request_digest.bytes))),
+			serverGeneration: receipt.server_generation,
+			protocolReceipt: receipt
+		},
+		readyStateBlobB64u: input.readyStateBlobB64u,
+		registeredPublicFacts,
+		roleLocalPublicFacts,
+		routerAbEcdsaDerivationNormalSigning: normalSigning,
+		runtimePolicyScope: normalizeRuntimePolicyScope(input.runtimePolicyScope),
+		committedAt: parseIsoTimestamp(new Date(receipt.ecdsa_activation.activated_at_ms).toISOString())
+	};
+}
+async function prepareWalletCustodyEcdsaContinuity(input) {
+	return prepareImportedWalletCustodyEcdsaContinuity(buildWalletCustodyEcdsaContinuityImportInput(input));
+}
+async function importWalletCustodyEcdsaContinuity(input) {
+	return await importCommittedActivation(input.store, buildWalletCustodyEcdsaContinuityImportInput(input), (prepared) => input.store.persistPreparedWalletCustodyEcdsaContinuity(prepared));
+}
+async function assertSharedWalletAuthorityMembership(input) {
+	const repositories = new SeamsWalletRepositories(seamsWalletDB);
+	for (const walletAuthMethodId of input.walletAuthMethodIds) {
+		const authMethod = await repositories.getWalletAuthMethodV2(String(walletAuthMethodId));
+		if (!authMethod || authMethod.status !== "active" || authMethod.walletId !== input.walletId || authMethod.walletAuthorityId !== input.walletAuthorityId) throw new Error(`ECDSA custody continuity method ${String(walletAuthMethodId)} is not an active member of the wallet authority`);
+	}
+}
+/**
+* Give an added auth method its own encrypted access projection over the
+* activation the wallet already has. The activation is not re-created and the
+* source credential's authority is not widened; only a second method-bound
+* record over the same material appears.
+*
+* The membership check is the whole safety argument. Copying access to a method
+* on another wallet authority would hand that credential custody it was never
+* granted, so both methods are read back and required to be active members of
+* the exact same authority before anything is opened.
+*/
+async function copyWalletCustodyEcdsaContinuityToAuthMethod(input) {
+	if (input.targetAuthority.walletId !== input.walletId || input.targetAuthority.walletAuthMethodId === input.sourceWalletAuthMethodId) throw new Error("ECDSA custody continuity target is invalid");
+	await assertSharedWalletAuthorityMembership({
+		walletId: input.walletId,
+		walletAuthorityId: input.walletAuthorityId,
+		walletAuthMethodIds: [input.sourceWalletAuthMethodId, input.targetAuthority.walletAuthMethodId]
+	});
+	const store = new IndexedDbEcdsaCapabilityManifestStore();
+	const listed = await store.listActiveWalletCapabilitySubjects(input.walletId);
+	if (listed.kind !== "resolved") throw new Error(`ECDSA custody continuity inventory is ${listed.kind}`);
+	if (listed.subjects.length === 0) return;
+	const sources = listed.subjects.filter((subject) => subject.authority.walletAuthMethodId === input.sourceWalletAuthMethodId);
+	if (sources.length === 0) throw new Error(`ECDSA custody continuity found no active capability for source method ${String(input.sourceWalletAuthMethodId)} among [${listed.subjects.map((subject) => String(subject.authority.walletAuthMethodId)).join(", ")}]`);
+	for (const source of sources) {
+		const sourceLookup = await store.lookup(source);
+		if (sourceLookup.kind !== "active") throw new Error(`ECDSA custody continuity source is ${sourceLookup.kind}`);
+		const targetSelector = {
+			capability: source.capability,
+			authority: input.targetAuthority
+		};
+		const targetLookup = await store.lookup(targetSelector);
+		if (targetLookup.kind === "active") {
+			const targetMaterial = targetLookup.manifest.durableMaterial;
+			const sourceMaterial = sourceLookup.manifest.durableMaterial;
+			if (targetMaterial.activationDigest !== sourceMaterial.activationDigest || targetMaterial.bindingDigest !== sourceMaterial.bindingDigest || targetMaterial.roleLocalBinding.ecdsaThresholdKeyId !== sourceMaterial.roleLocalBinding.ecdsaThresholdKeyId || !ecdsaRoleLocalMaterialBindingsMatch(targetMaterial.roleLocalBinding, sourceMaterial.roleLocalBinding) || !ecdsaRoleLocalPublicFactsMatch(targetMaterial.roleLocalPublicFacts, sourceMaterial.roleLocalPublicFacts) || !ecdsaRegisteredPublicFactsMatch(targetLookup.manifest.signer.registeredPublicFacts, sourceLookup.manifest.signer.registeredPublicFacts)) throw new Error("ECDSA custody continuity target conflicts with source material");
+			continue;
+		}
+		if (targetLookup.kind !== "missing") throw new Error(`ECDSA custody continuity target is ${targetLookup.kind}`);
+		const opened = await store.openActiveMaterialLookup(sourceLookup);
+		if (opened.kind !== "active") throw new Error(`ECDSA custody continuity material is ${opened.kind}`);
+		const manifest = opened.manifest;
+		const publicFacts = manifest.durableMaterial.roleLocalPublicFacts;
+		const imported = await importWalletCustodyEcdsaContinuity({
+			store,
+			authority: input.targetAuthority,
+			chainTargets: manifest.signer.scope.targetMemberships,
+			walletId: String(input.walletId),
+			keyHandle: publicFacts.keyHandle,
+			ecdsaThresholdKeyId: String(publicFacts.ecdsaThresholdKeyId),
+			signingRootId: String(publicFacts.signingRootId),
+			signingRootVersion: String(publicFacts.signingRootVersion),
+			relayerKeyId: String(manifest.durableMaterial.roleLocalBinding.relayerKeyId),
+			participantIds: publicFacts.participantIds,
+			publicCapability: publicFacts.publicCapability,
+			activationReceipt: manifest.activation.serverActivation.serverActivationReceipt.protocolReceipt,
+			runtimePolicyScope: manifest.durableMaterial.runtimePolicyScope,
+			readyStateBlobB64u: opened.readyStateBlobB64u,
+			publicFacts: {
+				contextBinding32B64u: publicFacts.contextBinding32B64u,
+				derivationClientSharePublicKey33B64u: publicFacts.derivationClientSharePublicKey33B64u,
+				clientVerifyingShare33B64u: publicFacts.publicCapability.public_identity.derivation_client_share_public_key33_b64u,
+				relayerPublicKey33B64u: publicFacts.relayerPublicKey33B64u,
+				groupPublicKey33B64u: publicFacts.groupPublicKey33B64u,
+				ethereumAddress: publicFacts.ethereumAddress,
+				clientShareRetryCounter: publicFacts.publicCapability.public_identity.client_share_retry_counter,
+				relayerShareRetryCounter: publicFacts.publicCapability.public_identity.server_share_retry_counter
+			}
+		});
+		if (imported.kind !== "committed") throw new Error(`ECDSA custody continuity import is ${imported.kind}`);
+	}
+}
+//#endregion
+export { openWalletAuthorityLinkedSignerMaterialV1 as A, parsePendingWalletRegistrationCommitV1 as C, createRouterAbTraceContextV1 as D, ROUTER_AB_TRACE_ID_HEADER_V1 as E, parseRouterAbTraceContextV1 as O, assertPendingWalletRegistrationIdentity as S, preparePendingNearRegistration as T, ecdsaCapabilityScopesMatch as _, loadWalletCustodyEd25519MaterialV1 as a, walletSessionAuthorizations as b, resolveAccountKeyMaterialTarget as c, configureIndexedDB as d, createIndexedDBNonceLaneCoordinationStore as f, IndexedDbEcdsaCapabilityManifestStore as g, readEmailOtpProviderSubjectForWalletV1 as h, deleteWalletCustodyEd25519MaterialV1 as i, parseWalletAuthorityLinkedSignerMaterialRecordV1 as j, computeWalletEcdsaKeyFactsInventoryChallengeDigestB64u as k, storeAccountKeyMaterial as l, publishEd25519YaoPublicCapabilityReferenceAndLane as m, importWalletCustodyEcdsaContinuity as n, persistWalletCustodyEd25519MaterialV1 as o, IndexedDbEd25519YaoPublicCapabilityReferenceStore as p, prepareWalletCustodyEcdsaContinuity as r, getAccountKeyMaterial as s, copyWalletCustodyEcdsaContinuityToAuthMethod as t, IndexedDBManager as u, runtimePolicyScopesMatch as v, planPendingNearRegistration as w, pendingWalletRecoveryCommitIdentityMatches as x, WalletSessionAuthorizationUpgradeRequiredError as y };