@seams/wallet-server 0.7.3 → 0.9.0

package/dist/esm/router/domains/ecdsa/routerAbEcdsaStrictRegistration.js

@@ -1,4 +1,6 @@
 import { parseRouterAbEcdsaDerivationActivationRefreshCommitRequestV1, parseRouterAbEcdsaDerivationActivationRefreshResponseV1, parseRouterAbEcdsaDerivationExplicitExportRequestV1, parseRouterAbEcdsaExplicitExportProtocolForwardedResponseV1, parseRouterAbEcdsaRegistrationActivationReceiptV1, parseRouterAbEcdsaStrictForwardedRegistrationResponseV1, projectRouterAbEcdsaDerivationExplicitExportRequestToProtocolV1 } from "../../../shared-ts/src/utils/routerAbEcdsaDerivation.js";
+import { walletObjectIdentity, walletObjectIdentityHeaders } from "../../cloudflare/runtime/walletObjectAddresses.js";
+import { ROUTER_AB_INTERNAL_SERVICE_AUTH_HEADER_V1, normalizeRouterAbInternalServiceAuthSecret } from "../../../core/ThresholdService/routerAb/internalServiceHttp.js";
 import { ROUTER_AB_TRACE_ID_HEADER_V1 } from "../../../shared-ts/src/utils/routerAbTraceContext.js";
 //#region src/router/domains/ecdsa/routerAbEcdsaStrictRegistration.ts
 const STRICT_ECDSA_REGISTRATION_PATH = "/router-ab/ecdsa-derivation/register";
@@ -90,9 +92,17 @@ var StrictRegistrationForwarder = class {
 			message: "Strict ECDSA registration request policy is invalid",
 			retryable: false
 		};
