@seams/wallet-server 0.6.1 → 0.7.1

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

@@ -1,17 +1,12 @@
-import { sameRouterAbMpcMaterialActivationRef } from "../../../../shared-ts/src/utils/routerAbNormalSigningIdentity.js";
-import { sameRouterAbEd25519YaoActivationBindingV1 } from "../../../../shared-ts/src/utils/routerAbEd25519Yao.js";
-import { routerAbEd25519YaoExecutionMatchesAdmissionV1 } from "../registration/routerAbEd25519YaoRegistration.js";
 import { createRouterAbEd25519YaoProductRegistrationStateV1 } from "./routerAbEd25519YaoProductRegistration.js";
 import { encodeRouterAbEd25519YaoProductRegistrationStateV1, parseRouterAbEd25519YaoProductRegistrationStateJsonV1 } from "./routerAbEd25519YaoProductRegistrationPersistence.js";
 import { boundedRouterAbEd25519YaoProductRegistrationSharedStateV1, mergeRouterAbEd25519YaoProductRegistrationStatePartitionV1, partitionRouterAbEd25519YaoProductRegistrationStateV1 } from "./routerAbEd25519YaoProductRegistrationPartitioning.js";
-import { ROUTER_AB_ED25519_YAO_REGISTRATION_EXECUTION_RECORD_KIND_V1, buildRouterAbEd25519YaoRegistrationExecutionReadyRecordV1, encodeRouterAbEd25519YaoRegistrationExecutionRecordV1, parseRouterAbEd25519YaoRegistrationExecutionRecordV1, routerAbEd25519YaoRegistrationExecutionRecordKeyV1 } from "../registration/routerAbEd25519YaoRegistrationExecutionRecord.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";
 const SHARED_RECORD_KIND = "router_ab_ed25519_yao_product_registration_shared_record_v1";
 const CEREMONY_RECORD_KIND = "router_ab_ed25519_yao_product_registration_ceremony_record_v1";
-const EXECUTION_RECORD_KIND = ROUTER_AB_ED25519_YAO_REGISTRATION_EXECUTION_RECORD_KIND_V1;
-const EXECUTION_RECONCILIATION_LEASE_MS = 1e4;
 function routerAbEd25519YaoPartitionedStateAfterStoredCommitV1(input) {
 	const lifecycleId = requireLifecycleId(input.lifecycleId);
 	const shared = boundedRouterAbEd25519YaoProductRegistrationSharedStateV1(partitionRouterAbEd25519YaoProductRegistrationStateV1(input.state, lifecycleId).shared);
@@ -20,21 +15,30 @@ function routerAbEd25519YaoPartitionedStateAfterStoredCommitV1(input) {
 		baseline: {
 			sharedEncoding: encodeSharedStateCanonicalEncoding(shared),
 			sharedVersion: input.commit.sharedVersion,
-			ceremonyVersion: input.commit.ceremonyVersion,
-			executionVersion: input.commit.executionVersion
+			ceremonyVersion: input.commit.ceremonyVersion
 		}
 	};
 }
