@seams/wallet-server 0.5.0

package/dist/esm/router/cloudflare/d1/passkeyCustody/d1WalletCustodyCommitStore.js

@@ -0,0 +1,823 @@
+import { mpcMaterialActivationRefsEqual, parseWalletId } from "../../../../shared-ts/src/utils/domainIds.js";
+import { sha256HexUtf8 } from "../../../../shared-ts/src/utils/digests.js";
+import { buildDelegatedWalletAuthorityV1, buildFullOwnerDelegatedWalletAuthorityV1, sameDelegatedWalletAuthorityV1 } from "../../../../shared-ts/src/authorization/delegatedAuthority.js";
+import { walletAuthorityDigestsMatchV1 } from "../../../../shared-ts/src/authorization/walletAuthority.js";
+import { sameWalletAuthMethodRecordV2 } from "../../../../shared-ts/src/utils/registrationIntent.js";
+import { D1WalletAuthMethodStore } from "../../../../core/d1WalletAuthMethodStore.js";
+import { parsePasskeyCustodyEnvelopeRecord, sameWalletCustodyEnvelopeOwnership } from "../../../../shared-ts/src/passkey-custody/custodyEnvelope.js";
+import "../../../../shared-ts/src/passkey-custody/index.js";
+import { WALLET_EMAIL_OTP_ACTIONS, emailOtpDeviceEnrollmentId } from "../../../../shared-ts/src/utils/emailOtpDomain.js";
+import { parseDerivedWalletRecoveryKeyId } from "../../../../shared-ts/src/wallet-recovery/recoveryKeyId.js";
+import { parseWalletRecoveryBackupAcknowledgementV1 } from "../../../../shared-ts/src/wallet-recovery/backupAcknowledgement.js";
+import "../../../../shared-ts/src/wallet-recovery/recoveryCodes.js";
+import { parseWalletRecoveryEnvelopeSetRecord } from "../../../../shared-ts/src/wallet-recovery/walletRecoveryEnvelopeSet.js";
+import { parseRecoveryCodeLocatorV1 } from "../../../../shared-ts/src/wallet-recovery/recoveryCodeLocator.js";
+import { prepareD1WebAuthnCredentialBindingInsertStatement } from "../../../../core/WebAuthnCredentialBindingStore.js";
+import { prepareD1WebAuthnAuthenticatorInsertStatement } from "../webauthn/d1WebAuthnStore.js";
+import { D1WalletAuthorityStore, prepareD1WalletAuthorityPutStatement } from "../wallet/d1WalletAuthorityStore.js";
+import { CloudflareD1VersionedJsonRecordStore } from "../versionedJson/d1VersionedJsonRecordStore.js";
+import { parseEmailOtpWalletEnrollmentRow } from "../emailOtp/d1EmailOtpRecords.js";
+import "../../../../shared-ts/src/wallet-recovery/index.js";
+import "../../../../shared-ts/src/authorization/index.js";
+import { PASSKEY_ENVELOPE_KEY_PREFIX, passkeyCustodyEnvelopeLocatorOf, passkeyCustodyEnvelopeRecordKey } from "./d1PasskeyCustodyEnvelopeStore.js";
+import { parseWalletRecoveryGoogleEmailOtpAttemptRecord, walletRecoveryGoogleEmailOtpAttemptKey, walletRecoveryGoogleEmailOtpFinalizationInput } from "./d1WalletRecoveryGoogleEmailOtpRecords.js";
+//#region src/router/cloudflare/d1/passkeyCustody/d1WalletCustodyCommitStore.ts
+function sameWalletSignerActivationSetV1(left, right) {
+	if (left.kind !== right.kind || left.keyFamilies.length !== right.keyFamilies.length) return false;
+	for (let index = 0; index < left.keyFamilies.length; index += 1) if (left.keyFamilies[index] !== right.keyFamilies[index]) return false;
+	const leftEcdsa = left.ecdsa;
+	const rightEcdsa = right.ecdsa;
+	if (leftEcdsa === void 0 !== (rightEcdsa === void 0)) return false;
+	if (leftEcdsa !== void 0 && rightEcdsa !== void 0 && !sameWalletEcdsaSignerActivationV1(leftEcdsa, rightEcdsa)) return false;
+	const leftEd25519 = left.ed25519;
+	const rightEd25519 = right.ed25519;
+	if (leftEd25519 === void 0 !== (rightEd25519 === void 0)) return false;
+	return leftEd25519 === void 0 || rightEd25519 === void 0 || sameWalletEd25519SignerActivationV1(leftEd25519, rightEd25519);
+}
+function sameWalletEcdsaSignerActivationV1(left, right) {
+	return left.kind === right.kind && left.signer.kind === right.signer.kind && left.signer.keyFamily === right.signer.keyFamily && left.signer.walletId === right.signer.walletId && left.signer.walletKeyId === right.signer.walletKeyId && left.signer.thresholdPublicKey33B64u === right.signer.thresholdPublicKey33B64u && left.signer.evmAddress === right.signer.evmAddress && mpcMaterialActivationRefsEqual(left.materialActivation, right.materialActivation);
+}
+function sameWalletEd25519SignerActivationV1(left, right) {
+	return left.kind === right.kind && left.signer.kind === right.signer.kind && left.signer.keyFamily === right.signer.keyFamily && left.signer.walletId === right.signer.walletId && left.signer.walletKeyId === right.signer.walletKeyId && left.signer.registeredPublicKeyB64u === right.signer.registeredPublicKeyB64u && mpcMaterialActivationRefsEqual(left.materialActivation, right.materialActivation);
+}
+function sameWalletRecoveryGoogleEmailOtpFinalizationInputV1(left, right) {
+	return left.kind === right.kind && left.walletId === right.walletId && left.orgId === right.orgId && left.reservationId === right.reservationId && left.recoveryOperationId === right.recoveryOperationId && left.targetDeviceId === right.targetDeviceId && left.targetAuthorityId === right.targetAuthorityId && left.targetWalletAuthMethodId === right.targetWalletAuthMethodId && left.challengeId === right.challengeId && left.providerSubject === right.providerSubject && left.verifiedEmail === right.verifiedEmail && left.ownerProofBindingDigest === right.ownerProofBindingDigest && sameWalletRecoveryGoogleEmailOtpTargetEnrollmentV1(left.targetEnrollment, right.targetEnrollment);
+}
+function sameWalletRecoveryGoogleEmailOtpTargetEnrollmentV1(left, right) {
+	switch (left.kind) {
+		case "existing": return right.kind === "existing" && left.enrollmentId === right.enrollmentId && left.enrollmentSealKeyVersion === right.enrollmentSealKeyVersion;
+		case "create": return right.kind === "create" && left.providerSubject === right.providerSubject && left.verifiedEmail === right.verifiedEmail;
+		default: return assertNeverWalletRecoveryComparison(left, "Google Email OTP target enrollment");
+	}
+}
+function hasFullOwnerPermissionsV1(permissions) {
+	return sameDelegatedWalletAuthorityV1(buildDelegatedWalletAuthorityV1({ permissions }), buildFullOwnerDelegatedWalletAuthorityV1());
+}
+async function sameVerifiedActiveWalletAuthorityV1(left, right) {
+	const [leftVerified, rightVerified] = await Promise.all([walletAuthorityDigestsMatchV1(left), walletAuthorityDigestsMatchV1(right)]);
+	return leftVerified && rightVerified && left.authorityDigestB64u === right.authorityDigestB64u && left.signerActivationSetDigestB64u === right.signerActivationSetDigestB64u && left.createdAtMs === right.createdAtMs && left.updatedAtMs === right.updatedAtMs && left.activatedAtMs === right.activatedAtMs;
+}
+function sameWalletCustodyRecoveryReplacementEnvelopeV1(left, right) {
+	if (left.kind !== right.kind || left.envelopeId !== right.envelopeId || left.walletId !== right.walletId || !sameWalletCustodyEnvelopeOwnership(left.ownership, right.ownership) || left.binding.kind !== "wallet_custody_seed_v1" || right.binding.kind !== "wallet_custody_seed_v1" || left.binding.derivationScheme !== right.binding.derivationScheme || left.envelopeVersion !== right.envelopeVersion || left.envelopeRevision !== right.envelopeRevision || left.nonceB64u !== right.nonceB64u || left.sealedCustodySecretB64u !== right.sealedCustodySecretB64u || left.ciphertextDigestB64u !== right.ciphertextDigestB64u || left.aadHashB64u !== right.aadHashB64u || left.lifecycle.state !== "active" || right.lifecycle.state !== "active" || left.lifecycle.activatedAtMs !== right.lifecycle.activatedAtMs || left.createdAtMs !== right.createdAtMs || left.updatedAtMs !== right.updatedAtMs) return false;
+	switch (left.factor.kind) {
+		case "passkey": return right.factor.kind === "passkey" && left.factor.rpId === right.factor.rpId && left.factor.credentialIdB64u === right.factor.credentialIdB64u && left.factor.kekVersion === right.factor.kekVersion;
+		case "email_otp": return right.factor.kind === "email_otp" && left.factor.enrollmentId === right.factor.enrollmentId && left.factor.enrollmentSealKeyVersion === right.factor.enrollmentSealKeyVersion && left.factor.kekVersion === right.factor.kekVersion;
+		default: return assertNeverWalletRecoveryComparison(left.factor, "custody envelope factor");
+	}
+}
+function sameEmailOtpWalletEnrollmentRecordV1(left, right) {
+	return left.version === right.version && left.walletId === right.walletId && left.providerUserId === right.providerUserId && left.orgId === right.orgId && left.verifiedEmail === right.verifiedEmail && left.enrollmentId === right.enrollmentId && left.enrollmentVersion === right.enrollmentVersion && left.enrollmentSealKeyVersion === right.enrollmentSealKeyVersion && left.clientUnlockPublicKeyB64u === right.clientUnlockPublicKeyB64u && left.unlockKeyVersion === right.unlockKeyVersion && left.serverSealedFactorCiphertextB64u === right.serverSealedFactorCiphertextB64u && left.createdAtMs === right.createdAtMs && left.updatedAtMs === right.updatedAtMs;
+}
+function assertNeverWalletRecoveryComparison(value, label) {
+	throw new Error(`${label} branch is unsupported: ${String(value)}`);
+}
+const WEB_AUTHN_RECOVERY_CHALLENGE_CAS_GUARD = `
+  INSERT INTO router_ab_yao_versioned_json_cas_guard (guard_id)
+  SELECT 1
+   WHERE changes() = 0
+`;
+const RECOVERY_CODE_LOCATOR_CAS_GUARD = `
+  INSERT INTO router_ab_yao_versioned_json_cas_guard (guard_id)
+  SELECT 1
+   WHERE changes() = 0
+`;
+const WALLET_RECOVERY_GOOGLE_EMAIL_OTP_ATTEMPT_CAS_GUARD = `
+  INSERT INTO router_ab_yao_versioned_json_cas_guard (guard_id)
+  SELECT 1
+   WHERE changes() = 0
+`;
+function requireWalletId(value) {
+	const parsed = parseWalletId(value);
+	if (!parsed.ok) throw new Error(parsed.error.message);
+	return parsed.value;
+}
+/** Recovery sets are wallet-scoped: one set covers the wallet, not one factor. */
+function walletRecoveryBackupAcknowledgementRecordKey(walletId) {
+	return `wallet-recovery-backup-ack/${String(walletId)}`;
+}
+function walletRecoveryEnvelopeSetRecordKey(walletId) {
+	return `recovery-set:${String(walletId)}`;
+}
+function encodeRecord(record) {
+	return record;
+}
+/**
+* Routes a row to its record family by its own `kind`, so a row can never be
+* read back as the other family even if a key were somehow reused.
+*
+* Every branch is structurally decoded here. Recovery sets are bound to the
+* caller's expected wallet a second time in `readRecoveryEnvelopeSet`; that
+* later check owns the storage-key identity invariant.
+*/
+function parseRecordOrNull(raw) {
+	if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return null;
+	const kind = Reflect.get(raw, "kind");
+	if (kind === "wallet_recovery_envelope_set_v1") {
+		const walletId = parseWalletId(Reflect.get(raw, "walletId"));
+		if (!walletId.ok) return null;
+		try {
+			return parseWalletRecoveryEnvelopeSetRecord(raw, {
+				expectedWalletId: walletId.value,
+				label: "walletRecoveryEnvelopeSet"
+			});
+		} catch {
+			return null;
+		}
+	}
+	if (kind === "wallet_recovery_backup_acknowledgement_v1") {
+		const walletId = parseWalletId(Reflect.get(raw, "walletId"));
+		if (!walletId.ok) return null;
+		const parsed = parseWalletRecoveryBackupAcknowledgementV1(raw, { expectedWalletId: walletId.value });
+		return parsed.ok ? parsed.record : null;
+	}
+	try {
+		return parsePasskeyCustodyEnvelopeRecord(raw);
+	} catch {
+		return null;
+	}
+}
+/**
+* Rejects a pair that does not describe one wallet's custody.
+*
+* The envelope and the recovery set wrap the same seed, so a pair naming two
+* wallets would leave a set whose codes open a seed that is not the wallet's.
+*/
+function commitInconsistency(commit) {
+	if (String(commit.envelope.walletId) !== String(commit.recoverySet.walletId)) return "envelope and recovery set describe different wallets";
+	if (commit.envelope.binding.kind !== "wallet_custody_seed_v1") return "registration commits a wallet custody seed envelope";
+	if (commit.recoverySet.entries.length !== 1) return "a recovery set carries exactly one custody entry";
+	if (commit.recoveryCodeLocators.length !== commit.recoverySet.manifestKekWraps.length) return "recovery code locators do not match the recovery wraps";
+	const recoveryKeyIds = new Set(commit.recoverySet.manifestKekWraps.map((wrap) => String(wrap.recoveryKeyId)));
+	if (recoveryKeyIds.size !== commit.recoverySet.manifestKekWraps.length) return "recovery wraps must have distinct key ids";
+	const locatorKeyIds = /* @__PURE__ */ new Set();
+	const locatorValues = /* @__PURE__ */ new Set();
+	for (const locator of commit.recoveryCodeLocators) {
+		if (String(locator.walletId) !== String(commit.recoverySet.walletId)) return "recovery code locator names a different wallet";
+		const recoveryKeyId = String(locator.recoveryKeyId);
+		const locatorValue = String(locator.locatorB64u);
+		if (!recoveryKeyIds.has(recoveryKeyId) || locatorKeyIds.has(recoveryKeyId) || locatorValues.has(locatorValue)) return "recovery code locators do not match the recovery wraps";
+		locatorKeyIds.add(recoveryKeyId);
+		locatorValues.add(locatorValue);
+	}
+	if (commit.recoveryBackupAcknowledgement.walletId !== String(commit.recoverySet.walletId) || commit.recoveryBackupAcknowledgement.issuedAtMs !== commit.recoverySet.issuedAtMs) return "recovery backup acknowledgement does not match the issued recovery set";
+	return null;
+}
+function isRecoveryCodeLocatorCollision(error) {
+	const message = error instanceof Error ? error.message : String(error);
+	return message.includes("wallet_recovery_code_locators") && /unique|constraint/i.test(message);
+}
+var CloudflareD1WalletCustodyCommitStore = class {
+	constructor(options) {
+		this.database = options.database;
+		this.scope = options.scope;
+		this.walletAuthMethodStore = options.walletAuthMethodStore ?? new D1WalletAuthMethodStore({
+			database: options.database,
+			namespace: options.scope.namespace,
+			orgId: options.scope.orgId,
+			projectId: options.scope.projectId,
+			envId: options.scope.envId
+		});
+		this.walletAuthorityStore = options.walletAuthorityStore ?? new D1WalletAuthorityStore({
+			database: options.database,
+			scope: options.scope
+		});
+		this.records = new CloudflareD1VersionedJsonRecordStore({
+			database: options.database,
+			scope: options.scope,
+			encode: encodeRecord,
+			parse: parseRecordOrNull,
+			keyPrefix: PASSKEY_ENVELOPE_KEY_PREFIX
+		});
+	}
+	async readRecoveryCodeLocator(locatorB64u) {
+		const row = await this.database.prepare(`SELECT locator_b64u, wallet_id, recovery_key_id
+           FROM wallet_recovery_code_locators
+          WHERE namespace = ?1
+            AND org_id = ?2
+            AND project_id = ?3
+            AND env_id = ?4
+            AND locator_b64u = ?5`).bind(this.scope.namespace, this.scope.orgId, this.scope.projectId, this.scope.envId, String(locatorB64u)).first();
+		if (!row) return null;
+		const walletId = parseWalletId(row.wallet_id);
+		if (!walletId.ok) return null;
+		try {
+			const parsedLocator = parseRecoveryCodeLocatorV1(row.locator_b64u);
+			if (String(parsedLocator) !== String(locatorB64u)) return null;
+			return {
+				locatorB64u: parsedLocator,
+				walletId: walletId.value,
+				recoveryKeyId: parseDerivedWalletRecoveryKeyId(row.recovery_key_id)
+			};
+		} catch {
+			return null;
+		}
+	}
+	/** Reads locator metadata without ever materializing a recovery code. */
+	async readRecoveryCodeLocatorByRecoveryKey(input) {
+		const row = await this.database.prepare(`SELECT locator_b64u, wallet_id, recovery_key_id
+           FROM wallet_recovery_code_locators
+          WHERE namespace = ?1
+            AND org_id = ?2
+            AND project_id = ?3
+            AND env_id = ?4
+            AND wallet_id = ?5
+            AND recovery_key_id = ?6
+          LIMIT 1`).bind(this.scope.namespace, this.scope.orgId, this.scope.projectId, this.scope.envId, String(input.walletId), String(input.recoveryKeyId)).first();
+		if (!row) return null;
+		const walletId = parseWalletId(row.wallet_id);
+		if (!walletId.ok || walletId.value !== input.walletId) return null;
+		try {
+			const recoveryKeyId = parseDerivedWalletRecoveryKeyId(row.recovery_key_id);
+			return {
+				locatorB64u: parseRecoveryCodeLocatorV1(row.locator_b64u),
+				walletId: walletId.value,
+				recoveryKeyId
+			};
+		} catch {
+			return null;
+		}
+	}
+	prepareRecoveryCodeLocatorInsertStatement(locator) {
+		return this.database.prepare(`INSERT INTO wallet_recovery_code_locators
+          (namespace, org_id, project_id, env_id, locator_b64u, wallet_id, recovery_key_id)
+         VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)`).bind(this.scope.namespace, this.scope.orgId, this.scope.projectId, this.scope.envId, String(locator.locatorB64u), String(locator.walletId), String(locator.recoveryKeyId));
+	}
+	prepareRecoveryCodeLocatorsDeleteForWalletStatement(walletId) {
+		return this.database.prepare(`DELETE FROM wallet_recovery_code_locators
+          WHERE namespace = ?1
+            AND org_id = ?2
+            AND project_id = ?3
+            AND env_id = ?4
+            AND wallet_id = ?5`).bind(this.scope.namespace, this.scope.orgId, this.scope.projectId, this.scope.envId, String(walletId));
+	}
+	prepareRecoveryCodeLocatorCollisionGuardStatement(locators) {
+		if (locators.length === 0) throw new Error("recovery code locator collision guard requires locators");
+		const locatorParameters = locators.map((_, index) => `?${5 + index}`).join(", ");
+		return this.database.prepare(`INSERT INTO wallet_recovery_code_locators
+          (namespace, org_id, project_id, env_id, locator_b64u, wallet_id, recovery_key_id)
+         SELECT namespace, org_id, project_id, env_id, locator_b64u, wallet_id, recovery_key_id
+           FROM wallet_recovery_code_locators
+          WHERE namespace = ?1
+            AND org_id = ?2
+            AND project_id = ?3
+            AND env_id = ?4
+            AND locator_b64u IN (${locatorParameters})`).bind(this.scope.namespace, this.scope.orgId, this.scope.projectId, this.scope.envId, ...locators.map((locator) => String(locator.locatorB64u)));
+	}
+	/** Retains the locator tombstone while `changes()` proves it existed in the atomic commit. */
+	prepareRecoveryCodeLocatorConsumeStatement(input) {
+		return this.database.prepare(`UPDATE wallet_recovery_code_locators
+            SET locator_b64u = locator_b64u
+          WHERE namespace = ?1
+            AND org_id = ?2
+            AND project_id = ?3
+            AND env_id = ?4
+            AND wallet_id = ?5
+            AND recovery_key_id = ?6`).bind(this.scope.namespace, this.scope.orgId, this.scope.projectId, this.scope.envId, String(input.walletId), String(input.recoveryKeyId));
+	}
+	prepareWalletRecoveryGoogleEmailOtpAttemptFinalizeStatement(input) {
+		return this.database.prepare(`UPDATE router_ab_yao_versioned_json_records
+            SET version = version + 1,
+                record_json = json_set(record_json, '$.state', 'finalized'),
+                updated_at_ms = ?20
+          WHERE namespace = ?1
+            AND org_id = ?2
+            AND project_id = ?3
+            AND env_id = ?4
+            AND record_key = ?5
+            AND version = ?6
+            AND json_extract(record_json, '$.version') = ?7
+            AND json_extract(record_json, '$.state') = ?8
+            AND json_extract(record_json, '$.walletId') = ?9
+            AND json_extract(record_json, '$.orgId') = ?10
+            AND json_extract(record_json, '$.reservationId') = ?11
+            AND json_extract(record_json, '$.recoveryOperationId') = ?12
+            AND json_extract(record_json, '$.targetDeviceId') = ?13
+            AND json_extract(record_json, '$.targetAuthorityId') = ?14
+            AND json_extract(record_json, '$.targetWalletAuthMethodId') = ?15
+            AND json_extract(record_json, '$.challengeId') = ?16
+            AND json_extract(record_json, '$.providerSubject') = ?17
+            AND json_extract(record_json, '$.verifiedEmail') = ?18
+            AND json_extract(record_json, '$.ownerProofBindingDigest') = ?19
+            AND json_extract(record_json, '$.target.kind') = 'google_email_otp'
+            AND json_extract(record_json, '$.target.googleProvider') = 'google'`).bind(this.scope.namespace, this.scope.orgId, this.scope.projectId, this.scope.envId, `wallet-recovery-google-email-otp:${walletRecoveryGoogleEmailOtpAttemptKey(input.recovery.recoveryOperationId)}`, input.expectedVersion, "wallet_recovery_google_email_otp_attempt_v1", "otp_verified", String(input.recovery.walletId), input.recovery.orgId, String(input.recovery.reservationId), String(input.recovery.recoveryOperationId), String(input.recovery.targetDeviceId), String(input.recovery.targetAuthorityId), String(input.recovery.targetWalletAuthMethodId), input.recovery.challengeId, input.recovery.providerSubject, input.recovery.verifiedEmail, String(input.recovery.ownerProofBindingDigest), input.finalizedAtMs);
+	}
+	/** The OTP verifier normally consumes this row before finalization. */
+	prepareWalletRecoveryGoogleEmailOtpChallengeDeleteStatement(input) {
+		return this.database.prepare(`DELETE FROM email_otp_challenges
+          WHERE namespace = ?1
+            AND org_id = ?2
+            AND project_id = ?3
+            AND env_id = ?4
+            AND challenge_id = ?5
+            AND challenge_subject_id = ?6
+            AND wallet_id = ?7
+            AND record_org_id = ?8
+            AND otp_channel = ?9
+            AND owner_proof_binding_digest = ?10
+            AND action = ?11
+            AND operation = ?12`).bind(this.scope.namespace, this.scope.orgId, this.scope.projectId, this.scope.envId, input.recovery.challengeId, input.recovery.providerSubject, String(input.recovery.walletId), input.recovery.orgId, "email_otp", String(input.recovery.ownerProofBindingDigest), WALLET_EMAIL_OTP_ACTIONS.recoveryBootstrap, "wallet_unlock");
+	}
+	async readEmailOtpEnrollment(walletId) {
+		return parseEmailOtpWalletEnrollmentRow(await this.database.prepare(`SELECT record_json, updated_at_ms
+           FROM email_otp_wallet_enrollments
+          WHERE namespace = ?1
+            AND org_id = ?2
+            AND project_id = ?3
+            AND env_id = ?4
+            AND wallet_id = ?5
+          LIMIT 1`).bind(this.scope.namespace, this.scope.orgId, this.scope.projectId, this.scope.envId, String(walletId)).first());
+	}
+	async walletRecoveryGoogleEmailOtpFinalizedAttemptMatches(recovery) {
+		const row = await this.database.prepare(`SELECT record_json
+           FROM router_ab_yao_versioned_json_records
+          WHERE namespace = ?1
+            AND org_id = ?2
+            AND project_id = ?3
+            AND env_id = ?4
+            AND record_key = ?5
+          LIMIT 1`).bind(this.scope.namespace, this.scope.orgId, this.scope.projectId, this.scope.envId, `wallet-recovery-google-email-otp:${walletRecoveryGoogleEmailOtpAttemptKey(recovery.recoveryOperationId)}`).first();
+		if (!row) return false;
+		let raw = row.record_json;
+		if (typeof raw === "string") try {
+			raw = JSON.parse(raw);
+		} catch {
+			return false;
+		}
+		const attempt = parseWalletRecoveryGoogleEmailOtpAttemptRecord(raw);
+		return attempt?.state === "finalized" && sameWalletRecoveryGoogleEmailOtpFinalizationInputV1(walletRecoveryGoogleEmailOtpFinalizationInput(attempt), recovery);
+	}
+	async walletRecoveryGoogleEmailOtpChallengeExists(challengeId) {
+		return await this.database.prepare(`SELECT 1
+           FROM email_otp_challenges
+          WHERE namespace = ?1
+            AND org_id = ?2
+            AND project_id = ?3
+            AND env_id = ?4
+            AND challenge_id = ?5
+          LIMIT 1`).bind(this.scope.namespace, this.scope.orgId, this.scope.projectId, this.scope.envId, challengeId).first() !== null;
+	}
+	/**
+	* Writes the envelope and the recovery set in one transaction.
+	*
+	* Both are inserts, never updates: `expectedVersion: null` fails if either
+	* key already holds a row, so a repeated registration cannot silently replace
+	* an established wallet's custody.
+	*/
+	async commitRegistration(commit) {
+		const inconsistency = commitInconsistency(commit);
+		if (inconsistency !== null) return {
+			kind: "inconsistent",
+			reason: inconsistency
+		};
+		const envelopeKey = passkeyCustodyEnvelopeRecordKey(passkeyCustodyEnvelopeLocatorOf(commit.envelope));
+		const recoverySetKey = walletRecoveryEnvelopeSetRecordKey(commit.recoverySet.walletId);
+		const recoveryBackupAcknowledgementKey = walletRecoveryBackupAcknowledgementRecordKey(commit.recoverySet.walletId);
+		let stored;
+		try {
+			stored = await this.records.putManyWithAdditionalStatements([
+				{
+					key: envelopeKey,
+					value: commit.envelope,
+					expectedVersion: null
+				},
+				{
+					key: recoverySetKey,
+					value: commit.recoverySet,
+					expectedVersion: null
+				},
+				{
+					key: recoveryBackupAcknowledgementKey,
+					value: commit.recoveryBackupAcknowledgement,
+					expectedVersion: null
+				}
+			], commit.recoveryCodeLocators.map((locator) => this.prepareRecoveryCodeLocatorInsertStatement(locator)));
+		} catch (error) {
+			if (isRecoveryCodeLocatorCollision(error)) return {
+				kind: "inconsistent",
+				reason: "recovery code locator already exists"
+			};
+			throw error;
+		}
+		if (stored.kind === "version_mismatch") {
+			if (stored.key === envelopeKey || (await this.records.read(envelopeKey)).kind !== "missing") return {
+				kind: "already_exists",
+				key: stored.key
+			};
+			return {
+				kind: "custody_already_established",
+				walletId: commit.recoverySet.walletId
+			};
+		}
+		const envelopeVersion = stored.versions.find((entry) => entry.key === envelopeKey);
+		const recoverySetVersion = stored.versions.find((entry) => entry.key === recoverySetKey);
+		const recoveryBackupAcknowledgementVersion = stored.versions.find((entry) => entry.key === recoveryBackupAcknowledgementKey);
+		if (!envelopeVersion || !recoverySetVersion || !recoveryBackupAcknowledgementVersion) throw new Error("wallet custody commit did not report both record versions");
+		return {
+			kind: "committed",
+			envelopeStoreVersion: envelopeVersion.version,
+			recoverySetStoreVersion: recoverySetVersion.version
+		};
+	}
+	/**
+	* Reads a wallet's recovery envelope set. Returns null when absent, and also
+	* when the stored row is not a recovery set — a row that fails its own parser
+	* is unusable, and reporting it as present would invite a caller to act on a
+	* record nothing validated.
+	*/
+	async readRecoveryEnvelopeSet(walletId) {
+		const read = await this.records.read(walletRecoveryEnvelopeSetRecordKey(walletId));
+		if (read.kind === "missing") return null;
+		if (read.value.kind !== "wallet_recovery_envelope_set_v1") return null;
+		try {
+			return {
+				record: parseWalletRecoveryEnvelopeSetRecord(read.value, {
+					expectedWalletId: walletId,
+					label: "walletRecoveryEnvelopeSet"
+				}),
+				storeVersion: read.version
+			};
+		} catch {
+			return null;
+		}
+	}
+	async listWalletAuthMethods(walletId) {
+		return await this.walletAuthMethodStore.listForWalletV2({ walletId: String(walletId) });
+	}
+	async readWalletAuthMethodById(walletAuthMethodId) {
+		return await this.walletAuthMethodStore.readByIdV2({ walletAuthMethodId });
+	}
+	async readPasskeyWalletAuthMethod(input) {
+		const method = await this.walletAuthMethodStore.getPasskeyV2(input);
+		return method?.kind === "passkey" ? method : null;
+	}
+	/**
+	* Reads the wallet's backup acknowledgement, if any.
+	*
+	* Absent is the normal state for a wallet whose owner has not confirmed
+	* saving their codes, so it is `null` rather than an error.
+	*/
+	async readBackupAcknowledgement(walletId) {
+		const read = await this.records.read(walletRecoveryBackupAcknowledgementRecordKey(walletId));
+		if (read.kind === "missing") return null;
+		const parsed = parseWalletRecoveryBackupAcknowledgementV1(read.value, { expectedWalletId: String(walletId) });
+		return parsed.ok ? parsed.record : null;
+	}
+	/**
+	* Records that the owner confirmed saving their codes.
+	*
+	* Written with no expected version, unlike the recovery set: this row is
+	* cosmetic, a repeat acknowledgement is not a conflict worth surfacing to
+	* someone pressing a button, and it shares no record with the wraps a spend
+	* updates — which is exactly why it is a separate key.
+	*/
+	async writeBackupAcknowledgement(record) {
+		const key = walletRecoveryBackupAcknowledgementRecordKey(requireWalletId(record.walletId));
+		const existing = await this.records.read(key);
+		return (await this.records.put(key, record, existing.kind === "missing" ? null : existing.version)).kind === "stored" ? { kind: "stored" } : { kind: "conflict" };
+	}
+	/**
+	* Writes a recovery set back, refusing if it changed underneath.
+	*
+	* The expected version is the whole point. Burning a recovery code is a
+	* read-modify-write on one shared record, so two concurrent attempts that
+	* both read the same set would otherwise each write their own view — and
+	* the second write would silently restore the first attempt's consumed code
+	* to the active pool. A single-use code that survives its use is the one
+	* failure this record must not have.
+	*/
+	async writeRecoveryEnvelopeSet(input) {
+		const result = await this.records.put(walletRecoveryEnvelopeSetRecordKey(input.record.walletId), input.record, input.expectedStoreVersion);
+		if (result.kind !== "stored") return { kind: "conflict" };
+		return {
+			kind: "stored",
+			storeVersion: result.version
+		};
+	}
+	/**
+	* Replaces a complete recovery set and carries the backup-ack row through
+	* the same CAS. The acknowledgement still names the previous issuance, so
+	* status naturally reports the fresh set as outstanding until the UI calls
+	* the explicit acknowledge route. Both rows are guarded against races.
+	*/
+	async replaceRecoveryEnvelopeSetAndPreserveBackupAcknowledgement(input) {
+		const acknowledgementKey = walletRecoveryBackupAcknowledgementRecordKey(input.record.walletId);
+		const existingAcknowledgement = await this.records.read(acknowledgementKey);
+		const mutations = [{
+			key: walletRecoveryEnvelopeSetRecordKey(input.record.walletId),
+			value: input.record,
+			expectedVersion: input.expectedRecoverySetVersion
+		}, ...existingAcknowledgement.kind === "present" ? [{
+			key: acknowledgementKey,
+			value: existingAcknowledgement.value,
+			expectedVersion: existingAcknowledgement.version
+		}] : []];
+		let stored;
+		try {
+			stored = await this.records.putManyWithAdditionalStatements(mutations, [
+				this.prepareRecoveryCodeLocatorCollisionGuardStatement(input.recoveryCodeLocators),
+				this.prepareRecoveryCodeLocatorsDeleteForWalletStatement(input.record.walletId),
+				...input.recoveryCodeLocators.map((locator) => this.prepareRecoveryCodeLocatorInsertStatement(locator))
+			]);
+		} catch (error) {
+			if (isRecoveryCodeLocatorCollision(error)) return { kind: "collision" };
+			throw error;
+		}
+		if (stored.kind === "version_mismatch") return { kind: "conflict" };
+		const version = stored.versions.find((entry) => entry.key === walletRecoveryEnvelopeSetRecordKey(input.record.walletId));
+		if (!version) throw new Error("recovery-set rotation did not report its store version");
+		return {
+			kind: "stored",
+			storeVersion: version.version
+		};
+	}
+	/**
+	* Installs a fresh recovered-device authority and Passkey target while
+	* consuming its held code in one D1 transaction. The continuity authority,
+	* methods, envelopes, and sessions are deliberately never updated here.
+	* Current recovery activation output has no fresh Ed25519 reference, so the
+	* first functional slice requires the target authority to reuse the exact
+	* anchor signer activation set.
+	*/
+	async commitRecoveryAuthorityInstall(input) {
+		const walletId = input.recoverySet.walletId;
+		if (String(input.authority.walletId) !== String(walletId) || String(input.continuityAuthority.walletId) !== String(walletId)) return {
+			kind: "inconsistent",
+			reason: "recovery authority records name different wallets"
+		};
+		if (input.authority.state !== "active" || input.authority.provenance.kind !== "wallet_recovery" || input.authority.provenance.continuityAuthorityId !== input.continuityAuthority.authorityId || input.authority.authorityId === input.continuityAuthority.authorityId || input.authority.principal.deviceId === input.continuityAuthority.principal.deviceId) return {
+			kind: "inconsistent",
+			reason: "recovery authority must be a fresh active device authority"
+		};
+		if (!hasFullOwnerPermissionsV1(input.authority.permissions)) return {
+			kind: "inconsistent",
+			reason: "recovery authority must have full-owner permissions"
+		};
+		if (!sameWalletSignerActivationSetV1(input.authority.signerActivations, input.continuityAuthority.signerActivations)) return {
+			kind: "inconsistent",
+			reason: "recovery authority signer activations violate custody continuity"
+		};
+		if (input.replacementEnvelope.walletId !== walletId || input.replacementEnvelope.binding.kind !== "wallet_custody_seed_v1" || input.replacementEnvelope.factor.kind !== "passkey" || input.replacementEnvelope.lifecycle.state !== "active" || Number(input.replacementEnvelope.envelopeRevision) !== 1 || input.replacementEnvelope.ownership.kind !== "method_bound") return {
+			kind: "inconsistent",
+			reason: "recovery install requires a first-revision active wallet custody envelope"
+		};
+		if (input.authenticatorCommit.userId !== String(walletId)) return {
+			kind: "inconsistent",
+			reason: "replacement authenticator names a different wallet"
+		};
+		const targetMethod = input.authenticatorCommit.walletAuthMethod;
+		if (targetMethod.kind !== "passkey" || targetMethod.status !== "active" || targetMethod.walletId !== walletId || targetMethod.walletAuthorityId !== input.authority.authorityId || input.replacementEnvelope.ownership.walletAuthMethodId !== targetMethod.walletAuthMethodId || targetMethod.rpId !== input.replacementEnvelope.factor.rpId || targetMethod.credentialIdB64u !== input.replacementEnvelope.factor.credentialIdB64u || targetMethod.credentialPublicKeyB64u !== input.authenticatorCommit.authenticator.credentialPublicKeyB64u || targetMethod.counter !== input.authenticatorCommit.authenticator.counter || input.authenticatorCommit.binding.userId !== String(walletId) || input.authenticatorCommit.binding.rpId !== targetMethod.rpId || input.authenticatorCommit.binding.credentialIdB64u !== targetMethod.credentialIdB64u || input.authenticatorCommit.authenticator.credentialIdB64u !== targetMethod.credentialIdB64u || !String(targetMethod.walletAuthMethodId).startsWith("wallet-auth-method:")) return {
+			kind: "inconsistent",
+			reason: "recovery authority, method, envelope, and authenticator disagree"
+		};
+		if (input.recoverySet.manifestKekWraps.filter((wrap) => wrap.lifecycle.state === "consumed" && wrap.lifecycle.reservationId === input.reservationId).length !== 1) return {
+			kind: "inconsistent",
+			reason: "recovery install must consume exactly its reserved recovery code"
+		};
+		const envelopeKey = passkeyCustodyEnvelopeRecordKey(passkeyCustodyEnvelopeLocatorOf(input.replacementEnvelope));
+		const recoverySetKey = walletRecoveryEnvelopeSetRecordKey(walletId);
+		const authorityStatement = prepareD1WalletAuthorityPutStatement({
+			database: this.database,
+			scope: {
+				namespace: this.scope.namespace,
+				orgId: this.scope.orgId,
+				projectId: this.scope.projectId,
+				envId: this.scope.envId
+			},
+			authority: input.authority
+		});
+		const authenticatorStatement = prepareD1WebAuthnAuthenticatorInsertStatement({
+			database: this.database,
+			scope: {
+				namespace: this.scope.namespace,
+				orgId: this.scope.orgId,
+				projectId: this.scope.projectId,
+				envId: this.scope.envId
+			},
+			userId: input.authenticatorCommit.userId,
+			record: input.authenticatorCommit.authenticator
+		});
+		const bindingStatement = prepareD1WebAuthnCredentialBindingInsertStatement({
+			database: this.database,
+			scope: {
+				namespace: this.scope.namespace,
+				orgId: this.scope.orgId,
+				projectId: this.scope.projectId,
+				envId: this.scope.envId
+			},
+			record: input.authenticatorCommit.binding
+		});
+		const walletAuthMethodStatements = this.walletAuthMethodStore.prepareV2InsertStatements(targetMethod);
+		let stored;
+		try {
+			stored = await this.records.putManyWithAdditionalStatements([{
+				key: recoverySetKey,
+				value: input.recoverySet,
+				expectedVersion: input.expectedRecoverySetVersion
+			}, {
+				key: envelopeKey,
+				value: input.replacementEnvelope,
+				expectedVersion: null
+			}], [
+				authorityStatement,
+				...walletAuthMethodStatements,
+				authenticatorStatement,
+				bindingStatement,
+				input.authenticatorCommit.challengeDeleteStatement,
+				this.database.prepare(WEB_AUTHN_RECOVERY_CHALLENGE_CAS_GUARD),
+				this.prepareRecoveryCodeLocatorConsumeStatement({
+					walletId,
+					recoveryKeyId: input.recoveryKeyId
+				}),
+				this.database.prepare(RECOVERY_CODE_LOCATOR_CAS_GUARD)
+			]);
+		} catch {
+			return { kind: "conflict" };
+		}
+		if (stored.kind === "version_mismatch") {
+			const [recoveryRead, envelopeRead, authorityRead, methodRead, locatorRead] = await Promise.all([
+				this.readRecoveryEnvelopeSet(walletId),
+				this.records.read(envelopeKey),
+				this.walletAuthorityStore.readById(input.authority.authorityId),
+				this.walletAuthMethodStore.readByIdV2({ walletAuthMethodId: targetMethod.walletAuthMethodId }),
+				this.readRecoveryCodeLocatorByRecoveryKey({
+					walletId,
+					recoveryKeyId: input.recoveryKeyId
+				})
+			]);
+			const alreadyConsumed = recoveryRead?.record.manifestKekWraps.some((wrap) => wrap.lifecycle.state === "consumed" && wrap.lifecycle.reservationId === input.reservationId);
+			const sameEnvelope = envelopeRead.kind === "present" && envelopeRead.value.kind === "wallet_custody_envelope_v2" && sameWalletCustodyRecoveryReplacementEnvelopeV1(envelopeRead.value, input.replacementEnvelope);
+			const sameAuthority = authorityRead?.state === "active" ? await sameVerifiedActiveWalletAuthorityV1(authorityRead, input.authority) : false;
+			const sameMethod = methodRead !== null && sameWalletAuthMethodRecordV2(methodRead, targetMethod);
+			if (alreadyConsumed && sameEnvelope && sameAuthority && sameMethod && locatorRead) return {
+				kind: "already_committed",
+				envelopeStoreVersion: envelopeRead.version
+			};
+			return { kind: "conflict" };
+		}
+		const envelopeVersion = stored.versions.find((entry) => entry.key === envelopeKey);
+		if (!envelopeVersion) throw new Error("wallet recovery install did not report the envelope version");
+		return {
+			kind: "committed",
+			envelopeStoreVersion: envelopeVersion.version
+		};
+	}
+	/**
+	* Exact readback for a retry after the recovery attempt was deleted. The
+	* target rows and the consumed reservation are the durable receipt; no
+	* source authority, method, envelope, or session is consulted for mutation.
+	*/
+	async resolveRecoveryGoogleEmailOtpReplay(input) {
+		const recovery = input.recovery;
+		const walletId = recovery.walletId;
+		const replacement = input.replacementEnvelope;
+		if (replacement.walletId !== walletId || replacement.binding.kind !== "wallet_custody_seed_v1" || replacement.factor.kind !== "email_otp" || replacement.lifecycle.state !== "active" || Number(replacement.envelopeRevision) !== 1 || replacement.ownership.kind !== "method_bound" || replacement.ownership.walletAuthMethodId !== recovery.targetWalletAuthMethodId) return {
+			kind: "inconsistent",
+			reason: "recovery replay envelope is not target-bound"
+		};
+		if (input.enrollment.walletId !== walletId || input.enrollment.orgId !== recovery.orgId || input.enrollment.providerUserId !== recovery.providerSubject || input.enrollment.verifiedEmail !== recovery.verifiedEmail || replacement.factor.enrollmentId !== input.enrollment.enrollmentId || replacement.factor.enrollmentSealKeyVersion !== input.enrollment.enrollmentSealKeyVersion) return {
+			kind: "inconsistent",
+			reason: "recovery replay enrollment is not target-bound"
+		};
+		const expectedEmailHashHex = await sha256HexUtf8(recovery.verifiedEmail);
+		const recoverySet = await this.readRecoveryEnvelopeSet(walletId);
+		if (!recoverySet) return { kind: "conflict" };
+		const consumed = recoverySet.record.manifestKekWraps.filter((wrap) => wrap.lifecycle.state === "consumed" && wrap.lifecycle.reservationId === recovery.reservationId);
+		if (consumed.length !== 1) return { kind: "conflict" };
+		const recoveryKeyId = consumed[0]?.recoveryKeyId;
+		if (!recoveryKeyId) return { kind: "conflict" };
+		const envelopeKey = passkeyCustodyEnvelopeRecordKey(passkeyCustodyEnvelopeLocatorOf(replacement));
+		const [envelopeRead, authority, method, enrollment, finalizedAttemptMatches, challengeExists] = await Promise.all([
+			this.records.read(envelopeKey),
+			this.walletAuthorityStore.readById(recovery.targetAuthorityId),
+			this.walletAuthMethodStore.readByIdV2({ walletAuthMethodId: recovery.targetWalletAuthMethodId }),
+			this.readEmailOtpEnrollment(walletId),
+			this.walletRecoveryGoogleEmailOtpFinalizedAttemptMatches(recovery),
+			this.walletRecoveryGoogleEmailOtpChallengeExists(recovery.challengeId)
+		]);
+		const locator = await this.readRecoveryCodeLocatorByRecoveryKey({
+			walletId,
+			recoveryKeyId
+		});
+		const sameEnvelope = envelopeRead?.kind === "present" && envelopeRead.value.kind === "wallet_custody_envelope_v2" && sameWalletCustodyRecoveryReplacementEnvelopeV1(envelopeRead.value, replacement);
+		const sameAuthority = authority !== null && authority.state === "active" && await walletAuthorityDigestsMatchV1(authority) && authority.walletId === walletId && authority.authorityId === recovery.targetAuthorityId && authority.principal.deviceId === recovery.targetDeviceId && authority.provenance.kind === "wallet_recovery" && authority.provenance.recoveryOperationId === recovery.recoveryOperationId && authority.provenance.continuityAuthorityId !== recovery.targetAuthorityId && hasFullOwnerPermissionsV1(authority.permissions);
+		const sameMethod = method !== null && method.kind === "email_otp" && method.status === "active" && method.walletId === walletId && method.walletAuthorityId === recovery.targetAuthorityId && method.walletAuthMethodId === recovery.targetWalletAuthMethodId && method.emailHashHex === expectedEmailHashHex && method.registrationAuthorityId === recovery.challengeId;
+		const sameEnrollment = enrollment !== null && sameEmailOtpWalletEnrollmentRecordV1(enrollment, input.enrollment) && (recovery.targetEnrollment.kind === "existing" ? enrollment.enrollmentId === recovery.targetEnrollment.enrollmentId && enrollment.enrollmentSealKeyVersion === recovery.targetEnrollment.enrollmentSealKeyVersion : enrollment.enrollmentId === emailOtpDeviceEnrollmentId(String(walletId), recovery.providerSubject));
+		if (sameEnvelope && sameAuthority && sameMethod && sameEnrollment && locator !== null && finalizedAttemptMatches && !challengeExists) return {
+			kind: "already_committed",
+			envelopeStoreVersion: envelopeRead.version
+		};
+		return { kind: "conflict" };
+	}
+	/** Installs a fresh Email OTP authority and envelope in one D1 transaction. */
+	async commitRecoveryGoogleEmailOtpAuthorityInstall(input) {
+		const recovery = input.recovery;
+		const walletId = recovery.walletId;
+		const targetMethod = input.walletAuthMethod;
+		const enrollment = input.enrollmentCommit.enrollment;
+		if (String(input.recoveryAttemptStoreVersion).trim() === "" || input.recoverySet.walletId !== walletId || input.authority.walletId !== walletId || input.continuityAuthority.walletId !== walletId || input.expectedRecoverySetVersion.trim() === "") return {
+			kind: "inconsistent",
+			reason: "recovery Email commit identities are inconsistent"
+		};
+		if (input.authority.state !== "active" || input.authority.authorityId !== recovery.targetAuthorityId || input.authority.principal.deviceId !== recovery.targetDeviceId || input.authority.authorityId === input.continuityAuthority.authorityId || input.authority.principal.deviceId === input.continuityAuthority.principal.deviceId || input.authority.provenance.kind !== "wallet_recovery" || input.authority.provenance.recoveryOperationId !== recovery.recoveryOperationId || input.authority.provenance.continuityAuthorityId !== input.continuityAuthority.authorityId || !hasFullOwnerPermissionsV1(input.authority.permissions)) return {
+			kind: "inconsistent",
+			reason: "recovery Email authority is not fresh and active"
+		};
+		if (!sameWalletSignerActivationSetV1(input.authority.signerActivations, input.continuityAuthority.signerActivations)) return {
+			kind: "inconsistent",
+			reason: "recovery Email signer activations changed"
+		};
+		if (targetMethod.kind !== "email_otp" || targetMethod.status !== "active" || targetMethod.walletId !== walletId || targetMethod.walletAuthorityId !== input.authority.authorityId || targetMethod.walletAuthMethodId !== recovery.targetWalletAuthMethodId || targetMethod.registrationAuthorityId !== recovery.challengeId || !String(targetMethod.walletAuthMethodId).startsWith("wallet-auth-method:")) return {
+			kind: "inconsistent",
+			reason: "recovery Email method is not target-bound"
+		};
+		const expectedEmailHashHex = await sha256HexUtf8(recovery.verifiedEmail);
+		if (targetMethod.emailHashHex !== expectedEmailHashHex) return {
+			kind: "inconsistent",
+			reason: "recovery Email method identity changed"
+		};
+		if (input.replacementEnvelope.walletId !== walletId || input.replacementEnvelope.binding.kind !== "wallet_custody_seed_v1" || input.replacementEnvelope.factor.kind !== "email_otp" || input.replacementEnvelope.lifecycle.state !== "active" || Number(input.replacementEnvelope.envelopeRevision) !== 1 || input.replacementEnvelope.ownership.kind !== "method_bound" || input.replacementEnvelope.ownership.walletAuthMethodId !== targetMethod.walletAuthMethodId || input.replacementEnvelope.factor.enrollmentId !== enrollment.enrollmentId || input.replacementEnvelope.factor.enrollmentSealKeyVersion !== enrollment.enrollmentSealKeyVersion) return {
+			kind: "inconsistent",
+			reason: "recovery Email envelope is not target-bound"
+		};
+		if (enrollment.walletId !== walletId || enrollment.orgId !== recovery.orgId || enrollment.providerUserId !== recovery.providerSubject || enrollment.verifiedEmail !== recovery.verifiedEmail) return {
+			kind: "inconsistent",
+			reason: "recovery Email enrollment identity changed"
+		};
+		switch (recovery.targetEnrollment.kind) {
+			case "existing":
+				if (input.enrollmentCommit.kind !== "existing" || input.enrollmentCommit.statements.length !== 0 || enrollment.enrollmentId !== recovery.targetEnrollment.enrollmentId || enrollment.enrollmentSealKeyVersion !== recovery.targetEnrollment.enrollmentSealKeyVersion) return {
+					kind: "inconsistent",
+					reason: "existing recovery Email enrollment changed"
+				};
+				break;
+			case "create":
+				if (input.enrollmentCommit.kind !== "create" || input.enrollmentCommit.statements.length === 0 || enrollment.providerUserId !== recovery.targetEnrollment.providerSubject || enrollment.verifiedEmail !== recovery.targetEnrollment.verifiedEmail || enrollment.enrollmentId !== emailOtpDeviceEnrollmentId(String(walletId), recovery.providerSubject)) return {
+					kind: "inconsistent",
+					reason: "new recovery Email enrollment is invalid"
+				};
+				break;
+		}
+		if (input.recoverySet.manifestKekWraps.filter((wrap) => wrap.lifecycle.state === "consumed" && wrap.lifecycle.reservationId === recovery.reservationId && wrap.recoveryKeyId === input.recoveryKeyId).length !== 1) return {
+			kind: "inconsistent",
+			reason: "recovery Email commit must consume its reserved code"
+		};
+		const envelopeKey = passkeyCustodyEnvelopeRecordKey(passkeyCustodyEnvelopeLocatorOf(input.replacementEnvelope));
+		const recoverySetKey = walletRecoveryEnvelopeSetRecordKey(walletId);
+		const authorityStatement = prepareD1WalletAuthorityPutStatement({
+			database: this.database,
+			scope: {
+				namespace: this.scope.namespace,
+				orgId: this.scope.orgId,
+				projectId: this.scope.projectId,
+				envId: this.scope.envId
+			},
+			authority: input.authority
+		});
+		const walletAuthMethodStatements = this.walletAuthMethodStore.prepareV2InsertStatements(targetMethod);
+		let stored;
+		try {
+			stored = await this.records.putManyWithAdditionalStatements([{
+				key: recoverySetKey,
+				value: input.recoverySet,
+				expectedVersion: input.expectedRecoverySetVersion
+			}, {
+				key: envelopeKey,
+				value: input.replacementEnvelope,
+				expectedVersion: null
+			}], [
+				authorityStatement,
+				...input.enrollmentCommit.statements,
+				...walletAuthMethodStatements,
+				this.prepareWalletRecoveryGoogleEmailOtpChallengeDeleteStatement({ recovery }),
+				this.prepareWalletRecoveryGoogleEmailOtpAttemptFinalizeStatement({
+					recovery,
+					expectedVersion: input.recoveryAttemptStoreVersion,
+					finalizedAtMs: input.authority.updatedAtMs
+				}),
+				this.database.prepare(WALLET_RECOVERY_GOOGLE_EMAIL_OTP_ATTEMPT_CAS_GUARD),
+				this.prepareRecoveryCodeLocatorConsumeStatement({
+					walletId,
+					recoveryKeyId: input.recoveryKeyId
+				}),
+				this.database.prepare(RECOVERY_CODE_LOCATOR_CAS_GUARD)
+			]);
+		} catch {
+			return { kind: "conflict" };
+		}
+		if (stored.kind === "version_mismatch") return await this.resolveRecoveryGoogleEmailOtpReplay({
+			recovery,
+			replacementEnvelope: input.replacementEnvelope,
+			enrollment
+		});
+		const envelopeVersion = stored.versions.find((entry) => entry.key === envelopeKey);
+		if (!envelopeVersion) throw new Error("wallet recovery Email install did not report the envelope version");
+		return {
+			kind: "committed",
+			envelopeStoreVersion: envelopeVersion.version
+		};
+	}
+};
+//#endregion
+export { CloudflareD1WalletCustodyCommitStore, walletRecoveryBackupAcknowledgementRecordKey, walletRecoveryEnvelopeSetRecordKey };
+
+//# sourceMappingURL=d1WalletCustodyCommitStore.js.map