@seams/wallet-server 0.8.0 → 0.9.1

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

@@ -92,6 +92,23 @@ function isWalletOwnershipMap(input) {
 	}
 	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) {
 	if (!isPlainObject(input)) return false;
 	if (input.kind !== "router_ab_ed25519_yao_product_registration_state_v1") return false;
@@ -100,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) && isWalletOwnershipMap(exportState.authorizationNonceOwners) && isWalletOwnershipMap(exportState.authorizationUncertainOwners);
+	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 {
@@ -202,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";
@@ -159,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/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;

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

@@ -1,21 +1,14 @@
 import { InMemoryRouterAbEd25519YaoRegistrationService } from "../registration/routerAbEd25519YaoRegistration.js";
 import { InMemoryRouterAbEd25519YaoRegistrationIntentAuthorizationAdapter } from "../registration/routerAbEd25519YaoRegistrationIntentAuthorization.js";
-import { InMemoryRouterAbEd25519YaoRecoveryService } from "../recovery/routerAbEd25519YaoRecovery.js";
-import { routerAbEd25519YaoPersistedCapabilityMatchesLookupV1 } from "./routerAbEd25519YaoProductRegistration.js";
-import { parseRouterAbEd25519YaoRegistrationRouterAnswerV1 } from "../registration/routerAbEd25519YaoHttpRegistrationBackend.js";
 import { pinRouterAbEd25519YaoRegistrationDispatchRootV1, routerAbEd25519YaoRegistrationExecuteRequestFromRouterRequestJsonV1, routerAbEd25519YaoRegistrationResultFromRouterAnswerV1 } from "../registration/routerAbEd25519YaoRegistrationExecutionRecord.js";
+import { resolveRouterAbEd25519YaoActiveCapability } from "../recovery/routerAbEd25519YaoRecovery.js";
+import { routerAbEd25519YaoRegistrationSigningRootIdV1 } from "../routerAbEd25519YaoGatewayEnvelope.js";
+import { routerAbEd25519YaoPersistedCapabilityMatchesLookupV1 } from "./routerAbEd25519YaoProductRegistration.js";
 import { routerAbEd25519YaoAdmittedRegistrationAuthorityV1 } from "./routerAbEd25519YaoProductRegistrationPartitionedStateStore.js";
+import { parseRouterAbEd25519YaoRegistrationRouterAnswerV1 } from "../registration/routerAbEd25519YaoHttpRegistrationBackend.js";
+import { rehydrateRouterAbEd25519YaoCapability } from "./routerAbEd25519YaoCapabilityCommit.js";
 //#region src/router/domains/ed25519Yao/capabilityLifecycle/routerAbEd25519YaoProductRegistrationRequestScopedRuntime.ts
-const SHARED_CAPABILITY_READ_LIFECYCLE_ID = "shared-capability-read";
 const MAX_DETERMINISTIC_COMMIT_ATTEMPTS = 2;
-const UNUSED_BACKEND = {
-	admit: rejectUnusedBackend,
-	execute: rejectUnusedBackend,
-	admitRecovery: rejectUnusedBackend,
-	resolveRecoveryDispatchRoot: rejectUnusedBackend,
-	executeRecovery: rejectUnusedBackend,
-	activateRecovery: rejectUnusedBackend
-};
 /**
 * Product-state runtime for wallet start/finalize routes. Each mutation loads
 * fresh partitioned state and reconciles CAS conflicts by reapplying only the
@@ -33,11 +26,28 @@ var RouterAbEd25519YaoProductRegistrationRequestScopedRuntime = class {
 		if (!this.signingWorkerId) throw new Error("Ed25519 Yao SigningWorker ID is required");
 	}
 	async bindVerifiedIntent(input) {
-		return await this.commitUntilReconciled(input.admissionRequest.scope.lifecycle_id, bindVerifiedIntentMutation.bind(void 0, input));
+		for (let attempt = 0; attempt < MAX_DETERMINISTIC_COMMIT_ATTEMPTS; attempt += 1) {
+			const loaded = await this.input.store.loadRegistration(input.admissionRequest.scope.lifecycle_id);
+			const result = await new InMemoryRouterAbEd25519YaoRegistrationIntentAuthorizationAdapter(loaded.state.authorization).bindVerifiedIntent(input);
+			if (!result.ok) return result;
+			if ((await this.input.store.commitRegistration(loaded, null)).kind !== "stored") continue;
+			return result;
+		}
+		throw new Error("Registration intent remained contended after one reconciliation");
+	}
+	startRegistrationDispatchRoot(signingRootId) {
+		const dispatchRoot = this.input.registrationBackend.resolveRegistrationDispatchRoot(signingRootId);
+		dispatchRoot.catch(ignoreUnobservedDispatchRoot);
+		return {
+			signingRootId,
+			dispatchRoot
+		};
 	}
-	async bindAndAdmitVerifiedRegistration(input) {
+	async bindAndAdmitVerifiedRegistration(input, companionWrite, startedDispatchRoot) {
 		return await bindAndAdmitVerifiedRegistration({
 			input,
+			companionWrite,
+			startedDispatchRoot,
 			store: this.input.store,
 			backend: this.input.registrationBackend
 		});
@@ -51,7 +61,7 @@ var RouterAbEd25519YaoProductRegistrationRequestScopedRuntime = class {
 	*/
 	async consumeActivated(input) {
 		const lifecycleId = input.reference.lifecycleId;
-		const authority = routerAbEd25519YaoAdmittedRegistrationAuthorityV1((await this.input.store.load(lifecycleId)).state, lifecycleId);
+		const authority = routerAbEd25519YaoAdmittedRegistrationAuthorityV1((await this.input.store.loadRegistration(lifecycleId)).state, lifecycleId);
 		if (!authority) return {
 			ok: false,
 			code: "unknown_registration",
@@ -59,9 +69,7 @@ var RouterAbEd25519YaoProductRegistrationRequestScopedRuntime = class {
 		};
 		const backend = this.input.registrationBackend;
 		const consumed = await backend.consumeRegistration({
-			tenantRoot: authority.dispatchRoot,
-			walletId: authority.admissionReceipt.binding.lifecycle.account_id,
-			lifecycleId,
+			authority,
 			sessionId: input.reference.sessionId,
 			consumerBinding: input.consumerBinding
 		});
@@ -91,14 +99,11 @@ var RouterAbEd25519YaoProductRegistrationRequestScopedRuntime = class {
 			}
 		};
 	}
-	async installRegistrationFinalizeCapability(input) {
-		return await this.commitUntilReconciled(input.registrationAdmissionRequest.scope.lifecycle_id, installRegistrationFinalizeCapabilityMutation.bind(void 0, input));
-	}
 	async installPersistedActiveCapability(input) {
-		return await this.commitUntilReconciled(input.admissionRequest.scope.lifecycle_id, installPersistedActiveCapabilityMutation.bind(void 0, input));
+		return await rehydrateRouterAbEd25519YaoCapability(this.input.store, input);
 	}
 	async resolveActiveCapability(input) {
-		const result = recoveryService((await this.input.store.load(SHARED_CAPABILITY_READ_LIFECYCLE_ID)).state).resolveActiveCapability(input);
+		const result = resolveRouterAbEd25519YaoActiveCapability((await this.input.store.loadCapabilities()).value.recoveryCapabilities, input);
 		if (result.ok || result.code !== "unknown_capability" || !this.input.loadPersistedActiveCapability) return result;
 		const persisted = await this.input.loadPersistedActiveCapability(input);
 		if (!persisted || !routerAbEd25519YaoPersistedCapabilityMatchesLookupV1(persisted, input)) return result;
@@ -108,48 +113,52 @@ var RouterAbEd25519YaoProductRegistrationRequestScopedRuntime = class {
 			code: "capability_conflict",
 			message: installed.message
 		};
-		return recoveryService((await this.input.store.load(SHARED_CAPABILITY_READ_LIFECYCLE_ID)).state).resolveActiveCapability(input);
-	}
-	async commitUntilReconciled(lifecycleId, mutate) {
-		for (let attempt = 0; attempt < MAX_DETERMINISTIC_COMMIT_ATTEMPTS; attempt += 1) {
-			const loaded = await this.input.store.load(lifecycleId);
-			const mutation = await mutate(loaded.state);
-			if (mutation.kind === "reject") return mutation.value;
-			if ((await this.input.store.commit(commitInput(lifecycleId, loaded))).kind === "stored") return mutation.value;
-		}
-		throw new Error("Request-scoped product state remained contended after one reconciliation");
+		return resolveRouterAbEd25519YaoActiveCapability((await this.input.store.loadCapabilities()).value.recoveryCapabilities, input);
 	}
 };
 /**
 * Binds a verified intent and admits its registration. The tenant root the
 * registration dispatches to is resolved once, for a fresh admission, and
-* pinned with the admission in the ceremony record.
+* pinned with the admission in the ceremony record. A companion write commits
+* in that record's batch.
 */
 async function bindAndAdmitVerifiedRegistration(input) {
 	const lifecycleId = input.input.admissionRequest.scope.lifecycle_id;
 	let backendResult = null;
 	let dispatchRoot = null;
 	for (let attempt = 0; attempt < MAX_DETERMINISTIC_COMMIT_ATTEMPTS; attempt += 1) {
-		const loaded = await input.store.load(lifecycleId);
-		const bound = await new InMemoryRouterAbEd25519YaoRegistrationIntentAuthorizationAdapter(loaded.state.authorization).bindVerifiedIntent(input.input);
+		const loaded = await input.store.loadRegistration(lifecycleId);
+		const bound = await new InMemoryRouterAbEd25519YaoRegistrationIntentAuthorizationAdapter(loaded.state.authorization).bindAndAuthorizeAdmission(input.input);
 		if (!bound.ok) return bound;
 		const service = new InMemoryRouterAbEd25519YaoRegistrationService(input.backend, loaded.state.registration);
 		const preparation = service.prepareAdmit(bound.admissionRequest);
 		if (preparation.kind === "completed") return {
 			ok: true,
 			status: 200,
-			value: preparation.value
+			admissionRequest: bound.admissionRequest,
+			value: preparation.value,
+			companionWrite: "not_committed"
 		};
 		if (preparation.kind === "failed") return preparation.failure;
-		if (dispatchRoot === null) try {
-			dispatchRoot = await input.backend.resolveRegistrationDispatchRoot(bound.admissionRequest);
-		} catch (error) {
-			return {
+		if (dispatchRoot === null) {
+			const signingRootId = routerAbEd25519YaoRegistrationSigningRootIdV1(bound.admissionRequest);
+			const started = input.startedDispatchRoot;
+			if (started !== null && (started.signingRootId.signing_root_id !== signingRootId.signing_root_id || started.signingRootId.root_share_epoch !== signingRootId.root_share_epoch)) return {
 				ok: false,
 				status: 503,
 				code: "admission_failed",
-				message: `registration tenant root is unavailable: ${error instanceof Error ? error.message : String(error)}`
+				message: "registration tenant root was read for another signing root ID"
 			};
+			try {
+				dispatchRoot = await (started ? started.dispatchRoot : input.backend.resolveRegistrationDispatchRoot(signingRootId));
+			} catch (error) {
+				return {
+					ok: false,
+					status: 503,
+					code: "admission_failed",
+					message: `registration tenant root is unavailable: ${error instanceof Error ? error.message : String(error)}`
+				};
+			}
 		}
 		if (backendResult === null) try {
 			backendResult = await input.backend.admit(bound.admissionRequest);
@@ -171,7 +180,13 @@ async function bindAndAdmitVerifiedRegistration(input) {
 		});
 		if (!admitted.ok) return admitted;
 		pinRouterAbEd25519YaoRegistrationDispatchRootV1(loaded.state.registration, lifecycleId, dispatchRoot);
-		if ((await input.store.commit(commitInput(lifecycleId, loaded))).kind === "stored") return admitted;
+		if ((await input.store.commitRegistration(loaded, input.companionWrite?.(bound.admissionRequest) ?? null)).kind === "stored") return {
+			ok: true,
+			status: 200,
+			admissionRequest: bound.admissionRequest,
+			value: admitted.value,
+			companionWrite: input.companionWrite ? "committed" : "not_committed"
+		};
 	}
 	return {
 		ok: false,
@@ -180,50 +195,7 @@ async function bindAndAdmitVerifiedRegistration(input) {
 		message: "Yao verified registration admission remained contended after one reconciliation"
 	};
 }
-async function bindVerifiedIntentMutation(input, state) {
-	const result = await new InMemoryRouterAbEd25519YaoRegistrationIntentAuthorizationAdapter(state.authorization).bindVerifiedIntent(input);
-	return result.ok ? {
-		kind: "commit",
-		value: result
-	} : {
-		kind: "reject",
-		value: result
-	};
-}
-async function installRegistrationFinalizeCapabilityMutation(input, state) {
-	const result = recoveryService(state).installRegistrationFinalizeCapability(input);
-	return result.ok ? {
-		kind: "commit",
-		value: result
-	} : {
-		kind: "reject",
-		value: result
-	};
-}
-async function installPersistedActiveCapabilityMutation(input, state) {
-	const result = recoveryService(state).installPersistedActiveCapability(input);
-	return result.ok ? {
-		kind: "commit",
-		value: result
-	} : {
-		kind: "reject",
-		value: result
-	};
-}
-function recoveryService(state) {
-	return new InMemoryRouterAbEd25519YaoRecoveryService(UNUSED_BACKEND, state.recovery);
-}
-function commitInput(lifecycleId, loaded) {
-	return {
-		lifecycleId,
-		state: loaded.state,
-		baseline: loaded.baseline,
-		companionWrite: null
-	};
-}
-async function rejectUnusedBackend() {
-	throw new Error("Request-scoped product runtime invoked an unavailable protocol backend");
-}
+function ignoreUnobservedDispatchRoot() {}
 //#endregion
 export { createRouterAbEd25519YaoProductRegistrationRequestScopedRuntimeV1 };