-function createRouterAbEd25519YaoProductRegistrationPartitionedStateStoreV1(store, atomicPatch) {
-	return new RouterAbEd25519YaoProductRegistrationPartitionedStateStore(store, atomicPatch);
+function createRouterAbEd25519YaoProductRegistrationPartitionedStateStoreV1(store) {
+	return new RouterAbEd25519YaoProductRegistrationPartitionedStateStore(store);
+}
+/**
+* The admitted authority a registration execute is checked against, from a
+* loaded ceremony state, or `null` when the lifecycle is not admitted.
+*/
+function routerAbEd25519YaoAdmittedRegistrationAuthorityV1(state, lifecycleId) {
+	const sessionKey = state.registration.lifecycleSessions.get(lifecycleId);
+	const registration = sessionKey === void 0 ? void 0 : state.registration.states.get(sessionKey);
+	const authority = state.authorization.authorities.find((candidate) => candidate.admissionRequest.scope.lifecycle_id === lifecycleId);
+	if (!registration || registration.kind !== "admitted" || !authority) return null;
+	return buildRouterAbEd25519YaoRegistrationExecutionAuthorityV1({
+		lifecycleId,
+		registration,
+		authority,
+		dispatchRoot: state.registration.dispatchRoots.get(lifecycleId)
+	});
 }
 function encodeRouterAbEd25519YaoProductRegistrationPartitionRecordV1(record) {
-	if (record.kind === EXECUTION_RECORD_KIND) return {
-		kind: PARTITION_RECORD_CODEC_KIND,
-		recordKind: EXECUTION_RECORD_KIND,
-		lifecycleId: record.lifecycleId,
-		execution: encodeRouterAbEd25519YaoRegistrationExecutionRecordV1(record.value)
-	};
 	const lifecycleId = record.kind === SHARED_RECORD_KIND ? "shared" : record.lifecycleId;
 	const state = createRouterAbEd25519YaoProductRegistrationStateV1();
 	const empty = partitionRouterAbEd25519YaoProductRegistrationStateV1(state, lifecycleId);
@@ -86,21 +90,6 @@ function sameVersionedJsonValue(left, right) {
 }
 function parseRouterAbEd25519YaoProductRegistrationPartitionRecordV1(input) {
 	if (!isVersionedJsonObject(input) || input.kind !== PARTITION_RECORD_CODEC_KIND) return null;
-	if (input.recordKind === EXECUTION_RECORD_KIND) {
-		if (!hasExactObjectKeys(input, [
-			"kind",
-			"recordKind",
-			"lifecycleId",
-			"execution"
-		])) return null;
-		const lifecycleId = readLifecycleId(input.lifecycleId);
-		const execution = parseRouterAbEd25519YaoRegistrationExecutionRecordV1(input.execution);
-		return lifecycleId !== null && execution?.lifecycleId === lifecycleId ? {
-			kind: EXECUTION_RECORD_KIND,
-			lifecycleId,
-			value: execution
-		} : null;
-	}
 	if (input.recordKind !== SHARED_RECORD_KIND && input.recordKind !== CEREMONY_RECORD_KIND) return null;
 	if (!hasExactObjectKeys(input, [
 		"kind",
@@ -148,9 +137,8 @@ function isCeremonyStateOwnedByLifecycle(state, lifecycleId) {
 	return true;
 }
 var RouterAbEd25519YaoProductRegistrationPartitionedStateStore = class {
-	constructor(store, atomicPatch) {
+	constructor(store) {
 		this.store = store;
-		this.atomicPatch = atomicPatch;
 	}
 	async readMany(keys) {
 		const encodedEntries = await this.store.readMany(keys);
@@ -161,34 +149,28 @@ var RouterAbEd25519YaoProductRegistrationPartitionedStateStore = class {
 		});
 		return entries;
 	}
-	async putMany(mutations) {
+	async putMany(mutations, companion) {
 		const encodedMutations = [];
 		for (const mutation of mutations) encodedMutations.push({
 			key: mutation.key,
 			value: encodeRouterAbEd25519YaoProductRegistrationPartitionRecordV1(mutation.value),
 			expectedVersion: mutation.expectedVersion
 		});
-		return await this.store.putMany(encodedMutations);
+		return await this.store.putMany(encodedMutations, companion);
 	}
 	async load(lifecycleId) {
 		const normalizedLifecycleId = requireLifecycleId(lifecycleId);
-		const entries = await this.readMany([
-			ROUTER_AB_ED25519_YAO_SHARED_STATE_RECORD_KEY_V1,
-			normalizedLifecycleId,
-			routerAbEd25519YaoRegistrationExecutionRecordKeyV1(normalizedLifecycleId)
-		]);
+		const entries = await this.readMany([ROUTER_AB_ED25519_YAO_SHARED_STATE_RECORD_KEY_V1, normalizedLifecycleId]);
 		const sharedResult = readManyEntry(entries, ROUTER_AB_ED25519_YAO_SHARED_STATE_RECORD_KEY_V1);
 		const ceremonyResult = readManyEntry(entries, normalizedLifecycleId);
 		const shared = readSharedRecord(sharedResult);
 		const ceremony = readCeremonyRecord(ceremonyResult, normalizedLifecycleId);
-		const executionVersion = readExecutionVersion(readManyEntry(entries, routerAbEd25519YaoRegistrationExecutionRecordKeyV1(normalizedLifecycleId)), normalizedLifecycleId);
 		return {
 			state: materializeState(shared.value, ceremony.value),
 			baseline: {
 				sharedEncoding: encodeSharedStateCanonicalEncoding(shared.value),
 				sharedVersion: shared.version,
-				ceremonyVersion: ceremony.version,
-				executionVersion
+				ceremonyVersion: ceremony.version
 			}
 		};
 	}
@@ -214,375 +196,18 @@ var RouterAbEd25519YaoProductRegistrationPartitionedStateStore = class {
 			},
 			expectedVersion: input.baseline.ceremonyVersion
 		});
-		const execution = registrationExecutionRecordFromState(input.state, lifecycleId);
-		if (input.baseline.executionVersion === null && execution !== null) mutations.push({
-			key: routerAbEd25519YaoRegistrationExecutionRecordKeyV1(lifecycleId),
-			value: {
-				kind: EXECUTION_RECORD_KIND,
-				lifecycleId,
-				value: execution
-			},
-			expectedVersion: input.baseline.executionVersion
-		});
-		else if (execution !== null) {
-			const key = routerAbEd25519YaoRegistrationExecutionRecordKeyV1(lifecycleId);
-			const current = readManyEntry(await this.readMany([key]), key);
-			if (current.kind === "missing" || current.version !== input.baseline.executionVersion) return {
-				kind: "version_mismatch",
-				key: "execution"
-			};
-			if (current.value.kind !== EXECUTION_RECORD_KIND) throw new Error("Yao registration execution record has an invalid kind");
-			const retained = current.value.value;
-			if (retained.credentialDigestSha256Hex !== execution.credentialDigestSha256Hex || retained.expiresAtMs !== execution.expiresAtMs) mutations.push({
-				key,
-				value: {
-					kind: EXECUTION_RECORD_KIND,
-					lifecycleId,
-					value: executionWithCurrentAuthority(retained, execution)
-				},
-				expectedVersion: current.version
-			});
-		}
-		const result = await this.putMany(mutations);
+		const result = await this.putMany(mutations, input.companionWrite);
 		if (result.kind === "version_mismatch") return {
 			kind: "version_mismatch",
-			key: result.key === "router-ab-ed25519-yao:shared" ? "shared" : result.key === routerAbEd25519YaoRegistrationExecutionRecordKeyV1(lifecycleId) ? "execution" : "ceremony"
+			key: result.key === "router-ab-ed25519-yao:shared" ? "shared" : "ceremony"
 		};
 		return {
 			kind: "stored",
 			sharedVersion: mutations[0]?.key === "router-ab-ed25519-yao:shared" ? findStoredVersion(result.versions, ROUTER_AB_ED25519_YAO_SHARED_STATE_RECORD_KEY_V1) : input.baseline.sharedVersion,
-			ceremonyVersion: findStoredVersion(result.versions, lifecycleId),
-			executionVersion: mutations.some(isRegistrationExecutionMutation) ? findStoredVersion(result.versions, routerAbEd25519YaoRegistrationExecutionRecordKeyV1(lifecycleId)) : input.baseline.executionVersion
+			ceremonyVersion: findStoredVersion(result.versions, lifecycleId)
 		};
 	}
-	async claimRegistrationExecution(input) {
-		const lifecycleId = requireLifecycleId(input.lifecycleId);
-		const key = routerAbEd25519YaoRegistrationExecutionRecordKeyV1(lifecycleId);
-		const admissionBindingJson = JSON.stringify(input.request.binding);
-		if (this.atomicPatch) {
-			const patch = await this.atomicPatch({
-				key,
-				expectedVersion: "1",
-				exactStringPredicates: [
-					{
-						jsonPath: "$.recordKind",
-						value: EXECUTION_RECORD_KIND
-					},
-					{
-						jsonPath: "$.lifecycleId",
-						value: lifecycleId
-					},
-					{
-						jsonPath: "$.execution.kind",
-						value: "ready"
-					},
-					{
-						jsonPath: "$.execution.admissionBindingJson",
-						value: admissionBindingJson
-					},
-					{
-						jsonPath: "$.execution.credentialDigestSha256Hex",
-						value: input.credentialDigestSha256Hex
-					}
-				],
-				unexpired: {
-					jsonPath: "$.execution.expiresAtMs",
-					nowMs: input.nowMs
-				},
-				patch: { execution: {
-					kind: "claimed",
-					requestDigestSha256Hex: input.requestDigestSha256Hex,
-					request: versionedJsonObject(input.request),
-					claimedAtMs: input.nowMs,
-					reconcileAfterMs: input.nowMs + EXECUTION_RECONCILIATION_LEASE_MS
-				} }
-			});
-			if (patch.kind === "stored") {
-				const stored = decodeAtomicPatchValue(patch.value);
-				if (stored?.kind !== EXECUTION_RECORD_KIND || stored.value.kind !== "claimed") throw new Error("Yao registration atomic claim returned an invalid execution record");
-				return {
-					kind: "claimed",
-					value: stored.value,
-					version: patch.version
-				};
-			}
-		}
-		return await this.reconcileRegistrationExecutionClaim(input);
-	}
-	async commitRegistrationExecution(input) {
-		const terminal = input.outcome.kind === "completed" ? {
-			...input.claimed,
-			kind: "completed",
-			result: input.outcome.result,
-			consumerBinding: null
-		} : {
-			...input.claimed,
-			kind: "failed",
-			failure: input.outcome.failure
-		};
-		const key = routerAbEd25519YaoRegistrationExecutionRecordKeyV1(input.claimed.lifecycleId);
-		if ((await this.putMany([{
-			key,
-			value: {
-				kind: EXECUTION_RECORD_KIND,
-				lifecycleId: input.claimed.lifecycleId,
-				value: terminal
-			},
-			expectedVersion: input.claimedVersion
-		}])).kind === "stored") return {
-			kind: "stored",
-			value: terminal.kind === "completed" ? terminal.result : terminal.failure
-		};
-		const current = await this.readRegistrationExecution(input.claimed.lifecycleId);
-		if (current?.kind === terminal.kind && current.requestDigestSha256Hex === input.claimed.requestDigestSha256Hex) {
-			if (terminal.kind === "completed" && current.kind === "completed" && sameActivationResult(current.result, terminal.result)) return {
-				kind: "stored",
-				value: current.result
-			};
-			if (terminal.kind === "failed" && current.kind === "failed" && sameRegistrationFailure(current.failure, terminal.failure)) return {
-				kind: "stored",
-				value: current.failure
-			};
-		}
-		return { kind: "uncertain" };
-	}
-	async consumeRegistrationExecution(input) {
-		const lifecycleId = requireLifecycleId(input.reference.lifecycleId);
-		const key = routerAbEd25519YaoRegistrationExecutionRecordKeyV1(lifecycleId);
-		for (let attempt = 0; attempt < 2; attempt += 1) {
-			const entry = readManyEntry(await this.readMany([key]), key);
-			if (entry.kind === "missing") return {
-				ok: false,
-				code: "unknown_registration",
-				message: "registration lifecycle was not found"
-			};
-			if (entry.value.kind !== EXECUTION_RECORD_KIND || entry.value.lifecycleId !== lifecycleId) throw new Error("Yao registration execution record does not match its lifecycle");
-			const execution = entry.value.value;
-			if (execution.kind !== "completed") return {
-				ok: false,
-				code: "registration_not_activated",
-				message: "registration lifecycle has no verified Yao activation"
-			};
-			if (!sameByteSequence(execution.result.binding.session_id, input.reference.sessionId)) return {
-				ok: false,
-				code: "activation_reference_mismatch",
-				message: "Yao activation reference does not match the admitted registration"
-			};
-			if (execution.consumerBinding !== null && execution.consumerBinding !== input.consumerBinding) return {
-				ok: false,
-				code: "activation_consumed",
-				message: "Yao activation was already consumed by wallet finalization"
-			};
-			if (execution.consumerBinding !== null) return {
-				ok: true,
-				activation: {
-					admissionRequest: execution.admissionRequest,
-					admissionReceipt: execution.admissionReceipt,
-					result: execution.result
-				}
-			};
-			const consumed = {
-				...execution,
-				consumerBinding: input.consumerBinding
-			};
-			if ((await this.putMany([{
-				key,
-				value: {
-					kind: EXECUTION_RECORD_KIND,
-					lifecycleId,
-					value: consumed
-				},
-				expectedVersion: entry.version
-			}])).kind === "stored") return {
-				ok: true,
-				activation: {
-					admissionRequest: execution.admissionRequest,
-					admissionReceipt: execution.admissionReceipt,
-					result: execution.result
-				}
-			};
-		}
-		throw new Error("Yao registration execution consumer claim did not converge");
-	}
-	async reconcileRegistrationExecutionClaim(input) {
-		const lifecycleId = requireLifecycleId(input.lifecycleId);
-		const key = routerAbEd25519YaoRegistrationExecutionRecordKeyV1(lifecycleId);
-		const entry = readManyEntry(await this.readMany([key]), key);
-		if (entry.kind === "missing") return {
-			kind: "rejected",
-			code: "unknown_registration",
-			message: "registration admission was not found"
-		};
-		if (entry.value.kind !== EXECUTION_RECORD_KIND || entry.value.lifecycleId !== lifecycleId) throw new Error("Yao registration execution record does not match its lifecycle");
-		const execution = entry.value.value;
-		if (!routerAbEd25519YaoExecutionMatchesAdmissionV1(input.request, execution.admissionReceipt)) return {
-			kind: "rejected",
-			code: "binding_mismatch",
-			message: "registration execution does not match the admitted binding"
-		};
-		if (execution.credentialDigestSha256Hex !== input.credentialDigestSha256Hex) return {
-			kind: "rejected",
-			code: "credential_rejected",
-			message: "registration execution credential does not match its admission subject"
-		};
-		if (execution.expiresAtMs <= input.nowMs) return {
-			kind: "rejected",
-			code: "credential_expired",
-			message: "registration intent credential is expired"
-		};
-		switch (execution.kind) {
-			case "completed": return execution.requestDigestSha256Hex === input.requestDigestSha256Hex ? {
-				kind: "completed",
-				value: execution.result
-			} : {
-				kind: "rejected",
-				code: "binding_mismatch",
-				message: "completed registration rejects a different execution payload"
-			};
-			case "failed": return execution.requestDigestSha256Hex === input.requestDigestSha256Hex ? {
-				kind: "failed",
-				value: execution.failure
-			} : {
-				kind: "rejected",
-				code: "binding_mismatch",
-				message: "failed registration rejects a different execution payload"
-			};
-			case "claimed":
-				if (execution.requestDigestSha256Hex !== input.requestDigestSha256Hex) return {
-					kind: "rejected",
-					code: "execution_in_progress",
-					message: "registration execution is already in progress"
-				};
-				if (execution.reconcileAfterMs > input.nowMs) return {
-					kind: "rejected",
-					code: "execution_in_progress",
-					message: "registration execution is already in progress"
-				};
-				return await this.renewRegistrationExecutionClaim(execution, entry.version, input.nowMs);
-			case "ready": {
-				const claimed = {
-					...execution,
-					kind: "claimed",
-					requestDigestSha256Hex: input.requestDigestSha256Hex,
-					request: input.request,
-					claimedAtMs: input.nowMs,
-					reconcileAfterMs: input.nowMs + EXECUTION_RECONCILIATION_LEASE_MS
-				};
-				const result = await this.putMany([{
-					key,
-					value: {
-						kind: EXECUTION_RECORD_KIND,
-						lifecycleId,
-						value: claimed
-					},
-					expectedVersion: entry.version
-				}]);
-				return result.kind === "stored" ? {
-					kind: "claimed",
-					value: claimed,
-					version: findStoredVersion(result.versions, key)
-				} : await this.reconcileRegistrationExecutionClaim(input);
-			}
-		}
-	}
-	async renewRegistrationExecutionClaim(execution, expectedVersion, nowMs) {
-		const renewed = {
-			...execution,
-			claimedAtMs: nowMs,
-			reconcileAfterMs: nowMs + EXECUTION_RECONCILIATION_LEASE_MS
-		};
-		const key = routerAbEd25519YaoRegistrationExecutionRecordKeyV1(execution.lifecycleId);
-		const result = await this.putMany([{
-			key,
-			value: {
-				kind: EXECUTION_RECORD_KIND,
-				lifecycleId: execution.lifecycleId,
-				value: renewed
-			},
-			expectedVersion
-		}]);
-		return result.kind === "stored" ? {
-			kind: "claimed",
-			value: renewed,
-			version: findStoredVersion(result.versions, key)
-		} : {
-			kind: "rejected",
-			code: "execution_in_progress",
-			message: "registration execution reconciliation was claimed concurrently"
-		};
-	}
-	async readRegistrationExecution(lifecycleId) {
-		const key = routerAbEd25519YaoRegistrationExecutionRecordKeyV1(lifecycleId);
-		const entry = readManyEntry(await this.readMany([key]), key);
-		if (entry.kind === "missing") return null;
-		if (entry.value.kind !== EXECUTION_RECORD_KIND || entry.value.lifecycleId !== lifecycleId) throw new Error("Yao registration execution record does not match its lifecycle");
-		return entry.value.value;
-	}
 };
-function isRegistrationExecutionMutation(mutation) {
-	return mutation.value.kind === EXECUTION_RECORD_KIND;
-}
-function executionWithCurrentAuthority(retained, authority) {
-	if (retained.lifecycleId !== authority.lifecycleId || retained.admissionBindingJson !== authority.admissionBindingJson) throw new Error("NEAR continuation changed its execution identity");
-	const common = {
-		lifecycleId: retained.lifecycleId,
-		admissionRequest: retained.admissionRequest,
-		admissionReceipt: retained.admissionReceipt,
-		admissionBindingJson: retained.admissionBindingJson,
-		credentialDigestSha256Hex: authority.credentialDigestSha256Hex,
-		expiresAtMs: authority.expiresAtMs
-	};
-	switch (retained.kind) {
-		case "ready": return {
-			kind: "ready",
-			...common
-		};
-		case "claimed": return {
-			kind: "claimed",
-			...common,
-			requestDigestSha256Hex: retained.requestDigestSha256Hex,
-			request: retained.request,
-			claimedAtMs: retained.claimedAtMs,
-			reconcileAfterMs: retained.reconcileAfterMs
-		};
-		case "completed": return {
-			kind: "completed",
-			...common,
-			requestDigestSha256Hex: retained.requestDigestSha256Hex,
-			request: retained.request,
-			claimedAtMs: retained.claimedAtMs,
-			reconcileAfterMs: retained.reconcileAfterMs,
-			result: retained.result,
-			consumerBinding: retained.consumerBinding
-		};
-		case "failed": return {
-			kind: "failed",
-			...common,
-			requestDigestSha256Hex: retained.requestDigestSha256Hex,
-			request: retained.request,
-			claimedAtMs: retained.claimedAtMs,
-			reconcileAfterMs: retained.reconcileAfterMs,
-			failure: retained.failure
-		};
-	}
-}
-function sameActivationResult(left, right) {
-	return sameRouterAbEd25519YaoActivationBindingV1(left.binding, right.binding) && sameActivationClientPackage(left.deriver_a_client_package, right.deriver_a_client_package) && sameActivationClientPackage(left.deriver_b_client_package, right.deriver_b_client_package) && sameActivationPublicReceipt(left.public_receipt, right.public_receipt);
-}
-function sameActivationClientPackage(left, right) {
-	return left.kind === right.kind && left.deriver === right.deriver && sameByteSequence(left.session, right.session) && sameByteSequence(left.transcript, right.transcript) && sameByteSequence(left.encapsulated_key, right.encapsulated_key) && sameByteSequence(left.ciphertext, right.ciphertext);
-}
-function sameActivationPublicReceipt(left, right) {
-	return sameByteSequence(left.transcript, right.transcript) && sameByteSequence(left.registered_public_key, right.registered_public_key) && sameByteSequence(left.joined_client_commitment, right.joined_client_commitment) && sameByteSequence(left.joined_signing_worker_commitment, right.joined_signing_worker_commitment) && sameByteSequence(left.signing_worker_verifying_share, right.signing_worker_verifying_share) && left.state_epoch === right.state_epoch && sameRouterAbMpcMaterialActivationRef(left.material_activation, right.material_activation);
-}
-function sameRegistrationFailure(left, right) {
-	return left.status === right.status && left.code === right.code && left.message === right.message;
-}
-function sameByteSequence(left, right) {
-	if (left.length !== right.length) return false;
-	for (let index = 0; index < left.length; index += 1) if (left[index] !== right[index]) return false;
-	return true;
-}
 function decodePartitionReadResult(result) {
 	if (result.kind === "missing") return result;
 	const parsed = parseRouterAbEd25519YaoProductRegistrationPartitionRecordV1(result.value);
@@ -593,12 +218,6 @@ function decodePartitionReadResult(result) {
 		version: result.version
 	};
 }
-function decodeAtomicPatchValue(value) {
-	if (value === void 0) return void 0;
-	const parsed = parseRouterAbEd25519YaoProductRegistrationPartitionRecordV1(value);
-	if (parsed === null) throw new Error("Router A/B atomic patch returned an invalid record");
-	return parsed;
-}
 function readManyEntry(entries, key) {
 	const entry = entries.find((candidate) => candidate.key === key);
 	if (!entry) throw new Error(`Router A/B batch read omitted ${key}`);
@@ -626,22 +245,6 @@ function readCeremonyRecord(result, lifecycleId) {
 		version: result.version
 	};
 }
-function readExecutionVersion(result, lifecycleId) {
-	if (result.kind === "missing") return null;
-	if (result.value.kind !== EXECUTION_RECORD_KIND || result.value.lifecycleId !== lifecycleId || result.value.value.lifecycleId !== lifecycleId) throw new Error("Router A/B execution record does not match its lifecycle key");
-	return result.version;
-}
-function registrationExecutionRecordFromState(state, lifecycleId) {
-	const sessionKey = state.registration.lifecycleSessions.get(lifecycleId);
-	const registration = sessionKey === void 0 ? void 0 : state.registration.states.get(sessionKey);
-	const authority = state.authorization.authorities.find((candidate) => candidate.admissionRequest.scope.lifecycle_id === lifecycleId);
-	if (!registration || registration.kind !== "admitted" || !authority) return null;
-	return buildRouterAbEd25519YaoRegistrationExecutionReadyRecordV1({
-		lifecycleId,
-		registration,
-		authority
-	});
-}
 function materializeState(shared, ceremony) {
 	return mergeRouterAbEd25519YaoProductRegistrationStatePartitionV1(createRouterAbEd25519YaoProductRegistrationStateV1(), {
 		kind: "router_ab_ed25519_yao_product_registration_state_partition_v1",
@@ -671,11 +274,6 @@ function hasExactObjectKeys(input, expectedFields) {
 	const expected = new Set(expectedFields);
 	return actualFields.every((field) => expected.has(field));
 }
-function versionedJsonObject(input) {
-	const value = JSON.parse(JSON.stringify(input));
-	if (!isVersionedJsonObject(value)) throw new Error("Router A/B execution request is not canonical JSON");
-	return value;
-}
 function isVersionedJsonObject(input) {
 	return typeof input === "object" && input !== null && !Array.isArray(input) && Object.values(input).every(isVersionedJsonValue);
 }
@@ -685,6 +283,6 @@ function isVersionedJsonValue(input) {
 	return isVersionedJsonObject(input);
 }
 //#endregion
-export { ROUTER_AB_ED25519_YAO_SHARED_STATE_RECORD_KEY_V1, createRouterAbEd25519YaoProductRegistrationPartitionedStateStoreV1, encodeRouterAbEd25519YaoProductRegistrationPartitionRecordV1, parseRouterAbEd25519YaoProductRegistrationPartitionRecordJsonV1, parseRouterAbEd25519YaoProductRegistrationPartitionRecordV1, routerAbEd25519YaoPartitionedStateAfterStoredCommitV1, sameRouterAbEd25519YaoSharedStateCanonicalEncodingV1 };
+export { ROUTER_AB_ED25519_YAO_SHARED_STATE_RECORD_KEY_V1, createRouterAbEd25519YaoProductRegistrationPartitionedStateStoreV1, encodeRouterAbEd25519YaoProductRegistrationPartitionRecordV1, parseRouterAbEd25519YaoProductRegistrationPartitionRecordJsonV1, parseRouterAbEd25519YaoProductRegistrationPartitionRecordV1, routerAbEd25519YaoAdmittedRegistrationAuthorityV1, routerAbEd25519YaoPartitionedStateAfterStoredCommitV1, sameRouterAbEd25519YaoSharedStateCanonicalEncodingV1 };
 
 //# sourceMappingURL=routerAbEd25519YaoProductRegistrationPartitionedStateStore.js.map

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

@@ -28,7 +28,8 @@ function partitionRouterAbEd25519YaoProductRegistrationStateV1(state, lifecycleI
 			registration: {
 				states: registrationStates,
 				lifecycleSessions: selectMapLifecycleEntry(state.registration.lifecycleSessions, normalizedLifecycleId),
-				admissionClaims: selectMapLifecycleEntry(state.registration.admissionClaims, normalizedLifecycleId)
+				admissionClaims: selectMapLifecycleEntry(state.registration.admissionClaims, normalizedLifecycleId),
+				dispatchRoots: selectMapLifecycleEntry(state.registration.dispatchRoots, normalizedLifecycleId)
 			},
 			authorization: { authorities: state.authorization.authorities.filter((authority) => authorityLifecycleId(authority) === normalizedLifecycleId) },
 			recovery: { recoveries: recoveryStates },
@@ -51,6 +52,9 @@ function mergeRouterAbEd25519YaoProductRegistrationStatePartitionV1(base, partit
 	const admissionClaims = new Map(base.registration.admissionClaims);
 	admissionClaims.delete(lifecycleId);
 	for (const [key, value] of partition.ceremony.registration.admissionClaims) admissionClaims.set(key, value);
+	const dispatchRoots = new Map(base.registration.dispatchRoots);
+	dispatchRoots.delete(lifecycleId);
+	for (const [key, value] of partition.ceremony.registration.dispatchRoots) dispatchRoots.set(key, value);
 	const authorities = base.authorization.authorities.filter((authority) => authorityLifecycleId(authority) !== lifecycleId);
 	authorities.push(...partition.ceremony.authorization.authorities);
 	const recoveries = replaceLifecycleEntries(base.recovery.recoveries, partition.ceremony.recovery.recoveries, recoveryStateLifecycleId, lifecycleId);
@@ -59,7 +63,8 @@ function mergeRouterAbEd25519YaoProductRegistrationStatePartitionV1(base, partit
 		registration: {
 			states: registrationStates,
 			lifecycleSessions,
-			admissionClaims: new Map(admissionClaims)
+			admissionClaims: new Map(admissionClaims),
+			dispatchRoots
 		},
 		authorization: { authorities },
 		recovery: {

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

@@ -22,7 +22,8 @@ function buildCommitInput(lifecycleId, loaded, state) {
 	return {
 		lifecycleId,
 		state,
-		baseline: loaded.baseline
+		baseline: loaded.baseline,
+		companionWrite: null
 	};
 }
 //#endregion