@seams/wallet-server 0.5.0

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

@@ -0,0 +1,871 @@
+import { parseEmailOtpProviderUserId, parsePasskeyEnvelopeId, parseWalletAuthMethodId, parseWalletAuthorityBindingDigest, parseWalletAuthorityId, parseWalletId, parseWalletRecoveryOperationId, parseWebAuthnRpId } from "../../../../shared-ts/src/utils/domainIds.js";
+import { parseDeviceId } from "../../../../shared-ts/src/authorization/capabilityKinds.js";
+import { base64UrlEncode } from "../../../../shared-ts/src/utils/base64.js";
+import "../../../../shared-ts/src/utils/encoders.js";
+import { isActiveRecoveredWalletAuthorityV1, walletAuthorityDigestsMatchV1 } from "../../../../shared-ts/src/authorization/walletAuthority.js";
+import { secureRandomBase64Url } from "../../../../shared-ts/src/utils/secureRandomId.js";
+import { PASSKEY_PRF_FIRST_SALT_V1, PASSKEY_PRF_SECOND_SALT_V1 } from "../../../../shared-ts/src/utils/signingSessionSeal.js";
+import { isHostWithinRpId, originHostnameOrEmpty } from "../../../../core/authService/webauthnOidcHelpers.js";
+import { buildWalletRecoveryBackupAcknowledgementV1, walletRecoveryBackupIsOutstanding } from "../../../../shared-ts/src/wallet-recovery/backupAcknowledgement.js";
+import "../../../../shared-ts/src/wallet-recovery/recoveryCodes.js";
+import { deriveRecoveryCodeLocatorV1FromBytes } from "../../../../shared-ts/src/wallet-recovery/recoveryCodeLocator.js";
+import { buildWebAuthnRecoveryContinuityAnchorRecord } from "../webauthn/d1WebAuthnRecords.js";
+import { buildWalletRecoveryCommittedProjectionV1 } from "../../../../shared-ts/src/wallet-recovery/walletRecoveryCommittedProjection.js";
+import { envelopeFactorRef } from "./d1PasskeyCustodyEnvelopeStore.js";
+import { buildPreparedWalletRecoveryGoogleEmailOtpAttempt, walletRecoveryGoogleEmailOtpFinalizationInput } from "./d1WalletRecoveryGoogleEmailOtpRecords.js";
+import { handlePasskeyCustodyEnvelopeRetrieval } from "../../../domains/passkeyCustody/passkeyCustodyEnvelopeRetrievalRoute.js";
+import { prepareWalletRecoveryWithCodeV1 } from "../../../domains/passkeyCustody/walletRecoveryAttempt.js";
+import { buildWalletRecoveryEcdsaPossessionChallengesV1, projectWalletRecoveryPreparationKeyManifestV1, projectWalletUnlockKeyManifestV1, resolveWalletRecoveryKeyManifestV1 } from "../../../domains/passkeyCustody/walletRecoveryKeyManifest.js";
+import { finalizeRecoveredWalletCredentialV1, resolveCommittedRecoveryReplayV1 } from "../../../domains/passkeyCustody/walletRecoveryFinalization.js";
+import { rotateWalletRecoveryCodesV1 } from "../../../domains/passkeyCustody/walletRecoveryRotation.js";
+//#region src/router/cloudflare/d1/passkeyCustody/d1PasskeyCustodyRouteService.ts
+/** How long a reservation may sit before another attempt may take the code. */
+const RECOVERY_RESERVATION_TTL_MS = 300 * 1e3;
+/**
+* Finds the one existing custody path that can authenticate a recovery code.
+* The target's RP is deliberately absent: it describes the new credential,
+* while continuity belongs to an already enrolled method and its envelope.
+*/
+function selectWalletRecoveryContinuityAnchor(input) {
+	const authoritiesById = new Map(input.authorities.filter((authority) => authority.state === "active" && authority.walletId === input.walletId).map((authority) => [String(authority.authorityId), authority]));
+	const candidates = [];
+	for (const method of input.methods) {
+		if (method.status !== "active" || method.walletId !== input.walletId) continue;
+		const authority = authoritiesById.get(String(method.walletAuthorityId));
+		if (!authority) continue;
+		const activeEnvelopes = input.envelopes.filter((envelope) => isActivePasskeyCustodyEnvelopeRecord(envelope) && envelope.walletId === input.walletId && envelope.binding.kind === "wallet_custody_seed_v1" && envelope.ownership.kind === "method_bound" && envelope.ownership.walletAuthMethodId === method.walletAuthMethodId && envelopeFactorMatchesAuthMethod(envelope, method));
+		if (activeEnvelopes.length !== 1) continue;
+		const [envelope] = activeEnvelopes;
+		if (!envelope) continue;
+		candidates.push({
+			kind: "wallet_recovery_continuity_anchor_v1",
+			authority,
+			method,
+			envelope
+		});
+	}
+	candidates.sort((left, right) => compareContinuityAnchors(left, right, input.targetFamily));
+	return candidates[0];
+}
+function walletRecoveryTargetFamily(target) {
+	switch (target.kind) {
+		case "passkey": return "passkey";
+		case "google_email_otp": return "email_otp";
+	}
+	return assertNeverWalletRecoveryTarget(target);
+}
+function assertNeverWalletRecoveryTarget(value) {
+	throw new Error(`Unsupported wallet recovery target kind: ${String(value)}`);
+}
+function compareContinuityAnchors(left, right, targetFamily) {
+	const leftRegistration = left.authority.provenance.kind === "wallet_registration" ? 0 : 1;
+	const rightRegistration = right.authority.provenance.kind === "wallet_registration" ? 0 : 1;
+	if (leftRegistration !== rightRegistration) return leftRegistration - rightRegistration;
+	const leftFamily = left.method.kind === targetFamily ? 0 : 1;
+	const rightFamily = right.method.kind === targetFamily ? 0 : 1;
+	if (leftFamily !== rightFamily) return leftFamily - rightFamily;
+	if (left.method.createdAtMs !== right.method.createdAtMs) return left.method.createdAtMs - right.method.createdAtMs;
+	const methodOrder = String(left.method.walletAuthMethodId).localeCompare(String(right.method.walletAuthMethodId));
+	if (methodOrder !== 0) return methodOrder;
+	return String(left.envelope.envelopeId).localeCompare(String(right.envelope.envelopeId));
+}
+function envelopeFactorMatchesAuthMethod(envelope, method) {
+	if (method.kind === "passkey") return envelope.factor.kind === "passkey" && envelope.factor.rpId === method.rpId && envelope.factor.credentialIdB64u === method.credentialIdB64u;
+	return envelope.factor.kind === "email_otp";
+}
+function isActivePasskeyCustodyEnvelopeRecord(envelope) {
+	return envelope.lifecycle.state === "active";
+}
+async function readWalletRecoveryAuthoritySelections(input) {
+	const authorityIds = [...new Set(input.methods.filter((method) => method.status === "active" && method.walletId === input.walletId).map((method) => method.walletAuthorityId))];
+	const authorities = await Promise.all(authorityIds.map((authorityId) => input.walletAuthorityStore.readById(authorityId)));
+	const selections = [];
+	for (const authority of authorities) {
+		if (!authority || authority.state !== "active" || authority.walletId !== input.walletId) continue;
+		selections.push(authority);
+	}
+	return selections;
+}
+function walletRecoveryAuthorityDigest(authority) {
+	const parsed = parseWalletAuthorityBindingDigest(String(authority.authorityDigestB64u));
+	if (!parsed.ok) throw new Error("wallet recovery authority digest is invalid");
+	return parsed.value;
+}
+function allocateRecoveryTargetIdentity() {
+	const recoveryOperationId = parseWalletRecoveryOperationId(`wallet-recovery-operation:${secureRandomBase64Url(24, "wallet recovery operation id")}`);
+	const targetDeviceId = parseDeviceId(`device:${secureRandomBase64Url(24, "wallet recovery device id")}`);
+	const targetAuthorityId = parseWalletAuthorityId(`wallet-authority:${secureRandomBase64Url(24, "wallet recovery authority id")}`);
+	const targetWalletAuthMethodId = parseWalletAuthMethodId(`wallet-auth-method:${secureRandomBase64Url(24, "wallet recovery auth method id")}`);
+	if (!recoveryOperationId.ok || !targetDeviceId.ok || !targetAuthorityId.ok || !targetWalletAuthMethodId.ok) return null;
+	return {
+		recoveryOperationId: recoveryOperationId.value,
+		targetDeviceId: targetDeviceId.value,
+		targetAuthorityId: targetAuthorityId.value,
+		targetWalletAuthMethodId: targetWalletAuthMethodId.value
+	};
+}
+function nowMsForAssembly(input) {
+	return (input.nowMs ?? Date.now)();
+}
+function isOriginWithinRpId(origin, rpId) {
+	return isHostWithinRpId(originHostnameOrEmpty(origin), rpId);
+}
+async function unavailableWalletRecoveryGoogleVerify(_request) {
+	return {
+		ok: false,
+		code: "not_configured",
+		message: "Google Email OTP recovery is not configured"
+	};
+}
+async function unavailableWalletRecoveryEmailOtpVerify(_request) {
+	return {
+		ok: false,
+		code: "not_configured",
+		message: "Google Email OTP recovery is not configured"
+	};
+}
+async function unavailableWalletRecoveryEmailOtpRelease(_request) {
+	return {
+		ok: false,
+		code: "not_configured",
+		message: "Google Email OTP recovery is not configured"
+	};
+}
+function createD1PasskeyCustodyRouteService(assembly) {
+	const authenticatorStore = authenticatorStoreView(assembly.webAuthnStore);
+	const googleRecovery = assembly.googleRecovery;
+	return {
+		readVerifiedFactorCustody: async (request) => {
+			const envelope = await assembly.passkeyCustodyEnvelopes.lookupEnvelopeForFactor(request);
+			if (envelope.kind !== "active") return envelope;
+			try {
+				const manifest = await resolveWalletRecoveryKeyManifestV1({
+					registry: assembly.walletStore,
+					walletId: request.walletId
+				});
+				if (request.factor.kind === "passkey") await assembly.passkeyCustodyEnvelopes.recordWalletCredentialUse({
+					walletId: request.walletId,
+					envelopeId: envelope.envelope.envelopeId,
+					usedAtMs: (assembly.nowMs ?? Date.now)()
+				}).catch(() => void 0);
+				return {
+					...envelope,
+					keyManifest: projectWalletUnlockKeyManifestV1(manifest)
+				};
+			} catch (error) {
+				return {
+					kind: "manifest_unavailable",
+					reason: error instanceof Error ? error.message : "wallet custody key manifest is unavailable"
+				};
+			}
+		},
+		readVerifiedEmailOtpMethodCustody: async (request) => {
+			const envelope = await assembly.passkeyCustodyEnvelopes.lookupEnvelopeForWalletAuthMethod(request);
+			if (envelope.kind !== "active") return envelope;
+			try {
+				const manifest = await resolveWalletRecoveryKeyManifestV1({
+					registry: assembly.walletStore,
+					walletId: request.walletId
+				});
+				return {
+					...envelope,
+					keyManifest: projectWalletUnlockKeyManifestV1(manifest)
+				};
+			} catch (error) {
+				return {
+					kind: "manifest_unavailable",
+					reason: error instanceof Error ? error.message : "wallet custody key manifest is unavailable"
+				};
+			}
+		},
+		listWalletCredentials: async (request) => await assembly.passkeyCustodyEnvelopes.listWalletCredentialActivity(request.walletId),
+		renameWalletCredential: async (request) => {
+			const envelopeId = parsePasskeyEnvelopeId(request.envelopeId);
+			if (!envelopeId.ok) return { kind: "invalid_envelope_id" };
+			const label = request.label === void 0 ? void 0 : String(request.label);
+			return await assembly.passkeyCustodyEnvelopes.renameWalletCredential({
+				walletId: request.walletId,
+				envelopeId: envelopeId.value,
+				...label === void 0 ? {} : { label },
+				nowMs: (assembly.nowMs ?? Date.now)()
+			});
+		},
+		upgradeEnvelopeOwnership: async (request) => {
+			const submitted = request.envelope;
+			if (String(submitted.walletId) !== String(request.walletId)) return {
+				kind: "refused",
+				reason: "the custody envelope belongs to a different wallet"
+			};
+			if (submitted.ownership.kind !== "method_bound" || String(submitted.ownership.walletAuthMethodId) !== String(request.walletAuthMethodId)) return {
+				kind: "refused",
+				reason: "an upgraded custody envelope must name the authenticated auth method"
+			};
+			const submittedRevision = Number(submitted.envelopeRevision);
+			const lookup = await assembly.passkeyCustodyEnvelopes.lookupEnvelope({
+				walletId: request.walletId,
+				factor: envelopeFactorRef(submitted),
+				envelopeId: submitted.envelopeId
+			});
+			if (lookup.kind === "missing") return { kind: "not_found" };
+			if (lookup.kind !== "active") return {
+				kind: "refused",
+				reason: `the custody envelope is ${lookup.kind}`
+			};
+			const stored = lookup.envelope;
+			if (stored.ownership.kind === "method_bound") return String(stored.ownership.walletAuthMethodId) === String(request.walletAuthMethodId) ? { kind: "already_owned" } : {
+				kind: "refused",
+				reason: "the custody envelope is owned by a different auth method"
+			};
+			if (Number(stored.envelopeRevision) !== submittedRevision - 1) return {
+				kind: "conflict",
+				reason: "the custody envelope moved before the upgrade could be stored"
+			};
+			const rewrapped = await assembly.passkeyCustodyEnvelopes.rewrapEnvelope(submitted, {
+				envelopeId: stored.envelopeId,
+				envelopeRevision: Number(stored.envelopeRevision),
+				ownership: stored.ownership
+			});
+			switch (rewrapped.kind) {
+				case "stored": return {
+					kind: "upgraded",
+					envelopeRevision: rewrapped.envelopeRevision
+				};
+				case "not_found": return { kind: "not_found" };
+				case "ownership_conflict": return {
+					kind: "refused",
+					reason: rewrapped.reason
+				};
+				case "terminal_lifecycle": return {
+					kind: "refused",
+					reason: "the custody envelope is revoked"
+				};
+				case "revision_conflict":
+				case "version_mismatch": return {
+					kind: "conflict",
+					reason: "the custody envelope moved before the upgrade could be stored"
+				};
+			}
+		},
+		retrieveEnvelope: async (request) => {
+			const challengeId = String(request.challengeId || "").trim();
+			const expectedOrigin = String(request.expectedOrigin || "").trim();
+			if (!challengeId || !expectedOrigin) return {
+				status: 400,
+				body: {
+					ok: false,
+					code: "challenge_required",
+					message: "custody retrieval needs a server-issued challenge and an origin"
+				}
+			};
+			const challenge = await assembly.webAuthnStore.consumeLoginChallenge(challengeId);
+			if (!challenge) return {
+				status: 401,
+				body: {
+					ok: false,
+					code: "challenge_unknown",
+					message: "the challenge is unknown, expired, or already used"
+				}
+			};
+			const projections = await assembly.passkeyCustodyEnvelopes.listWalletCredentialActivity(request.locator.walletId);
+			const requestedFactor = request.locator.factor;
+			const matchingProjections = projections.filter((entry) => {
+				const factor = entry.index.factor;
+				return factor.kind === "passkey" && requestedFactor.kind === "passkey" && String(factor.rpId) === String(requestedFactor.rpId) && String(factor.credentialIdB64u) === String(requestedFactor.credentialIdB64u);
+			});
+			const projection = matchingProjections.find((entry) => entry.index.lifecycle.state === "active") ?? matchingProjections[0];
+			if (!projection || projection.index.factor.kind !== "passkey") return {
+				status: 404,
+				body: {
+					ok: false,
+					code: "envelope_missing",
+					message: "no custody envelope for this wallet and credential"
+				}
+			};
+			const locator = {
+				walletId: request.locator.walletId,
+				envelopeId: projection.index.envelopeId,
+				factor: {
+					kind: "passkey",
+					rpId: projection.index.factor.rpId,
+					credentialIdB64u: projection.index.factor.credentialIdB64u
+				}
+			};
+			const response = await handlePasskeyCustodyEnvelopeRetrieval({
+				request: {
+					locator,
+					rpId: challenge.rpId,
+					userId: challenge.userId,
+					expectedChallenge: challenge.challengeB64u,
+					expectedOrigin,
+					webauthnAuthentication: request.webauthnAuthentication
+				},
+				envelopeStore: assembly.passkeyCustodyEnvelopes,
+				authenticatorStore,
+				logger: assembly.logger
+			});
+			if (response.status === 200 && request.locator.factor.kind === "passkey") await assembly.passkeyCustodyEnvelopes.recordWalletCredentialUse({
+				walletId: request.locator.walletId,
+				envelopeId: locator.envelopeId,
+				usedAtMs: (assembly.nowMs ?? Date.now)()
+			}).catch(() => void 0);
+			return response;
+		},
+		prepareRecovery: prepareRecoveryForRoute.bind(void 0, assembly),
+		verifyGoogleRecovery: googleRecovery ? googleRecovery.verifyGoogle.bind(googleRecovery) : unavailableWalletRecoveryGoogleVerify,
+		verifyRecoveryEmailOtp: googleRecovery ? googleRecovery.verifyOtp.bind(googleRecovery) : unavailableWalletRecoveryEmailOtpVerify,
+		releaseRecoveryEmailOtpFactor: googleRecovery ? googleRecovery.releaseFactor.bind(googleRecovery) : unavailableWalletRecoveryEmailOtpRelease,
+		readPreparedEd25519RecoveryAdmission: readPreparedEd25519RecoveryAdmission.bind(void 0, assembly),
+		finalizeRecovery: finalizeRecoveryForRoute.bind(void 0, assembly),
+		finalizeGoogleEmailOtpRecovery: finalizeGoogleEmailOtpRecoveryForRoute.bind(void 0, assembly),
+		acknowledgeRecoveryBackup: async (request) => {
+			const stored = await assembly.walletCustodyCommits.readRecoveryEnvelopeSet(requireWalletId(request.walletId));
+			if (!stored) return { kind: "no_recovery_set" };
+			const issuedAtMs = Number(stored.record.issuedAtMs);
+			await assembly.walletCustodyCommits.writeBackupAcknowledgement(buildWalletRecoveryBackupAcknowledgementV1({
+				walletId: request.walletId,
+				issuedAtMs,
+				acknowledgedAtMs: (assembly.nowMs ?? Date.now)()
+			}));
+			return {
+				kind: "acknowledged",
+				issuedAtMs
+			};
+		},
+		readRecoveryStatus: async (request) => {
+			const stored = await assembly.walletCustodyCommits.readRecoveryEnvelopeSet(requireWalletId(request.walletId));
+			if (!stored) return { kind: "no_recovery_set" };
+			const acknowledgement = await assembly.walletCustodyCommits.readBackupAcknowledgement(requireWalletId(request.walletId));
+			const issuedAtMs = Number(stored.record.issuedAtMs);
+			return {
+				kind: "status",
+				activeCodeCount: stored.record.manifestKekWraps.filter((wrap) => wrap.lifecycle.state === "active").length,
+				totalCodeCount: stored.record.manifestKekWraps.length,
+				issuedAtMs,
+				storeVersion: stored.storeVersion,
+				backupOutstanding: walletRecoveryBackupIsOutstanding({
+					setIssuedAtMs: issuedAtMs,
+					acknowledgement
+				})
+			};
+		},
+		rotateRecoveryCodes: (request) => rotateWalletRecoveryCodesV1({
+			store: assembly.walletCustodyCommits,
+			walletId: requireWalletId(request.walletId),
+			replacement: request.replacement,
+			recoveryCodeLocators: request.recoveryCodeLocators,
+			expectedStoreVersion: request.expectedStoreVersion,
+			nowMs: (assembly.nowMs ?? Date.now)()
+		}),
+		readRecoverySet: async (request) => {
+			const stored = await assembly.walletCustodyCommits.readRecoveryEnvelopeSet(requireWalletId(request.walletId));
+			return stored ? {
+				kind: "ready",
+				record: stored.record,
+				storeVersion: stored.storeVersion
+			} : { kind: "no_recovery_set" };
+		}
+	};
+}
+async function readPreparedEd25519RecoveryAdmission(assembly, request) {
+	const challenge = await assembly.webAuthnStore.readRecoveryRegistrationChallenge(request.challengeId, request.nowMs);
+	if (challenge) {
+		if (!(await assembly.walletCustodyCommits.readRecoveryEnvelopeSet(challenge.walletId))?.record.manifestKekWraps.some((wrap) => wrap.lifecycle.state === "reserved" && wrap.lifecycle.reservationId === challenge.reservationId && wrap.lifecycle.reservationExpiresAtMs > request.nowMs)) return null;
+		const manifest = await resolveWalletRecoveryKeyManifestV1({
+			registry: assembly.walletStore,
+			walletId: challenge.walletId
+		});
+		return {
+			kind: "prepared_ed25519_recovery_admission_v1",
+			walletId: challenge.walletId,
+			reservationId: challenge.reservationId,
+			entries: manifest.entries.filter((entry) => entry.kind === "near_ed25519")
+		};
+	}
+	const recoveryOperationId = parseWalletRecoveryOperationId(request.challengeId);
+	if (!recoveryOperationId.ok || !assembly.googleRecovery) return null;
+	const storedAttempt = await assembly.googleRecovery.readAttempt(recoveryOperationId.value);
+	if (storedAttempt.kind !== "present") return null;
+	const attempt = storedAttempt.value;
+	if (attempt.state !== "otp_verified" || attempt.orgId !== assembly.orgId || attempt.recoveryOperationId !== recoveryOperationId.value || attempt.expiresAtMs <= request.nowMs) return null;
+	if (!(await assembly.walletCustodyCommits.readRecoveryEnvelopeSet(attempt.walletId))?.record.manifestKekWraps.some((wrap) => wrap.lifecycle.state === "reserved" && wrap.lifecycle.reservationId === attempt.reservationId && wrap.lifecycle.reservationExpiresAtMs > request.nowMs)) return null;
+	const manifest = await resolveWalletRecoveryKeyManifestV1({
+		registry: assembly.walletStore,
+		walletId: attempt.walletId
+	});
+	return {
+		kind: "prepared_ed25519_recovery_admission_v1",
+		walletId: attempt.walletId,
+		reservationId: attempt.reservationId,
+		entries: manifest.entries.filter((entry) => entry.kind === "near_ed25519")
+	};
+}
+async function prepareRecoveryForRoute(assembly, request) {
+	const origin = request.origin.trim();
+	if (!origin) return {
+		kind: "refused",
+		reason: "that recovery code cannot be used"
+	};
+	let passkeyRpId = null;
+	if (request.target.kind === "passkey") {
+		const parsedRpId = parseWebAuthnRpId(request.target.rpId);
+		if (!parsedRpId.ok || !isOriginWithinRpId(origin, parsedRpId.value)) return {
+			kind: "refused",
+			reason: "that recovery code cannot be used"
+		};
+		passkeyRpId = parsedRpId.value;
+	}
+	let locator;
+	try {
+		locator = await deriveRecoveryCodeLocatorV1FromBytes(request.recoveryCodeBytes);
+	} catch {
+		return {
+			kind: "refused",
+			reason: "that recovery code cannot be used"
+		};
+	}
+	const located = await assembly.walletCustodyCommits.readRecoveryCodeLocator(locator);
+	if (!located) return {
+		kind: "refused",
+		reason: "that recovery code cannot be used"
+	};
+	const walletId = located.walletId;
+	const methods = await assembly.walletCustodyCommits.listWalletAuthMethods(walletId);
+	const envelopes = await assembly.passkeyCustodyEnvelopes.listWalletEnvelopes(walletId);
+	const authorities = await readWalletRecoveryAuthoritySelections({
+		walletId,
+		methods,
+		walletAuthorityStore: assembly.walletAuthorityStore
+	});
+	const continuityAnchor = selectWalletRecoveryContinuityAnchor({
+		walletId,
+		targetFamily: walletRecoveryTargetFamily(request.target),
+		methods,
+		envelopes,
+		authorities
+	});
+	if (!continuityAnchor) return {
+		kind: "refused",
+		reason: "that recovery code cannot be used"
+	};
+	const targetIdentity = allocateRecoveryTargetIdentity();
+	if (!targetIdentity) return {
+		kind: "registration_unavailable",
+		reason: "wallet recovery target identity allocation failed"
+	};
+	const prepared = await prepareWalletRecoveryWithCodeV1({
+		store: assembly.walletCustodyCommits,
+		walletId,
+		expectedRecoveryKeyId: located.recoveryKeyId,
+		recoveryCodeBytes: request.recoveryCodeBytes,
+		reservationId: request.reservationId,
+		nowMs: (assembly.nowMs ?? Date.now)(),
+		reservationTtlMs: RECOVERY_RESERVATION_TTL_MS
+	});
+	if (prepared.kind !== "prepared") return prepared;
+	try {
+		const manifest = await resolveWalletRecoveryKeyManifestV1({
+			registry: assembly.walletStore,
+			walletId
+		});
+		const continuityAnchorRecord = buildWebAuthnRecoveryContinuityAnchorRecord(continuityAnchor);
+		const keyManifest = projectWalletRecoveryPreparationKeyManifestV1(manifest, await buildEcdsaPossessionChallenges({
+			manifest,
+			walletId,
+			reservationId: request.reservationId,
+			replacementId: String(targetIdentity.recoveryOperationId),
+			sourceAuthorityDigestB64u: walletRecoveryAuthorityDigest(continuityAnchor.authority),
+			challengeB64u: String(targetIdentity.recoveryOperationId),
+			expiresAtMs: prepared.reservationExpiresAtMs
+		}));
+		if (request.target.kind === "google_email_otp") {
+			if (!assembly.googleRecovery) return {
+				kind: "registration_unavailable",
+				reason: "Google Email OTP recovery is not configured"
+			};
+			if ((await assembly.googleRecovery.persistPrepared({ attempt: buildPreparedWalletRecoveryGoogleEmailOtpAttempt({
+				walletId,
+				orgId: assembly.orgId,
+				reservationId: request.reservationId,
+				recoveryOperationId: targetIdentity.recoveryOperationId,
+				targetDeviceId: targetIdentity.targetDeviceId,
+				targetAuthorityId: targetIdentity.targetAuthorityId,
+				targetWalletAuthMethodId: targetIdentity.targetWalletAuthMethodId,
+				continuityAnchor: continuityAnchorRecord,
+				recoverySetVersion: prepared.storeVersion,
+				createdAtMs: nowMsForAssembly(assembly),
+				expiresAtMs: prepared.reservationExpiresAtMs
+			}) })).kind === "conflict") return { kind: "conflict" };
+			return {
+				...prepared,
+				target: request.target,
+				recoveryOperationId: targetIdentity.recoveryOperationId,
+				targetDeviceId: targetIdentity.targetDeviceId,
+				targetAuthorityId: targetIdentity.targetAuthorityId,
+				targetWalletAuthMethodId: targetIdentity.targetWalletAuthMethodId,
+				keyManifest
+			};
+		}
+		if (!passkeyRpId) return {
+			kind: "registration_unavailable",
+			reason: "Passkey recovery rpId is unavailable"
+		};
+		const registration = await createWalletRecoveryRegistrationOptions({
+			webAuthnStore: assembly.webAuthnStore,
+			walletId,
+			reservationId: request.reservationId,
+			recoveryOperationId: targetIdentity.recoveryOperationId,
+			targetDeviceId: targetIdentity.targetDeviceId,
+			targetAuthorityId: targetIdentity.targetAuthorityId,
+			targetWalletAuthMethodId: targetIdentity.targetWalletAuthMethodId,
+			origin,
+			rpId: passkeyRpId,
+			continuityAnchor,
+			expiresAtMs: prepared.reservationExpiresAtMs,
+			nowMs: nowMsForAssembly(assembly)
+		});
+		if (registration.kind !== "ready") return {
+			kind: "registration_unavailable",
+			reason: registration.reason
+		};
+		const possessionChallenges = await buildEcdsaPossessionChallenges({
+			manifest,
+			walletId,
+			reservationId: request.reservationId,
+			replacementId: registration.options.replacementId,
+			sourceAuthorityDigestB64u: walletRecoveryAuthorityDigest(continuityAnchor.authority),
+			challengeB64u: registration.options.challengeB64u,
+			expiresAtMs: prepared.reservationExpiresAtMs
+		});
+		return {
+			...prepared,
+			target: request.target,
+			recoveryOperationId: targetIdentity.recoveryOperationId,
+			targetDeviceId: targetIdentity.targetDeviceId,
+			targetAuthorityId: targetIdentity.targetAuthorityId,
+			targetWalletAuthMethodId: targetIdentity.targetWalletAuthMethodId,
+			keyManifest: projectWalletRecoveryPreparationKeyManifestV1(manifest, possessionChallenges),
+			registration: registration.options
+		};
+	} catch (error) {
+		return {
+			kind: "manifest_unavailable",
+			reason: error instanceof Error ? error.message : "wallet recovery key manifest is unavailable"
+		};
+	}
+}
+async function createWalletRecoveryRegistrationOptions(input) {
+	const challengeId = secureRandomBase64Url(16, "wallet recovery registration challenge id");
+	const challengeB64u = secureRandomBase64Url(32, "wallet recovery registration challenge");
+	const replacementId = `wallet-recovery-replacement:${secureRandomBase64Url(18, "wallet recovery replacement id")}`;
+	const record = {
+		version: "webauthn_recovery_registration_challenge_v2",
+		challengeId,
+		walletId: input.walletId,
+		reservationId: input.reservationId,
+		recoveryOperationId: input.recoveryOperationId,
+		targetDeviceId: input.targetDeviceId,
+		targetAuthorityId: input.targetAuthorityId,
+		targetWalletAuthMethodId: input.targetWalletAuthMethodId,
+		origin: input.origin,
+		rpId: input.rpId,
+		replacementId,
+		challengeB64u,
+		continuityAnchor: buildWebAuthnRecoveryContinuityAnchorRecord(input.continuityAnchor),
+		createdAtMs: input.nowMs,
+		expiresAtMs: input.expiresAtMs
+	};
+	await input.webAuthnStore.writeChallenge({
+		challengeId,
+		challengeKind: "recovery_registration",
+		record,
+		createdAtMs: input.nowMs,
+		expiresAtMs: input.expiresAtMs
+	});
+	return {
+		kind: "ready",
+		options: {
+			kind: "webauthn_recovery_registration_v1",
+			challengeId,
+			challengeB64u,
+			replacementId,
+			walletAuthMethodId: input.targetWalletAuthMethodId,
+			rpId: input.rpId,
+			user: {
+				idB64u: base64UrlEncode(new TextEncoder().encode(String(input.walletId))),
+				name: String(input.walletId),
+				displayName: String(input.walletId)
+			},
+			pubKeyCredParams: [{
+				type: "public-key",
+				alg: -7
+			}, {
+				type: "public-key",
+				alg: -257
+			}],
+			authenticatorSelection: {
+				residentKey: "required",
+				userVerification: "preferred"
+			},
+			timeoutMs: 6e4,
+			attestation: "none",
+			extensions: { prf: { eval: {
+				firstB64u: base64UrlEncode(PASSKEY_PRF_FIRST_SALT_V1),
+				secondB64u: base64UrlEncode(PASSKEY_PRF_SECOND_SALT_V1)
+			} } },
+			excludeCredentials: []
+		}
+	};
+}
+async function finalizeRecoveryForRoute(assembly, request) {
+	if (request.kind === "replay") {
+		const replay = await resolveCommittedRecoveryReplayV1({
+			envelopeStore: assembly.passkeyCustodyEnvelopes,
+			walletCustodyCommits: assembly.walletCustodyCommits,
+			walletAuthorityStore: assembly.walletAuthorityStore,
+			webAuthnStore: assembly.webAuthnStore,
+			walletId: request.walletId,
+			reservationId: request.reservationId,
+			recoveryOperationId: request.recoveryOperationId,
+			targetDeviceId: request.targetDeviceId,
+			targetAuthorityId: request.targetAuthorityId,
+			targetWalletAuthMethodId: request.targetWalletAuthMethodId,
+			replacementId: request.replacementId,
+			replacementEnvelope: request.replacementEnvelope
+		});
+		if (replay.kind === "rejected") return {
+			kind: "registration_rejected",
+			reason: replay.reason
+		};
+		if (replay.kind !== "promoted") return replay;
+		return await readPasskeyCommittedRecoveryProjection({
+			assembly,
+			walletId: request.walletId,
+			recoveryOperationId: request.recoveryOperationId,
+			targetDeviceId: request.targetDeviceId,
+			targetAuthorityId: request.targetAuthorityId,
+			targetWalletAuthMethodId: request.targetWalletAuthMethodId,
+			replacementEnvelope: request.replacementEnvelope,
+			credential: replay.credential,
+			storeVersion: replay.storeVersion
+		});
+	}
+	const result = await finalizeRecoveredWalletCredentialV1({
+		envelopeStore: assembly.passkeyCustodyEnvelopes,
+		walletCustodyCommits: assembly.walletCustodyCommits,
+		walletAuthorityStore: assembly.walletAuthorityStore,
+		walletId: request.walletId,
+		reservationId: request.reservationId,
+		recoveryOperationId: request.recoveryOperationId,
+		targetDeviceId: request.targetDeviceId,
+		targetAuthorityId: request.targetAuthorityId,
+		targetWalletAuthMethodId: request.targetWalletAuthMethodId,
+		challengeId: request.challengeId,
+		replacementId: request.replacementId,
+		webauthnRegistration: request.webauthnRegistration,
+		expectedOrigin: request.expectedOrigin,
+		webAuthnStore: assembly.webAuthnStore,
+		walletStore: assembly.walletStore,
+		replacementEnvelope: request.replacementEnvelope,
+		ecdsaMaterialPossessionProofs: request.ecdsaMaterialPossessionProofs,
+		nowMs: (assembly.nowMs ?? Date.now)()
+	});
+	if (result.kind !== "promoted") return result;
+	return await readPasskeyCommittedRecoveryProjection({
+		assembly,
+		walletId: request.walletId,
+		recoveryOperationId: request.recoveryOperationId,
+		targetDeviceId: request.targetDeviceId,
+		targetAuthorityId: request.targetAuthorityId,
+		targetWalletAuthMethodId: request.targetWalletAuthMethodId,
+		replacementEnvelope: request.replacementEnvelope,
+		credential: result.credential,
+		storeVersion: result.storeVersion
+	});
+}
+async function readPasskeyCommittedRecoveryProjection(input) {
+	const [authority, authMethod] = await Promise.all([input.assembly.walletAuthorityStore.readById(input.targetAuthorityId), input.assembly.walletCustodyCommits.readWalletAuthMethodById(input.targetWalletAuthMethodId)]);
+	if (!authority || authority.state !== "active" || !isActiveRecoveredWalletAuthorityV1(authority) || authority.walletId !== input.walletId || !authMethod || authMethod.kind !== "passkey" || authMethod.status !== "active" || input.replacementEnvelope.factor.kind !== "passkey" || authMethod.walletId !== input.walletId || authMethod.walletAuthorityId !== authority.authorityId || authMethod.walletAuthMethodId !== input.targetWalletAuthMethodId || authority.authorityId !== input.targetAuthorityId || authority.principal.deviceId !== input.targetDeviceId || authority.provenance.recoveryOperationId !== input.recoveryOperationId || authMethod.credentialIdB64u !== input.credential.credentialIdB64u || authMethod.credentialPublicKeyB64u !== input.credential.credentialPublicKeyB64u || authMethod.counter !== input.credential.counter || authMethod.rpId !== input.replacementEnvelope.factor.rpId || authMethod.credentialIdB64u !== input.replacementEnvelope.factor.credentialIdB64u) throw new Error("recovery promotion authority projection is unavailable");
+	return {
+		kind: "promoted",
+		projection: buildWalletRecoveryCommittedProjectionV1({
+			kind: "passkey",
+			storeVersion: input.storeVersion,
+			walletId: input.walletId,
+			recoveryOperationId: input.recoveryOperationId,
+			targetDeviceId: input.targetDeviceId,
+			targetAuthorityId: input.targetAuthorityId,
+			targetWalletAuthMethodId: input.targetWalletAuthMethodId,
+			authority,
+			authMethod
+		})
+	};
+}
+async function finalizeGoogleEmailOtpRecoveryForRoute(assembly, request) {
+	const googleRecovery = assembly.googleRecovery;
+	const enrollmentFinalizer = assembly.emailOtpRegistrationEnrollmentFinalizer;
+	if (!googleRecovery || !enrollmentFinalizer) return {
+		kind: "refused",
+		reason: "Google Email OTP recovery is not configured"
+	};
+	const stored = await googleRecovery.readAttempt(request.recoveryOperationId);
+	if (stored.kind !== "present" || stored.value.state !== "otp_verified" && stored.value.state !== "finalized") return {
+		kind: "refused",
+		reason: "the verified recovery operation is unavailable"
+	};
+	const attempt = stored.value;
+	if (String(attempt.reservationId) !== String(request.reservationId)) return {
+		kind: "refused",
+		reason: "the recovery reservation does not match the operation"
+	};
+	const recovery = walletRecoveryGoogleEmailOtpFinalizationInput(attempt);
+	const dependencies = {
+		envelopeStore: assembly.passkeyCustodyEnvelopes,
+		walletCustodyCommits: assembly.walletCustodyCommits,
+		walletAuthorityStore: assembly.walletAuthorityStore,
+		walletStore: assembly.walletStore,
+		enrollmentFinalizer
+	};
+	const result = request.kind === "replay" ? await googleRecovery.finalizeRecovery({
+		kind: "replay",
+		recovery,
+		replacementEnvelope: request.replacementEnvelope,
+		dependencies
+	}) : await finalizeGoogleEmailOtpRouteRequest({
+		googleRecovery,
+		recovery,
+		request,
+		dependencies
+	});
+	if (result.kind !== "promoted") return result;
+	if (result.authority.state !== "active" || !isActiveRecoveredWalletAuthorityV1(result.authority) || result.authority.walletId !== recovery.walletId || result.authority.authorityId !== recovery.targetAuthorityId || result.authority.principal.deviceId !== recovery.targetDeviceId || result.authority.provenance.recoveryOperationId !== recovery.recoveryOperationId || result.authMethod.walletId !== recovery.walletId || result.authMethod.walletAuthorityId !== recovery.targetAuthorityId || result.authMethod.walletAuthMethodId !== recovery.targetWalletAuthMethodId) throw new Error("recovery promotion authority projection is unavailable");
+	if (!await walletAuthorityDigestsMatchV1(result.authority)) throw new Error("recovery promotion authority digest is invalid");
+	const providerSubject = parseEmailOtpProviderUserId(recovery.providerSubject);
+	if (!providerSubject.ok) throw new Error("recovery provider subject projection is unavailable");
+	return {
+		kind: "promoted",
+		projection: buildWalletRecoveryCommittedProjectionV1({
+			kind: "google_email_otp",
+			storeVersion: result.storeVersion,
+			walletId: recovery.walletId,
+			recoveryOperationId: recovery.recoveryOperationId,
+			targetDeviceId: recovery.targetDeviceId,
+			targetAuthorityId: recovery.targetAuthorityId,
+			targetWalletAuthMethodId: recovery.targetWalletAuthMethodId,
+			authority: result.authority,
+			authMethod: result.authMethod,
+			providerSubject: providerSubject.value,
+			emailHashHex: result.authMethod.emailHashHex,
+			registrationAuthorityId: result.authMethod.registrationAuthorityId,
+			enrollment: {
+				kind: "email_otp_enrollment_reference_v1",
+				enrollmentId: result.enrollment.enrollmentId,
+				enrollmentSealKeyVersion: result.enrollment.enrollmentSealKeyVersion
+			}
+		})
+	};
+}
+async function finalizeGoogleEmailOtpRouteRequest(input) {
+	const emailOtpEnrollment = googleEmailOtpEnrollmentForRoute({
+		recovery: input.recovery,
+		emailOtpEnrollment: input.request.emailOtpEnrollment
+	});
+	if (emailOtpEnrollment.kind !== "ready") return emailOtpEnrollment;
+	return await input.googleRecovery.finalizeRecovery({
+		kind: "finalize",
+		recovery: input.recovery,
+		replacementEnvelope: input.request.replacementEnvelope,
+		emailOtpEnrollment: emailOtpEnrollment.enrollment,
+		ecdsaMaterialPossessionProofs: input.request.ecdsaMaterialPossessionProofs,
+		dependencies: input.dependencies
+	});
+}
+function googleEmailOtpEnrollmentForRoute(input) {
+	switch (input.recovery.targetEnrollment.kind) {
+		case "existing":
+			if (input.emailOtpEnrollment !== null) return {
+				kind: "enrollment_rejected",
+				reason: "existing recovery Email enrollment accepts no client material"
+			};
+			return {
+				kind: "ready",
+				enrollment: {
+					kind: "existing",
+					enrollmentId: input.recovery.targetEnrollment.enrollmentId,
+					enrollmentSealKeyVersion: input.recovery.targetEnrollment.enrollmentSealKeyVersion
+				}
+			};
+		case "create":
+			if (input.emailOtpEnrollment === null) return {
+				kind: "enrollment_rejected",
+				reason: "new recovery Email enrollment material is required"
+			};
+			return {
+				kind: "ready",
+				enrollment: {
+					kind: "create",
+					providerSubject: input.recovery.providerSubject,
+					verifiedEmail: input.recovery.verifiedEmail,
+					material: input.emailOtpEnrollment.material
+				}
+			};
+	}
+}
+async function buildEcdsaPossessionChallenges(input) {
+	return await buildWalletRecoveryEcdsaPossessionChallengesV1({
+		manifest: input.manifest,
+		walletId: input.walletId,
+		reservationId: input.reservationId,
+		replacementId: input.replacementId,
+		sourceAuthorityDigestB64u: input.sourceAuthorityDigestB64u,
+		challengeB64u: input.challengeB64u,
+		expiresAtMs: input.expiresAtMs
+	});
+}
+function requireWalletId(value) {
+	const parsed = parseWalletId(value);
+	if (!parsed.ok) throw new Error("wallet ID is invalid");
+	return parsed.value;
+}
+/**
+* The router's WebAuthn store, seen as the interface assertion verification
+* expects.
+*
+* The two shapes differ only in naming — both read and write the same
+* `WebAuthnAuthenticatorRecord` rows — so this adapts rather than duplicates.
+* Verifying against the router's own authenticators is the point: a separate
+* store would let a credential be active for registration and unknown to
+* custody, and the wallet would refuse a passkey the user just enrolled.
+*/
+function authenticatorStoreView(store) {
+	return {
+		get: async (userId, credentialIdB64u) => {
+			const record = await store.readAuthenticator({
+				userId,
+				credentialIdB64u
+			});
+			if (!record) return null;
+			return {
+				version: "webauthn_authenticator_v1",
+				credentialIdB64u: record.credentialIdB64u,
+				credentialPublicKeyB64u: record.credentialPublicKeyB64u,
+				counter: record.counter,
+				createdAtMs: record.createdAtMs,
+				updatedAtMs: record.updatedAtMs,
+				deviceInfo: record.deviceInfo
+			};
+		},
+		put: (userId, record) => store.updateAuthenticatorCounter({
+			userId,
+			credentialIdB64u: record.credentialIdB64u,
+			newCounter: record.counter,
+			updatedAtMs: record.updatedAtMs
+		}),
+		del: async () => {
+			throw new Error("the router WebAuthn store cannot delete authenticators; revoke the custody envelope instead");
+		}
+	};
+}
+//#endregion
+export { createD1PasskeyCustodyRouteService, createWalletRecoveryRegistrationOptions, selectWalletRecoveryContinuityAnchor };
+
+//# sourceMappingURL=d1PasskeyCustodyRouteService.js.map