@seams/wallet-server 0.5.0

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

@@ -0,0 +1,628 @@
+import { base64UrlDecode, base64UrlEncode } from "../../../../shared-ts/src/utils/base64.js";
+import { sha256Bytes } from "../../../../shared-ts/src/utils/digests.js";
+import { admitWalletCustodyEnvelopeOwnershipReplacementV1, buildRevokedEnvelopeLifecycle, parsePasskeyCustodyEnvelopeRecord, sameWalletCustodyEnvelopeOwnership } from "../../../../shared-ts/src/passkey-custody/custodyEnvelope.js";
+import { parseWalletCredentialActivityRecordV1 } from "../../../../shared-ts/src/passkey-custody/credentialActivity.js";
+import "../../../../shared-ts/src/passkey-custody/index.js";
+import { CloudflareD1VersionedJsonRecordStore } from "../versionedJson/d1VersionedJsonRecordStore.js";
+import { admitEnvelopeRevocation } from "../../../domains/passkeyCustody/envelopeRevocationAdmission.js";
+//#region src/router/cloudflare/d1/passkeyCustody/d1PasskeyCustodyEnvelopeStore.ts
+/**
+* Opaque custody storage for factor-sealed custody envelopes.
+*
+* The store validates credential, wallet, lifecycle, revision, and digest
+* facts, and it cannot open an envelope or report its plaintext as live: the
+* KEK only ever exists inside the browser's secure worker. Ciphertext lives
+* here because a browser with empty IndexedDB must be able to retrieve it after
+* an exact WebAuthn assertion — a browser-only record is never the cross-device
+* source of truth.
+*
+* Persistence rides on the shared versioned JSON record store, so CAS, batching,
+* and tenant scoping behave exactly as they do for every other Gateway D1
+* record. Two version identities are deliberately distinct:
+*
+* - the store's opaque `version` string is the transport CAS token;
+* - the domain `envelopeRevision` increments by exactly 1 per rewrap and is
+*   bound into the envelope's AAD, so an old ciphertext cannot be replayed into
+*   a newer revision.
+*
+* A lifecycle transition changes no ciphertext and therefore never bumps
+* `envelopeRevision`.
+*/
+const PASSKEY_ENVELOPE_KEY_PREFIX = "passkey-envelope";
+const PASSKEY_CREDENTIAL_ACTIVITY_KEY_PREFIX = "passkey-credential-activity";
+/** The factor address a stored envelope actually carries. */
+function envelopeFactorRef(envelope) {
+	switch (envelope.factor.kind) {
+		case "passkey": return {
+			kind: "passkey",
+			rpId: envelope.factor.rpId,
+			credentialIdB64u: envelope.factor.credentialIdB64u
+		};
+		case "email_otp": return {
+			kind: "email_otp",
+			enrollmentId: envelope.factor.enrollmentId,
+			enrollmentSealKeyVersion: envelope.factor.enrollmentSealKeyVersion
+		};
+	}
+}
+/**
+* The complete factor identity, not a shorthand: RP ID and seal-key version
+* participate in KEK and AAD identity, so a locator that omitted them could
+* resolve an envelope the caller's factor cannot actually open.
+*/
+function factorKeyPart(factor) {
+	switch (factor.kind) {
+		case "passkey": return [
+			"passkey",
+			String(factor.rpId),
+			String(factor.credentialIdB64u)
+		];
+		case "email_otp": return [
+			"email_otp",
+			factor.enrollmentId,
+			factor.enrollmentSealKeyVersion
+		];
+	}
+}
+function factorRefsMatch(left, right) {
+	if (left.kind !== right.kind) return false;
+	switch (left.kind) {
+		case "passkey":
+			if (right.kind !== "passkey") return false;
+			return left.rpId === right.rpId && left.credentialIdB64u === right.credentialIdB64u;
+		case "email_otp":
+			if (right.kind !== "email_otp") return false;
+			return left.enrollmentId === right.enrollmentId && left.enrollmentSealKeyVersion === right.enrollmentSealKeyVersion;
+	}
+	return false;
+}
+function isActivityMutationRecord(value) {
+	return !("ok" in value);
+}
+function encodeEnvelope(envelope) {
+	return envelope;
+}
+function parseEnvelopeOrNull(raw) {
+	try {
+		return parsePasskeyCustodyEnvelopeRecord(raw);
+	} catch {
+		return null;
+	}
+}
+function parseActivityRecordOrNull(raw) {
+	if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return null;
+	let prototype;
+	try {
+		prototype = Object.getPrototypeOf(raw);
+	} catch {
+		return null;
+	}
+	if (prototype !== Object.prototype && prototype !== null) return null;
+	const walletId = raw.walletId;
+	if (typeof walletId !== "string" || !walletId.trim()) return null;
+	const parsed = parseWalletCredentialActivityRecordV1(raw, { expectedWalletId: walletId });
+	return parsed.ok ? parsed.record : null;
+}
+async function ciphertextDigestB64u(sealedCustodySecretB64u) {
+	return base64UrlEncode(await sha256Bytes(base64UrlDecode(sealedCustodySecretB64u)));
+}
+function isD1ConstraintError(error) {
+	const message = error instanceof Error ? error.message : String(error || "");
+	return /constraint|unique|foreign key|not null/i.test(message);
+}
+/**
+* The record key for one envelope, exported so the registration commit path
+* addresses envelopes with this exact definition rather than a copy of it. A
+* second spelling of this key would write rows no lookup could ever find.
+*
+* Envelopes are addressed by wallet, factor, and envelope id together, so a
+* lookup can never return an envelope belonging to another factor even if the
+* envelope id were guessed. JSON-encoded so no delimiter inside an id can
+* splice one locator into another: enrollment ids are caller strings and
+* domain ids permit ':'. A joined string would let
+* {enrollment "e", envelope "x:y"} collide with {enrollment "e:x", envelope "y"}.
+*/
+function passkeyCustodyEnvelopeRecordKey(locator) {
+	return JSON.stringify([
+		String(locator.walletId),
+		...factorKeyPart(locator.factor),
+		String(locator.envelopeId)
+	]);
+}
+/** The factor address a stored envelope carries, for callers building locators. */
+function passkeyCustodyEnvelopeLocatorOf(envelope) {
+	return envelopeLocator(envelope);
+}
+var CloudflareD1PasskeyCustodyEnvelopeStore = class {
+	constructor(options) {
+		this.database = options.database;
+		this.scope = options.scope;
+		this.records = new CloudflareD1VersionedJsonRecordStore({
+			database: options.database,
+			scope: options.scope,
+			encode: encodeEnvelope,
+			parse: parseEnvelopeOrNull,
+			keyPrefix: PASSKEY_ENVELOPE_KEY_PREFIX
+		});
+		this.activityRecords = new CloudflareD1VersionedJsonRecordStore({
+			database: options.database,
+			scope: options.scope,
+			encode: (value) => value,
+			parse: parseActivityRecordOrNull,
+			keyPrefix: PASSKEY_CREDENTIAL_ACTIVITY_KEY_PREFIX
+		});
+	}
+	recordKey(locator) {
+		return passkeyCustodyEnvelopeRecordKey(locator);
+	}
+	/**
+	* Reads one envelope and classifies it. The caller must have already verified
+	* a WebAuthn assertion for this exact wallet, RP, credential, and challenge —
+	* this store authenticates nothing on its own.
+	*/
+	async lookupEnvelope(locator) {
+		const read = await this.records.read(this.recordKey(locator));
+		if (read.kind === "missing") return { kind: "missing" };
+		const envelope = read.value;
+		if (String(envelope.walletId) !== String(locator.walletId) || !factorRefsMatch(envelopeFactorRef(envelope), locator.factor) || String(envelope.envelopeId) !== String(locator.envelopeId)) return { kind: "missing" };
+		if (envelope.lifecycle.state === "retired") return {
+			kind: "retired",
+			envelopeId: envelope.envelopeId,
+			retiredAtMs: envelope.lifecycle.retiredAtMs
+		};
+		if (envelope.lifecycle.state === "revoked") return {
+			kind: "revoked",
+			envelopeId: envelope.envelopeId,
+			revokedAtMs: envelope.lifecycle.revokedAtMs
+		};
+		const actual = await ciphertextDigestB64u(envelope.sealedCustodySecretB64u);
+		if (actual !== String(envelope.ciphertextDigestB64u)) return {
+			kind: "digest_mismatch",
+			envelopeId: envelope.envelopeId,
+			storedCiphertextDigestB64u: String(envelope.ciphertextDigestB64u),
+			actualCiphertextDigestB64u: actual
+		};
+		return {
+			kind: "active",
+			envelope,
+			storeVersion: read.version
+		};
+	}
+	/**
+	* Confirms a browser cache entry against the active server envelope. A cache
+	* hit requires the exact revision and ciphertext digest, so a cache that
+	* drifted across a rewrap is refetched rather than opened.
+	*/
+	async validateCachedEnvelope(args) {
+		const lookup = await this.lookupEnvelope(args.locator);
+		if (lookup.kind !== "active") return {
+			kind: "cache_unusable",
+			lookup
+		};
+		const { envelope } = lookup;
+		const serverRevision = Number(envelope.envelopeRevision);
+		const serverDigest = String(envelope.ciphertextDigestB64u);
+		if (serverRevision !== args.cachedRevision || serverDigest !== args.cachedCiphertextDigestB64u) return {
+			kind: "cache_stale",
+			serverRevision,
+			serverCiphertextDigestB64u: serverDigest
+		};
+		return {
+			kind: "cache_valid",
+			envelope
+		};
+	}
+	/**
+	* Stores the first revision of a new envelope. Fails with `version_mismatch`
+	* if any envelope already exists at this locator.
+	*/
+	/**
+	* Every envelope stored for one wallet, in key order.
+	*
+	* Credential management needs this and cannot be written without it: whether
+	* removing a passkey is safe depends on whether *another* active envelope
+	* still protects the same custody seed, and that question is unanswerable
+	* from a single locator.
+	*
+	* The scan is bounded by the wallet's own key prefix, so it cannot reach
+	* another wallet's rows even if a caller passes a crafted id — the prefix is
+	* a JSON-encoded array whose first element is the wallet.
+	*/
+	async listWalletEnvelopes(walletId, options = {}) {
+		const prefix = `[${JSON.stringify(String(walletId))},`;
+		const entries = await this.records.listByKeyPrefix(prefix, options);
+		const envelopes = [];
+		for (const entry of entries) {
+			if (entry.result.kind !== "present") continue;
+			if (String(entry.result.value.walletId) !== String(walletId)) continue;
+			envelopes.push(entry.result.value);
+		}
+		return envelopes;
+	}
+	/**
+	* Revocation statements for every live envelope sealed under one factor,
+	* for a caller whose transaction is owned elsewhere.
+	*
+	* Auth-method revocation is that caller: the method, its sessions, and its
+	* sealed envelope have to become unusable together, and the authority store
+	* owns that batch. Returning statements rather than running them is what
+	* keeps this from becoming a second, non-atomic revocation path.
+	*
+	* The last-active-envelope guard rides along, so revoking the final factor
+	* that can open the wallet custody seed still aborts.
+	*/
+	async prepareMethodEnvelopeRevocationStatements(input) {
+		return await this.prepareEnvelopeRevocationStatements({
+			walletId: input.walletId,
+			revokedAtMs: input.revokedAtMs,
+			selects: (envelope) => envelope.ownership.kind === "method_bound" && String(envelope.ownership.walletAuthMethodId) === String(input.walletAuthMethodId)
+		});
+	}
+	async prepareEnvelopeRevocationStatements(input) {
+		const envelopes = await this.listWalletEnvelopes(input.walletId, { limit: 1e3 });
+		const revocable = envelopes.filter((envelope) => input.selects(envelope)).filter((envelope) => envelope.lifecycle.state === "active" || envelope.lifecycle.state === "retired");
+		if (revocable.length === 0) return {
+			kind: "prepared",
+			statements: []
+		};
+		const targetIds = new Set(revocable.map((envelope) => String(envelope.envelopeId)));
+		const activeTargets = revocable.filter((envelope) => envelope.lifecycle.state === "active");
+		for (const target of activeTargets) {
+			const admission = admitEnvelopeRevocation({
+				envelopes,
+				envelopeId: target.envelopeId
+			});
+			if (admission.kind === "refused") return admission;
+		}
+		if (activeTargets.length > 0 && !envelopes.some((envelope) => envelope.lifecycle.state === "active" && !targetIds.has(String(envelope.envelopeId)))) return {
+			kind: "refused",
+			reason: "revoking the last active envelope would leave the wallet custody seed with no factor that can open it"
+		};
+		const mutations = [];
+		for (const target of revocable) {
+			const current = await this.records.read(this.recordKey(envelopeLocator(target)));
+			if (current.kind === "missing") return { kind: "version_mismatch" };
+			if (String(current.value.walletId) !== String(input.walletId) || String(current.value.envelopeId) !== String(target.envelopeId) || !input.selects(current.value)) return { kind: "version_mismatch" };
+			mutations.push({
+				key: this.recordKey(envelopeLocator(target)),
+				expectedVersion: current.version,
+				value: {
+					...current.value,
+					lifecycle: buildRevokedEnvelopeLifecycle({
+						activatedAtMs: current.value.lifecycle.activatedAtMs,
+						revokedAtMs: input.revokedAtMs
+					}),
+					updatedAtMs: input.revokedAtMs
+				}
+			});
+		}
+		const statements = [...this.records.prepareMutationStatements(mutations)];
+		if (activeTargets.length > 0) statements.push(this.prepareRemainingActiveEnvelopeGuard(input.walletId));
+		return {
+			kind: "prepared",
+			statements
+		};
+	}
+	/** Returns the public credential-management view; activity never enters envelope AAD. */
+	async listWalletCredentialActivity(walletId) {
+		const envelopes = (await this.listWalletEnvelopes(walletId)).filter((envelope) => envelope.factor.kind === "passkey");
+		const projections = [];
+		for (const envelope of envelopes) {
+			const activity = await this.readActivity(walletId, envelope);
+			projections.push({
+				index: credentialEnvelopeIndex(envelope, activity),
+				activity
+			});
+		}
+		return projections;
+	}
+	async renameWalletCredential(input) {
+		const envelope = await this.findPasskeyEnvelope(input.walletId, input.envelopeId);
+		if (!envelope) return { kind: "missing" };
+		return await this.mutateActivity(envelope, (record) => {
+			const parsed = parseWalletCredentialActivityRecordV1({
+				...record,
+				...input.label === void 0 ? { label: void 0 } : { label: input.label },
+				updatedAtMs: input.nowMs
+			}, { expectedWalletId: String(input.walletId) });
+			return parsed.ok ? parsed.record : parsed;
+		});
+	}
+	/** Called only after a passkey assertion has successfully opened custody. */
+	async recordWalletCredentialUse(input) {
+		const envelope = await this.findPasskeyEnvelope(input.walletId, input.envelopeId);
+		if (!envelope) return { kind: "missing" };
+		for (let attempt = 0; attempt < 3; attempt += 1) {
+			const result = await this.mutateActivity(envelope, (record) => {
+				const lastUsedAtMs = Math.max(input.usedAtMs, record.lastUsedAtMs ?? 0);
+				return {
+					...record,
+					lastUsedAtMs,
+					useCount: record.useCount + 1,
+					updatedAtMs: Math.max(input.usedAtMs, record.updatedAtMs)
+				};
+			});
+			if (result.kind !== "conflict") return result;
+		}
+		return { kind: "conflict" };
+	}
+	async findPasskeyEnvelope(walletId, envelopeId) {
+		return (await this.listWalletEnvelopes(walletId)).find((envelope) => envelope.factor.kind === "passkey" && String(envelope.envelopeId) === String(envelopeId)) ?? null;
+	}
+	async readActivity(walletId, envelope) {
+		const read = await this.activityRecords.read(activityRecordKey(walletId, envelope.envelopeId));
+		if (read.kind === "present") return read.value;
+		return initialActivityRecord(walletId, envelope);
+	}
+	async mutateActivity(envelope, mutate) {
+		const walletId = envelope.walletId;
+		const key = activityRecordKey(walletId, envelope.envelopeId);
+		const current = await this.activityRecords.read(key);
+		const next = mutate(current.kind === "present" ? current.value : initialActivityRecord(walletId, envelope));
+		if ("ok" in next && next.ok === false) return {
+			kind: "invalid_label",
+			reason: next.reason
+		};
+		if (!isActivityMutationRecord(next)) return {
+			kind: "invalid_label",
+			reason: "Invalid credential activity record"
+		};
+		if ((await this.activityRecords.put(key, next, current.kind === "present" ? current.version : null)).kind === "version_mismatch") return { kind: "conflict" };
+		return {
+			kind: "updated",
+			projection: {
+				index: credentialEnvelopeIndex(envelope, next),
+				activity: next
+			}
+		};
+	}
+	prepareRemainingActiveEnvelopeGuard(walletId) {
+		return this.database.prepare(`
+        INSERT INTO router_ab_yao_versioned_json_cas_guard (guard_id)
+        SELECT 1
+         WHERE NOT EXISTS (
+           SELECT 1
+             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 LIKE ?5
+              AND json_extract(record_json, '$.walletId') = ?6
+              AND json_extract(record_json, '$.lifecycle.state') = 'active'
+         )
+      `).bind(this.scope.namespace, this.scope.orgId, this.scope.projectId, this.scope.envId, `${PASSKEY_ENVELOPE_KEY_PREFIX}:%`, String(walletId));
+	}
+	async lookupEnvelopeForFactor(input) {
+		const matching = (await this.listWalletEnvelopes(input.walletId)).filter((envelope) => factorRefsMatch(envelopeFactorRef(envelope), input.factor));
+		const active = matching.filter((envelope) => envelope.lifecycle.state === "active");
+		if (active.length > 1) return { kind: "conflict" };
+		const selected = active[0];
+		if (selected) return await this.lookupEnvelope(envelopeLocator(selected));
+		const terminal = matching[0];
+		if (!terminal) return { kind: "missing" };
+		return await this.lookupEnvelope(envelopeLocator(terminal));
+	}
+	async lookupEnvelopeForWalletAuthMethod(input) {
+		const matching = (await this.listWalletEnvelopes(input.walletId)).filter((envelope) => factorRefsMatch(envelopeFactorRef(envelope), input.factor) && envelope.ownership.kind === "method_bound" && envelope.ownership.walletAuthMethodId === input.walletAuthMethodId);
+		const active = matching.filter((envelope) => envelope.lifecycle.state === "active");
+		if (active.length > 1) return { kind: "conflict" };
+		const selected = active[0];
+		if (selected) return await this.lookupEnvelope(envelopeLocator(selected));
+		const terminal = matching[0];
+		if (!terminal) return { kind: "missing" };
+		return await this.lookupEnvelope(envelopeLocator(terminal));
+	}
+	async createEnvelope(envelope) {
+		if (Number(envelope.envelopeRevision) !== 1) return {
+			kind: "revision_conflict",
+			expectedRevision: 1
+		};
+		const locator = envelopeLocator(envelope);
+		const stored = await this.records.put(this.recordKey(locator), envelope, null);
+		if (stored.kind === "version_mismatch") return { kind: "version_mismatch" };
+		return {
+			kind: "stored",
+			storeVersion: stored.version,
+			envelopeRevision: Number(envelope.envelopeRevision)
+		};
+	}
+	/**
+	* Inserts a new custody envelope together with caller-owned authenticator,
+	* credential-binding, and wallet-auth-method statements in one D1 batch.
+	* The envelope row is insert-only, so a repeated envelope identity or any
+	* conflicting credential aborts the complete transaction.
+	*
+	* The factor kind is the caller's to assert, not this store's. Refactor 109C
+	* enrols an Email OTP factor by exactly this route — a new envelope holding
+	* the same seed, committed with the auth-method insert — and each branch has
+	* already verified the factor it built the envelope for by the time it gets
+	* here. A kind check here would only re-state one branch's assumption and
+	* refuse the other.
+	*/
+	async linkWalletCustodyFactorAtomically(input) {
+		const envelope = input.envelope;
+		if (Number(envelope.envelopeRevision) !== 1 || envelope.lifecycle.state !== "active") return { kind: "conflict" };
+		if (input.additionalStatements.length === 0) throw new Error("Wallet custody linking requires credential and auth-method mutations");
+		const key = this.recordKey(envelopeLocator(envelope));
+		try {
+			const stored = await this.records.putManyWithAdditionalStatements([{
+				key,
+				value: envelope,
+				expectedVersion: null
+			}], input.additionalStatements);
+			if (stored.kind === "version_mismatch") return { kind: "version_mismatch" };
+			const version = stored.versions.find((entry) => entry.key === key)?.version;
+			if (!version) throw new Error("wallet custody link did not report envelope version");
+			return {
+				kind: "stored",
+				storeVersion: version
+			};
+		} catch (error) {
+			if (isD1ConstraintError(error)) return { kind: "conflict" };
+			throw error;
+		}
+	}
+	/**
+	* Commits a linked-device owner credential without inserting a generic
+	* wallet-custody envelope. The linked Device 2 root is a local export
+	* repository record and never belongs in this seed store.
+	*/
+	async commitPasskeyFactorWithoutCustodyAtomically(input) {
+		if (input.additionalStatements.length === 0) throw new Error("Passkey linking requires credential and auth-method mutations");
+		try {
+			const results = await this.database.batch(input.additionalStatements);
+			if (results.length !== input.additionalStatements.length || results.some((result) => !result.success)) throw new Error("linked passkey commit returned an incomplete D1 batch");
+			return { kind: "stored" };
+		} catch (error) {
+			if (isD1ConstraintError(error)) return { kind: "conflict" };
+			throw error;
+		}
+	}
+	/**
+	* Replaces an envelope's ciphertext at exactly the next revision.
+	*
+	* The read-then-CAS window is closed by the store version: a concurrent
+	* writer changes it, so the put fails rather than skipping a revision.
+	*
+	* `expected` is the caller's statement of which row it believes it is
+	* replacing — the exact envelope, the exact revision it was read at, and the
+	* exact method that owned it. The store refuses when any of the three has
+	* moved. Passing the replacement alone would let a caller that read a stale
+	* row overwrite whatever is there now as long as the arithmetic happened to
+	* line up, and for an envelope the arithmetic is not the identity.
+	*/
+	async rewrapEnvelope(envelope, expected) {
+		if (String(expected.envelopeId) !== String(envelope.envelopeId)) throw new Error("a custody envelope rewrap must name the envelope it replaces");
+		const locator = envelopeLocator(envelope);
+		const key = this.recordKey(locator);
+		const current = await this.records.read(key);
+		if (current.kind === "missing") return { kind: "not_found" };
+		if (current.value.lifecycle.state === "revoked") return {
+			kind: "terminal_lifecycle",
+			state: "revoked"
+		};
+		const nextRevision = Number(current.value.envelopeRevision) + 1;
+		if (Number(current.value.envelopeRevision) !== Number(expected.envelopeRevision) || Number(envelope.envelopeRevision) !== nextRevision) return {
+			kind: "revision_conflict",
+			expectedRevision: nextRevision
+		};
+		if (!sameWalletCustodyEnvelopeOwnership(current.value.ownership, expected.ownership)) return {
+			kind: "ownership_conflict",
+			reason: "the stored custody envelope is owned by a different auth method"
+		};
+		const admission = admitWalletCustodyEnvelopeOwnershipReplacementV1({
+			stored: current.value.ownership,
+			replacement: envelope.ownership
+		});
+		if (admission.kind === "refused") return {
+			kind: "ownership_conflict",
+			reason: admission.reason
+		};
+		const stored = await this.records.put(key, envelope, current.version);
+		if (stored.kind === "version_mismatch") return { kind: "version_mismatch" };
+		return {
+			kind: "stored",
+			storeVersion: stored.version,
+			envelopeRevision: nextRevision
+		};
+	}
+	/**
+	* Marks an active envelope superseded. Retired rows stay readable so a
+	* lookup can report `retired` explicitly instead of `missing`.
+	*/
+	async retireEnvelope(args) {
+		return await this.transitionLifecycle(args.locator, (envelope) => {
+			if (envelope.lifecycle.state !== "active") return null;
+			return {
+				...envelope,
+				lifecycle: {
+					state: "retired",
+					activatedAtMs: envelope.lifecycle.activatedAtMs,
+					retiredAtMs: args.retiredAtMs
+				},
+				updatedAtMs: args.retiredAtMs
+			};
+		});
+	}
+	/**
+	* Revokes an envelope terminally. The row is retained as a credential
+	* tombstone — credential replacement needs the prior credential's record —
+	* but it is excluded from every active retrieval.
+	*/
+	async revokeEnvelope(args) {
+		return await this.transitionLifecycle(args.locator, (envelope) => {
+			if (envelope.lifecycle.state === "revoked") return null;
+			return {
+				...envelope,
+				lifecycle: {
+					state: "revoked",
+					activatedAtMs: envelope.lifecycle.activatedAtMs,
+					revokedAtMs: args.revokedAtMs
+				},
+				updatedAtMs: args.revokedAtMs
+			};
+		});
+	}
+	/**
+	* Lifecycle transitions never touch ciphertext, so `envelopeRevision` is
+	* carried forward unchanged and the sealed AAD stays valid.
+	*/
+	async transitionLifecycle(locator, next) {
+		const key = this.recordKey(locator);
+		const current = await this.records.read(key);
+		if (current.kind === "missing") return { kind: "not_found" };
+		const updated = next(current.value);
+		if (updated === null) return current.value.lifecycle.state === "revoked" ? {
+			kind: "terminal_lifecycle",
+			state: "revoked"
+		} : { kind: "version_mismatch" };
+		const stored = await this.records.put(key, updated, current.version);
+		if (stored.kind === "version_mismatch") return { kind: "version_mismatch" };
+		return {
+			kind: "stored",
+			storeVersion: stored.version,
+			envelopeRevision: Number(updated.envelopeRevision)
+		};
+	}
+};
+function envelopeLocator(envelope) {
+	return {
+		walletId: envelope.walletId,
+		factor: envelopeFactorRef(envelope),
+		envelopeId: envelope.envelopeId
+	};
+}
+function activityRecordKey(walletId, envelopeId) {
+	return JSON.stringify([String(walletId), String(envelopeId)]);
+}
+function initialActivityRecord(walletId, envelope) {
+	const createdAtMs = Math.max(1, Number(envelope.createdAtMs));
+	const updatedAtMs = Math.max(createdAtMs, Number(envelope.updatedAtMs));
+	return {
+		kind: "wallet_credential_activity_v1",
+		walletId: String(walletId),
+		envelopeId: String(envelope.envelopeId),
+		createdAtMs,
+		updatedAtMs,
+		useCount: 0
+	};
+}
+function credentialEnvelopeIndex(envelope, activity) {
+	if (envelope.factor.kind !== "passkey") throw new Error("credential envelope index requires a passkey factor");
+	return {
+		kind: "wallet_custody_envelope_index_v2",
+		walletId: envelope.walletId,
+		custodySecretKind: envelope.binding.kind,
+		factor: envelope.factor,
+		envelopeId: envelope.envelopeId,
+		...activity.label === void 0 ? {} : { deviceLabel: activity.label },
+		lifecycle: envelope.lifecycle,
+		createdAtMs: envelope.createdAtMs,
+		updatedAtMs: Math.max(envelope.updatedAtMs, activity.updatedAtMs)
+	};
+}
+//#endregion
+export { CloudflareD1PasskeyCustodyEnvelopeStore, PASSKEY_ENVELOPE_KEY_PREFIX, envelopeFactorRef, passkeyCustodyEnvelopeLocatorOf, passkeyCustodyEnvelopeRecordKey };
+
+//# sourceMappingURL=d1PasskeyCustodyEnvelopeStore.js.map