+		const claims = ceremonyTokenClaimsForAuthority(input.authority, this.config.tokenScope, input.projectEnvironmentId, input.kind === "activation" ? pendingOwnershipGeneration(input.pendingActivation) : input.tenantRoot.ownershipGeneration);
+		const token = await this.config.tokenIssuer.issueRequest(claims, requestPolicy);
 		const headers = {
-			authorization: `Bearer ${await this.config.tokenIssuer.issueRequest(ceremonyTokenClaimsForAuthority(input.authority, this.config.tokenScope, input.projectEnvironmentId), requestPolicy)}`,
-			"content-type": JSON_CONTENT_TYPE
+			[ROUTER_AB_INTERNAL_SERVICE_AUTH_HEADER_V1]: normalizeRouterAbInternalServiceAuthSecret(this.config.internalServiceAuthSecret),
+			authorization: `Bearer ${token}`,
+			"content-type": JSON_CONTENT_TYPE,
+			...walletObjectIdentityHeaders(walletObjectIdentity(claims.accountId, claims.ownershipGeneration, {
+				orgId: claims.orgId,
+				projectId: claims.projectId,
+				envId: claims.projectEnvironmentId
+			}))
 		};
 		if (input.traceContext) headers[ROUTER_AB_TRACE_ID_HEADER_V1] = input.traceContext.value;
 		const response = await this.config.router.fetch(new Request(`https://router.router-ab.internal${input.path}`, {
@@ -186,7 +196,8 @@ var StrictPostRegistrationForwarder = class {
 	async forwardRaw(input) {
 		const authorityFailure = validatePostRegistrationAuthorityBinding(input);
 		if (authorityFailure) return authorityFailure;
-		const token = await this.config.tokenIssuer.issueRequest(ceremonyTokenClaimsForAuthority(input.authority, this.config.tokenScope, input.tenantRoot.projectEnvironmentId), postRegistrationRequestPolicy(input.kind === "explicit_export" ? {
+		const claims = ceremonyTokenClaimsForAuthority(input.authority, this.config.tokenScope, input.tenantRoot.projectEnvironmentId, input.tenantRoot.ownershipGeneration);
+		const token = await this.config.tokenIssuer.issueRequest(claims, postRegistrationRequestPolicy(input.kind === "explicit_export" ? {
 			workKind: "key_export",
 			requestDigestB64u: input.requestDigestB64u
 		} : {
@@ -196,8 +207,14 @@ var StrictPostRegistrationForwarder = class {
 		const response = await this.config.router.fetch(new Request(`https://router.router-ab.internal${input.path}`, {
 			method: "POST",
 			headers: {
+				[ROUTER_AB_INTERNAL_SERVICE_AUTH_HEADER_V1]: normalizeRouterAbInternalServiceAuthSecret(this.config.internalServiceAuthSecret),
 				authorization: `Bearer ${token}`,
-				"content-type": JSON_CONTENT_TYPE
+				"content-type": JSON_CONTENT_TYPE,
+				...walletObjectIdentityHeaders(walletObjectIdentity(claims.accountId, claims.ownershipGeneration, {
+					orgId: claims.orgId,
+					projectId: claims.projectId,
+					envId: claims.projectEnvironmentId
+				}))
 			},
 			body: strictPostRegistrationForwardBodyJson(input)
 		}));
@@ -297,6 +314,7 @@ function assertNeverStrictForwardBody(value) {
 function canonicalPendingActivationJson(value) {
 	if (!exactObject(value, [
 		"registration",
+		"ownership_generation",
 		"tenant_root_custody_binding_digest",
 		"wallet_scope",
 		"environment_key",
@@ -305,6 +323,11 @@ function canonicalPendingActivationJson(value) {
 	])) throw new Error("MPCRouter pending activation has an invalid envelope");
 	return canonicalJson(value);
 }
+function pendingOwnershipGeneration(pending) {
+	const generation = objectValue(JSON.parse(pending.canonicalPayloadJson))?.ownership_generation;
+	if (typeof generation !== "number" || !Number.isSafeInteger(generation) || generation < 1) throw new Error("Stored ECDSA pending activation has an invalid ownership generation");
+	return generation;
+}
 function pendingProjectEnvironmentId(pending) {
 	const projectEnvironmentId = nonEmptyString(objectValue(objectValue(JSON.parse(pending.canonicalPayloadJson))?.wallet_scope)?.project_environment_id);
 	if (!projectEnvironmentId) throw new Error("Stored ECDSA pending activation has no canonical project environment");
@@ -313,11 +336,12 @@ function pendingProjectEnvironmentId(pending) {
 function parseStoredRouterAbEcdsaPendingActivationV1(value) {
 	const record = exactObject(value, ["kind", "canonicalPayloadJson"]);
 	if (!record || record.kind !== "router_ab_ecdsa_pending_activation_v1" || typeof record.canonicalPayloadJson !== "string") throw new Error("Stored MPCRouter ECDSA pending activation is invalid");
-	const canonicalPayloadJson = canonicalPendingActivationJson(JSON.parse(record.canonicalPayloadJson));
-	if (canonicalPayloadJson !== record.canonicalPayloadJson) throw new Error("Stored MPCRouter ECDSA pending activation is not canonical");
+	const parsed = objectValue(JSON.parse(record.canonicalPayloadJson));
+	if (!parsed || canonicalJson(parsed) !== record.canonicalPayloadJson) throw new Error("Stored MPCRouter ECDSA pending activation is not canonical");
+	if (!Object.hasOwn(parsed, "ownership_generation")) parsed.ownership_generation = 1;
 	return {
 		kind: "router_ab_ecdsa_pending_activation_v1",
-		canonicalPayloadJson
+		canonicalPayloadJson: canonicalPendingActivationJson(parsed)
 	};
 }
 function canonicalJson(value) {
@@ -380,8 +404,9 @@ function parseStrictRegistrationForwardingResult(raw) {
 		};
 	}
 }
-function ceremonyTokenClaimsForAuthority(authority, scope, projectEnvironmentId) {
+function ceremonyTokenClaimsForAuthority(authority, scope, projectEnvironmentId, ownershipGeneration) {
 	return {
+		ownershipGeneration,
 		subjectId: authority.subjectId,
 		sessionId: authority.sessionId,
 		orgId: scope.orgId,
@@ -501,6 +526,7 @@ var Ed25519CeremonyTokenIssuer = class {
 			project_id: claims.projectId,
 			environment: claims.environment,
 			project_environment_id: claims.projectEnvironmentId,
+			ownership_generation: claims.ownershipGeneration,
 			account_id: claims.accountId,
 			...requestPolicy ? { routerAbRequestPolicy: requestPolicy } : {}
 		})}`;
@@ -659,7 +685,7 @@ function validateCeremonyTokenIssuerConfig(config) {
 	if (!nonEmptyString(config.issuer) || !nonEmptyString(config.audience) || !nonEmptyString(config.keyId) || config.privateJwk.kty !== "OKP" || config.privateJwk.crv !== "Ed25519" || !base64UrlString(config.privateJwk.x, 32) || !base64UrlString(config.privateJwk.d, 32)) throw new Error("Router A/B ECDSA ceremony token issuer requires an Ed25519 private JWK");
 }
 function validateCeremonyTokenClaims(claims) {
-	if (!nonEmptyString(claims.subjectId) || !nonEmptyString(claims.sessionId) || !nonEmptyString(claims.orgId) || !nonEmptyString(claims.projectId) || !nonEmptyString(claims.environment) || !nonEmptyString(claims.projectEnvironmentId) || !nonEmptyString(claims.accountId) || !Number.isSafeInteger(claims.expiresAtMs) || claims.expiresAtMs <= Date.now()) throw new Error("Router A/B ECDSA ceremony token claims are invalid");
+	if (!Number.isSafeInteger(claims.ownershipGeneration) || claims.ownershipGeneration < 1 || !nonEmptyString(claims.subjectId) || !nonEmptyString(claims.sessionId) || !nonEmptyString(claims.orgId) || !nonEmptyString(claims.projectId) || !nonEmptyString(claims.environment) || !nonEmptyString(claims.projectEnvironmentId) || !nonEmptyString(claims.accountId) || !Number.isSafeInteger(claims.expiresAtMs) || claims.expiresAtMs <= Date.now()) throw new Error("Router A/B ECDSA ceremony token claims are invalid");
 }
 function exactObject(raw, keys) {
 	const record = objectValue(raw);

package/dist/esm/router/domains/ed25519Yao/capabilityLifecycle/routerAbEd25519YaoCapabilityCommit.js

@@ -0,0 +1,42 @@
+import { InMemoryRouterAbEd25519YaoRecoveryService, InMemoryRouterAbEd25519YaoRecoveryStateV1 } from "../recovery/routerAbEd25519YaoRecovery.js";
+//#region src/router/domains/ed25519Yao/capabilityLifecycle/routerAbEd25519YaoCapabilityCommit.ts
+/** The wallet and its initial capability become visible in the same transaction. */
+function commitRouterAbEd25519YaoRegistrationCapability(store, installation, walletWrite) {
+	return commitCapability(store, installRegistration.bind(void 0, installation), walletWrite);
+}
+function rehydrateRouterAbEd25519YaoCapability(store, capability) {
+	return commitCapability(store, installPersisted.bind(void 0, capability), Promise.resolve(null));
+}
+async function commitCapability(store, install, preparedWrite) {
+	for (let attempt = 0; attempt < 2; attempt += 1) {
+		const [snapshot, companionWrite] = await Promise.all([store.loadCapabilities(), preparedWrite]);
+		const state = new InMemoryRouterAbEd25519YaoRecoveryStateV1();
+		for (const [key, capability] of snapshot.value.recoveryCapabilities) state.capabilities.set(key, capability);
+		for (const [key, capabilityKey] of snapshot.value.recoveryIdentityCapabilities) state.identityCapabilities.set(key, capabilityKey);
+		const result = install(new InMemoryRouterAbEd25519YaoRecoveryService({
+			admitRecovery: rejectProtocolExecution,
+			resolveRecoveryDispatchRoot: rejectProtocolExecution,
+			executeRecovery: rejectProtocolExecution,
+			activateRecovery: rejectProtocolExecution
+		}, state));
+		if (!result.ok) return result;
+		if ((await store.commitCapabilities(snapshot, {
+			capabilities: state.capabilities,
+			identityCapabilities: state.identityCapabilities
+		}, companionWrite)).kind === "stored") return result;
+	}
+	throw new Error("Capability state remained contended after one reconciliation");
+}
+function installRegistration(input, service) {
+	return service.installRegistrationFinalizeCapability(input);
+}
+function installPersisted(input, service) {
+	return service.installPersistedActiveCapability(input);
+}
+function rejectProtocolExecution() {
+	throw new Error("A capability commit cannot execute a protocol");
+}
+//#endregion
+export { commitRouterAbEd25519YaoRegistrationCapability, rehydrateRouterAbEd25519YaoCapability };
+
+//# sourceMappingURL=routerAbEd25519YaoCapabilityCommit.js.map

package/dist/esm/router/domains/ed25519Yao/capabilityLifecycle/routerAbEd25519YaoProductRegistration.js

@@ -1,13 +1,14 @@
+import { parseWalletId } from "../../../../shared-ts/src/utils/domainIds.js";
 import { isPlainObject } from "../../../../shared-ts/src/utils/validation.js";
 import { routerAbMpcMaterialActivationRefToWire } from "../../../../shared-ts/src/utils/routerAbNormalSigningIdentity.js";
 import { parseRouterAbEd25519YaoRegistrationAdmissionRequestV1 } from "../../../../shared-ts/src/utils/routerAbEd25519Yao.js";
 import { deriveSigningRootId } from "../../../../shared-ts/src/threshold/signingRootScope.js";
 import { secureRandomBase64Url } from "../../../../shared-ts/src/utils/secureRandomId.js";
 import { ROUTER_AB_ED25519_NORMAL_SIGNING_STATE_KIND } from "../../../../shared-ts/src/utils/signingSessionSeal.js";
-import { thresholdEd25519AuthorityScopeFromWalletAuthAuthority } from "../../../../core/ThresholdService/validation.js";
 import { computeAddSignerNearEd25519SigningKeyId, computeRegistrationNearEd25519SigningKeyId } from "../../../../shared-ts/src/utils/registrationIds.js";
 import { registrationNearEd25519BranchKey } from "../../../../shared-ts/src/utils/registrationSignerPlan.js";
 import "../../../../shared-ts/src/threshold/sessionPolicy.js";
+import { thresholdEd25519AuthorityScopeFromWalletAuthAuthority } from "../../../../core/ThresholdService/validation.js";
 import { createRouterApiModule } from "../../../framework/modules.js";
 import { InMemoryRouterAbEd25519YaoRegistrationStateV1, createRouterAbEd25519YaoRegistrationModule } from "../registration/routerAbEd25519YaoRegistration.js";
 import { InMemoryRouterAbEd25519YaoRegistrationIntentAuthorizationStateV1 } from "../registration/routerAbEd25519YaoRegistrationIntentAuthorization.js";
@@ -83,9 +84,29 @@ function isDispatchRootMap(input) {
 	for (const [key, value] of input) if (typeof key !== "string" || parseRouterAbEd25519YaoTenantRootWireV1(value) === null) return false;
 	return true;
 }
-function isStringSet(input) {
-	if (!(input instanceof Set)) return false;
-	for (const value of input) if (typeof value !== "string") return false;
+function isWalletOwnershipMap(input) {
+	if (!isStringMap(input)) return false;
+	for (const [key, walletId] of input) {
+		const parsed = parseWalletId(walletId);
+		if (!key || !parsed.ok || parsed.value !== walletId) return false;
+	}
+	return true;
+}
+function hasIntentAuthorityGeneration(input) {
+	return isPlainObject(input) && INTENT_AUTHORITY_KINDS.has(String(input.kind)) && typeof input.ownershipGeneration === "number" && Number.isSafeInteger(input.ownershipGeneration) && input.ownershipGeneration > 0;
+}
+function hasRecoveryOwnershipGenerations(input) {
+	if (!(input instanceof Map)) return false;
+	for (const state of input.values()) {
+		if (!isPlainObject(state) || !isPlainObject(state.context)) return false;
+		const authorization = state.context.authorization;
+		if (!isPlainObject(authorization) || typeof authorization.ownershipGeneration !== "number" || !Number.isSafeInteger(authorization.ownershipGeneration) || authorization.ownershipGeneration < 1) return false;
+	}
+	return true;
+}
+function hasExportOwnershipGenerations(input) {
+	if (!(input instanceof Map)) return false;
+	for (const state of input.values()) if (!isPlainObject(state) || typeof state.ownershipGeneration !== "number" || !Number.isSafeInteger(state.ownershipGeneration) || state.ownershipGeneration < 1) return false;
 	return true;
 }
 function hasProductStateCollections(input) {
@@ -96,7 +117,7 @@ function hasProductStateCollections(input) {
 	const recovery = input.recovery;
 	const exportState = input.export;
 	if (!isPlainObject(registration) || !isPlainObject(authorization) || !isPlainObject(recovery) || !isPlainObject(exportState)) return false;
-	return isStringMapWithStateKinds(registration.states, REGISTRATION_STATE_KINDS) && isStringMap(registration.lifecycleSessions) && (registration.admissionClaims === void 0 || isStringMapWithStateKinds(registration.admissionClaims, REGISTRATION_ADMISSION_CLAIM_KINDS)) && isDispatchRootMap(registration.dispatchRoots) && Array.isArray(authorization.authorities) && authorization.authorities.every((authority) => isPlainObject(authority) && INTENT_AUTHORITY_KINDS.has(String(authority.kind))) && isStringMapWithStateKinds(recovery.capabilities, CAPABILITY_STATE_KINDS) && isStringMap(recovery.identityCapabilities) && isStringMapWithStateKinds(recovery.recoveries, RECOVERY_STATE_KINDS) && isStringMap(recovery.recoverySessions) && isStringMapWithStateKinds(exportState.exports, EXPORT_STATE_KINDS) && isStringSet(exportState.authorizationNonces) && (exportState.authorizationUncertain === void 0 || isStringSet(exportState.authorizationUncertain));
+	return isStringMapWithStateKinds(registration.states, REGISTRATION_STATE_KINDS) && isStringMap(registration.lifecycleSessions) && (registration.admissionClaims === void 0 || isStringMapWithStateKinds(registration.admissionClaims, REGISTRATION_ADMISSION_CLAIM_KINDS)) && isDispatchRootMap(registration.dispatchRoots) && Array.isArray(authorization.authorities) && authorization.authorities.every(hasIntentAuthorityGeneration) && isStringMapWithStateKinds(recovery.capabilities, CAPABILITY_STATE_KINDS) && isStringMap(recovery.identityCapabilities) && isStringMapWithStateKinds(recovery.recoveries, RECOVERY_STATE_KINDS) && hasRecoveryOwnershipGenerations(recovery.recoveries) && isStringMap(recovery.recoverySessions) && isStringMapWithStateKinds(exportState.exports, EXPORT_STATE_KINDS) && hasExportOwnershipGenerations(exportState.exports) && isWalletOwnershipMap(exportState.authorizationNonceOwners) && isWalletOwnershipMap(exportState.authorizationUncertainOwners);
 }
 function parseRouterAbEd25519YaoProductRegistrationStateV1(input) {
 	if (!hasProductStateCollections(input)) return {
@@ -105,7 +126,6 @@ function parseRouterAbEd25519YaoProductRegistrationStateV1(input) {
 	};
 	const registration = input.registration;
 	const admissionClaims = registration.admissionClaims === void 0 ? /* @__PURE__ */ new Map() : registration.admissionClaims;
-	const authorizationUncertain = input.export.authorizationUncertain === void 0 ? /* @__PURE__ */ new Set() : input.export.authorizationUncertain;
 	return {
 		ok: true,
 		value: {
@@ -120,8 +140,8 @@ function parseRouterAbEd25519YaoProductRegistrationStateV1(input) {
 			recovery: input.recovery,
 			export: {
 				exports: input.export.exports,
-				authorizationNonces: input.export.authorizationNonces,
-				authorizationUncertain
+				authorizationNonceOwners: input.export.authorizationNonceOwners,
+				authorizationUncertainOwners: input.export.authorizationUncertainOwners
 			}
 		}
 	};
@@ -199,17 +219,26 @@ var RouterAbEd25519YaoProductRegistrationRuntime = class {
 	async bindVerifiedIntent(input) {
 		return await this.input.authorization.bindVerifiedIntent(input);
 	}
+	/** The registration service of this runtime resolves the tenant root when it executes. */
+	startRegistrationDispatchRoot() {
+		return null;
+	}
 	async bindAndAdmitVerifiedRegistration(input) {
-		const bound = await this.input.authorization.bindVerifiedIntent(input);
+		const bound = await this.input.authorization.bindAndAuthorizeAdmission(input);
 		if (!bound.ok) return bound;
-		return await this.input.registrationService.admit(bound.admissionRequest);
+		const admitted = await this.input.registrationService.admit(bound.admissionRequest);
+		if (!admitted.ok) return admitted;
+		return {
+			ok: true,
+			status: 200,
+			admissionRequest: bound.admissionRequest,
+			value: admitted.value,
+			companionWrite: "not_committed"
+		};
 	}
 	async consumeActivated(request) {
 		return await this.input.registrationService.consumeActivated(request);
 	}
-	async installRegistrationFinalizeCapability(input) {
-		return await this.input.capabilityInstaller.installRegistrationFinalizeCapability(input);
-	}
 	async installPersistedActiveCapability(input) {
 		return await this.input.capabilityInstaller.installPersistedActiveCapability(input);
 	}

package/dist/esm/router/domains/ed25519Yao/capabilityLifecycle/routerAbEd25519YaoProductRegistrationPartitionedStateStore.js

@@ -1,7 +1,7 @@
+import { buildRouterAbEd25519YaoRegistrationExecutionAuthorityV1 } from "../registration/routerAbEd25519YaoRegistrationExecutionRecord.js";
 import { createRouterAbEd25519YaoProductRegistrationStateV1 } from "./routerAbEd25519YaoProductRegistration.js";
 import { encodeRouterAbEd25519YaoProductRegistrationStateV1, parseRouterAbEd25519YaoProductRegistrationStateJsonV1 } from "./routerAbEd25519YaoProductRegistrationPersistence.js";
 import { boundedRouterAbEd25519YaoProductRegistrationSharedStateV1, mergeRouterAbEd25519YaoProductRegistrationStatePartitionV1, partitionRouterAbEd25519YaoProductRegistrationStateV1 } from "./routerAbEd25519YaoProductRegistrationPartitioning.js";
-import { buildRouterAbEd25519YaoRegistrationExecutionAuthorityV1 } from "../registration/routerAbEd25519YaoRegistrationExecutionRecord.js";
 //#region src/router/domains/ed25519Yao/capabilityLifecycle/routerAbEd25519YaoProductRegistrationPartitionedStateStore.ts
 const ROUTER_AB_ED25519_YAO_SHARED_STATE_RECORD_KEY_V1 = "router-ab-ed25519-yao:shared";
 const PARTITION_RECORD_CODEC_KIND = "router_ab_ed25519_yao_product_registration_partition_record_json_v1";
@@ -122,15 +122,16 @@ function parseRouterAbEd25519YaoProductRegistrationPartitionRecordJsonV1(input)
 	return isVersionedJsonObject(input) ? input : null;
 }
 function isEmptyCeremonyState(state) {
-	return state.registration.states.size === 0 && state.registration.lifecycleSessions.size === 0 && state.registration.admissionClaims.size === 0 && state.authorization.authorities.length === 0 && state.recovery.recoveries.size === 0 && state.export.exports.size === 0;
+	return state.registration.states.size === 0 && state.registration.lifecycleSessions.size === 0 && state.registration.admissionClaims.size === 0 && state.registration.dispatchRoots.size === 0 && state.authorization.authorities.length === 0 && state.recovery.recoveries.size === 0 && state.export.exports.size === 0;
 }
 function isEmptySharedState(state) {
-	return state.recovery.capabilities.size === 0 && state.recovery.identityCapabilities.size === 0 && state.recovery.recoverySessions.size === 0 && state.export.authorizationNonces.size === 0 && state.export.authorizationUncertain.size === 0;
+	return state.recovery.capabilities.size === 0 && state.recovery.identityCapabilities.size === 0 && state.recovery.recoverySessions.size === 0 && state.export.authorizationNonceOwners.size === 0 && state.export.authorizationUncertainOwners.size === 0;
 }
 function isCeremonyStateOwnedByLifecycle(state, lifecycleId) {
 	for (const value of state.registration.states.values()) if (value.admissionRequest.scope.lifecycle_id !== lifecycleId) return false;
 	for (const key of state.registration.lifecycleSessions.keys()) if (key !== lifecycleId) return false;
 	for (const key of state.registration.admissionClaims.keys()) if (key !== lifecycleId) return false;
+	for (const key of state.registration.dispatchRoots.keys()) if (key !== lifecycleId) return false;
 	for (const authority of state.authorization.authorities) if (authority.admissionRequest.scope.lifecycle_id !== lifecycleId) return false;
 	for (const value of state.recovery.recoveries.values()) if (value.context.admissionRequest.scope.lifecycle_id !== lifecycleId) return false;
 	for (const value of state.export.exports.values()) if (value.request.scope.lifecycle_id !== lifecycleId) return false;
@@ -158,6 +159,66 @@ var RouterAbEd25519YaoProductRegistrationPartitionedStateStore = class {
 		});
 		return await this.store.putMany(encodedMutations, companion);
 	}
+	async loadCapabilities() {
+		return readSharedRecord(readManyEntry(await this.readMany([ROUTER_AB_ED25519_YAO_SHARED_STATE_RECORD_KEY_V1]), ROUTER_AB_ED25519_YAO_SHARED_STATE_RECORD_KEY_V1));
+	}
+	async commitCapabilities(snapshot, mutation, companionWrite) {
+		const shared = boundedRouterAbEd25519YaoProductRegistrationSharedStateV1({
+			kind: "router_ab_ed25519_yao_product_registration_shared_state_v1",
+			recoveryCapabilities: mutation.capabilities,
+			recoveryIdentityCapabilities: mutation.identityCapabilities,
+			recoverySessions: snapshot.value.recoverySessions,
+			exportAuthorizationNonceOwners: snapshot.value.exportAuthorizationNonceOwners,
+			exportAuthorizationUncertainOwners: snapshot.value.exportAuthorizationUncertainOwners
+		});
+		if (companionWrite === null && sameRouterAbEd25519YaoSharedStateCanonicalEncodingV1(encodeSharedStateCanonicalEncoding(shared), encodeSharedStateCanonicalEncoding(snapshot.value))) return {
+			kind: "stored",
+			versions: []
+		};
+		return await this.putMany([{
+			key: ROUTER_AB_ED25519_YAO_SHARED_STATE_RECORD_KEY_V1,
+			expectedVersion: snapshot.version,
+			value: {
+				kind: SHARED_RECORD_KIND,
+				value: shared
+			}
+		}], companionWrite);
+	}
+	async loadRegistration(lifecycleId) {
+		const normalizedLifecycleId = requireLifecycleId(lifecycleId);
+		const ceremony = readCeremonyRecord(readManyEntry(await this.readMany([normalizedLifecycleId]), normalizedLifecycleId), normalizedLifecycleId);
+		const state = materializeState(readSharedRecord({ kind: "missing" }).value, ceremony.value);
+		return {
+			lifecycleId: normalizedLifecycleId,
+			state: {
+				registration: state.registration,
+				authorization: state.authorization
+			},
+			baseline: {
+				version: ceremony.version,
+				recovery: ceremony.value.recovery,
+				export: ceremony.value.export
+			}
+		};
+	}
+	async commitRegistration(snapshot, companionWrite) {
+		return await this.putMany([{
+			key: snapshot.lifecycleId,
+			expectedVersion: snapshot.baseline.version,
+			value: {
+				kind: CEREMONY_RECORD_KIND,
+				lifecycleId: snapshot.lifecycleId,
+				value: {
+					kind: "router_ab_ed25519_yao_product_registration_ceremony_state_v1",
+					lifecycleId: snapshot.lifecycleId,
+					registration: snapshot.state.registration,
+					authorization: snapshot.state.authorization,
+					recovery: snapshot.baseline.recovery,
+					export: snapshot.baseline.export
+				}
+			}
+		}], companionWrite);
+	}
 	async load(lifecycleId) {
 		const normalizedLifecycleId = requireLifecycleId(lifecycleId);
 		const entries = await this.readMany([ROUTER_AB_ED25519_YAO_SHARED_STATE_RECORD_KEY_V1, normalizedLifecycleId]);

package/dist/esm/router/domains/ed25519Yao/capabilityLifecycle/routerAbEd25519YaoProductRegistrationPartitioning.js

@@ -19,8 +19,8 @@ function partitionRouterAbEd25519YaoProductRegistrationStateV1(state, lifecycleI
 			recoveryCapabilities: new Map(state.recovery.capabilities),
 			recoveryIdentityCapabilities: new Map(state.recovery.identityCapabilities),
 			recoverySessions: new Map(state.recovery.recoverySessions),
-			exportAuthorizationNonces: new Set(state.export.authorizationNonces),
-			exportAuthorizationUncertain: new Set(state.export.authorizationUncertain)
+			exportAuthorizationNonceOwners: new Map(state.export.authorizationNonceOwners),
+			exportAuthorizationUncertainOwners: new Map(state.export.authorizationUncertainOwners)
 		},
 		ceremony: {
 			kind: "router_ab_ed25519_yao_product_registration_ceremony_state_v1",
@@ -75,8 +75,8 @@ function mergeRouterAbEd25519YaoProductRegistrationStatePartitionV1(base, partit
 		},
 		export: {
 			exports,
-			authorizationNonces: new Set(partition.shared.exportAuthorizationNonces),
-			authorizationUncertain: new Set(partition.shared.exportAuthorizationUncertain)
+			authorizationNonceOwners: new Map(partition.shared.exportAuthorizationNonceOwners),
+			authorizationUncertainOwners: new Map(partition.shared.exportAuthorizationUncertainOwners)
 		}
 	});
 }
@@ -102,8 +102,8 @@ function boundedRouterAbEd25519YaoProductRegistrationSharedStateV1(source) {
 		recoveryCapabilities,
 		recoveryIdentityCapabilities: retainedRecoveryIdentityCapabilities(source.recoveryIdentityCapabilities, recoveryCapabilities),
 		recoverySessions: new Map(source.recoverySessions),
-		exportAuthorizationNonces: new Set(source.exportAuthorizationNonces),
-		exportAuthorizationUncertain: new Set(source.exportAuthorizationUncertain)
+		exportAuthorizationNonceOwners: new Map(source.exportAuthorizationNonceOwners),
+		exportAuthorizationUncertainOwners: new Map(source.exportAuthorizationUncertainOwners)
 	};
 }
 function boundedRecoveryCapabilities(source) {

package/dist/esm/router/domains/ed25519Yao/capabilityLifecycle/routerAbEd25519YaoProductRegistrationPersistence.js

@@ -9,7 +9,10 @@ function createRouterAbEd25519YaoCeremonyStateStoreV1(store) {
 		put: async (key, value, expectedVersion) => await store.put(key.lifecycleId, value, expectedVersion)
 	};
 }
-const CODEC_KIND = "router_ab_ed25519_yao_product_registration_state_json_v1";
+const CODEC_KIND = "router_ab_ed25519_yao_product_registration_state_json_v4";
+const RECOVERY_GENERATION_CODEC_KIND = "router_ab_ed25519_yao_product_registration_state_json_v3";
+const REGISTRATION_GENERATION_CODEC_KIND = "router_ab_ed25519_yao_product_registration_state_json_v2";
+const FIXED_HOME_CODEC_KIND = "router_ab_ed25519_yao_product_registration_state_json_v1";
 const MAP_KIND = "map_v1";
 const SET_KIND = "set_v1";
 const BYTES_KIND = "bytes_v1";
@@ -23,12 +26,76 @@ function encodeRouterAbEd25519YaoProductRegistrationStateV1(state) {
 }
 function parseRouterAbEd25519YaoProductRegistrationStateJsonV1(input) {
 	const record = exactRouterAbEd25519YaoProductRegistrationStateEnvelopeV1(input);
-	if (record === null || record.kind !== CODEC_KIND) return null;
+	if (record === null || record.kind !== CODEC_KIND && record.kind !== FIXED_HOME_CODEC_KIND && record.kind !== REGISTRATION_GENERATION_CODEC_KIND && record.kind !== RECOVERY_GENERATION_CODEC_KIND) return null;
 	const decoded = decodeRouterAbEd25519YaoProductRegistrationStateValueV1(record.state);
 	if (!decoded.ok || !isRouterAbEd25519YaoProductRegistrationJsonObjectV1(decoded.value)) return null;
-	const parsed = parseRouterAbEd25519YaoProductRegistrationStateV1(decoded.value);
+	const state = record.kind === FIXED_HOME_CODEC_KIND ? normalizeFixedHomeAuthorities(decoded.value) : decoded.value;
+	const recoveryNormalized = record.kind === CODEC_KIND || record.kind === RECOVERY_GENERATION_CODEC_KIND ? state : normalizeFixedHomeRecoveries(state);
+	const parsed = parseRouterAbEd25519YaoProductRegistrationStateV1(record.kind === CODEC_KIND ? recoveryNormalized : normalizeFixedHomeExports(recoveryNormalized));
 	return parsed.ok ? parsed.value : null;
 }
+function normalizeFixedHomeAuthority(input) {
+	if (!isRouterAbEd25519YaoProductRegistrationJsonObjectV1(input)) return input;
+	if (Object.prototype.hasOwnProperty.call(input, "ownershipGeneration")) return input;
+	return {
+		...input,
+		ownershipGeneration: 1
+	};
+}
+function normalizeFixedHomeAuthorities(state) {
+	const authorization = state.authorization;
+	if (!isRouterAbEd25519YaoProductRegistrationJsonObjectV1(authorization)) return state;
+	if (!Array.isArray(authorization.authorities)) return state;
+	return {
+		...state,
+		authorization: {
+			...authorization,
+			authorities: authorization.authorities.map(normalizeFixedHomeAuthority)
+		}
+	};
+}
+function normalizeFixedHomeRecovery(input) {
+	if (!isRouterAbEd25519YaoProductRegistrationJsonObjectV1(input)) return input;
+	const context = input.context;
+	if (!isRouterAbEd25519YaoProductRegistrationJsonObjectV1(context)) return input;
+	return {
+		...input,
+		context: {
+			...context,
+			authorization: normalizeFixedHomeAuthority(context.authorization)
+		}
+	};
+}
+function normalizeFixedHomeRecoveries(input) {
+	if (!isRouterAbEd25519YaoProductRegistrationJsonObjectV1(input)) return input;
+	const recovery = input.recovery;
+	if (!isRouterAbEd25519YaoProductRegistrationJsonObjectV1(recovery)) return input;
+	if (!(recovery.recoveries instanceof Map)) return input;
+	const recoveries = /* @__PURE__ */ new Map();
+	for (const [key, value] of recovery.recoveries) recoveries.set(key, normalizeFixedHomeRecovery(value));
+	return {
+		...input,
+		recovery: {
+			...recovery,
+			recoveries
+		}
+	};
+}
+function normalizeFixedHomeExports(input) {
+	if (!isRouterAbEd25519YaoProductRegistrationJsonObjectV1(input)) return input;
+	const exportState = input.export;
+	if (!isRouterAbEd25519YaoProductRegistrationJsonObjectV1(exportState)) return input;
+	if (!(exportState.exports instanceof Map)) return input;
+	const exports = /* @__PURE__ */ new Map();
+	for (const [key, value] of exportState.exports) exports.set(key, normalizeFixedHomeAuthority(value));
+	return {
+		...input,
+		export: {
+			...exportState,
+			exports
+		}
+	};
+}
 function parseRouterAbEd25519YaoCeremonyKeyV1(input) {
 	const record = readRouterAbEd25519YaoCeremonyKeyObjectV1(input);
 	if (record === null) return null;