@seams/wallet-server 0.5.0

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

@@ -0,0 +1,143 @@
+import { createRouterAbEd25519YaoProductRegistrationStateFromPartsV1 } from "./routerAbEd25519YaoProductRegistration.js";
+//#region src/router/domains/ed25519Yao/capabilityLifecycle/routerAbEd25519YaoProductRegistrationPartitioning.ts
+const MAX_SHARED_RECOVERY_CAPABILITIES = 32;
+/**
+* Projects the tenant-wide state into shared and lifecycle-owned records.
+* Capability ownership and export nonce replay state deliberately stay in the
+* shared record; only lifecycle-indexed entries enter the ceremony record.
+*/
+function partitionRouterAbEd25519YaoProductRegistrationStateV1(state, lifecycleId) {
+	const normalizedLifecycleId = requireLifecycleId(lifecycleId);
+	const registrationStates = selectMapEntries(state.registration.states, normalizedLifecycleId, registrationStateLifecycleId);
+	const recoveryStates = selectMapEntries(state.recovery.recoveries, normalizedLifecycleId, recoveryStateLifecycleId);
+	const exportStates = selectMapEntries(state.export.exports, normalizedLifecycleId, exportStateLifecycleId);
+	return {
+		kind: "router_ab_ed25519_yao_product_registration_state_partition_v1",
+		lifecycleId: normalizedLifecycleId,
+		shared: {
+			kind: "router_ab_ed25519_yao_product_registration_shared_state_v1",
+			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)
+		},
+		ceremony: {
+			kind: "router_ab_ed25519_yao_product_registration_ceremony_state_v1",
+			lifecycleId: normalizedLifecycleId,
+			registration: {
+				states: registrationStates,
+				lifecycleSessions: selectMapLifecycleEntry(state.registration.lifecycleSessions, normalizedLifecycleId),
+				admissionClaims: selectMapLifecycleEntry(state.registration.admissionClaims, normalizedLifecycleId)
+			},
+			authorization: { authorities: state.authorization.authorities.filter((authority) => authorityLifecycleId(authority) === normalizedLifecycleId) },
+			recovery: { recoveries: recoveryStates },
+			export: { exports: exportStates }
+		}
+	};
+}
+/**
+* Applies one request's partition back onto a complete snapshot. Existing
+* lifecycle entries are replaced while unrelated ceremonies and all shared
+* records remain intact.
+*/
+function mergeRouterAbEd25519YaoProductRegistrationStatePartitionV1(base, partition) {
+	const lifecycleId = requireLifecycleId(partition.lifecycleId);
+	if (partition.ceremony.lifecycleId !== lifecycleId) throw new Error("Ed25519 Yao ceremony partition lifecycle IDs must match");
+	const registrationStates = replaceLifecycleEntries(base.registration.states, partition.ceremony.registration.states, registrationStateLifecycleId, lifecycleId);
+	const lifecycleSessions = new Map(base.registration.lifecycleSessions);
+	lifecycleSessions.delete(lifecycleId);
+	for (const [key, value] of partition.ceremony.registration.lifecycleSessions) lifecycleSessions.set(key, value);
+	const admissionClaims = new Map(base.registration.admissionClaims);
+	admissionClaims.delete(lifecycleId);
+	for (const [key, value] of partition.ceremony.registration.admissionClaims) admissionClaims.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);
+	const exports = replaceLifecycleEntries(base.export.exports, partition.ceremony.export.exports, exportStateLifecycleId, lifecycleId);
+	return createRouterAbEd25519YaoProductRegistrationStateFromPartsV1({
+		registration: {
+			states: registrationStates,
+			lifecycleSessions,
+			admissionClaims: new Map(admissionClaims)
+		},
+		authorization: { authorities },
+		recovery: {
+			capabilities: new Map(partition.shared.recoveryCapabilities),
+			identityCapabilities: new Map(partition.shared.recoveryIdentityCapabilities),
+			recoveries,
+			recoverySessions: new Map(partition.shared.recoverySessions)
+		},
+		export: {
+			exports,
+			authorizationNonces: new Set(partition.shared.exportAuthorizationNonces),
+			authorizationUncertain: new Set(partition.shared.exportAuthorizationUncertain)
+		}
+	});
+}
+function selectMapEntries(source, lifecycleId, lifecycleOf) {
+	const selected = /* @__PURE__ */ new Map();
+	for (const [key, value] of source) if (lifecycleOf(value) === lifecycleId) selected.set(key, value);
+	return selected;
+}
+function selectMapLifecycleEntry(source, lifecycleId) {
+	const value = source.get(lifecycleId);
+	return value === void 0 ? /* @__PURE__ */ new Map() : new Map([[lifecycleId, value]]);
+}
+function replaceLifecycleEntries(base, replacement, lifecycleOf, lifecycleId) {
+	const merged = /* @__PURE__ */ new Map();
+	for (const [key, value] of base) if (lifecycleOf(value) !== lifecycleId) merged.set(key, value);
+	for (const [key, value] of replacement) merged.set(key, value);
+	return merged;
+}
+function boundedRouterAbEd25519YaoProductRegistrationSharedStateV1(source) {
+	const recoveryCapabilities = boundedRecoveryCapabilities(source.recoveryCapabilities);
+	return {
+		kind: "router_ab_ed25519_yao_product_registration_shared_state_v1",
+		recoveryCapabilities,
+		recoveryIdentityCapabilities: retainedRecoveryIdentityCapabilities(source.recoveryIdentityCapabilities, recoveryCapabilities),
+		recoverySessions: new Map(source.recoverySessions),
+		exportAuthorizationNonces: new Set(source.exportAuthorizationNonces),
+		exportAuthorizationUncertain: new Set(source.exportAuthorizationUncertain)
+	};
+}
+function boundedRecoveryCapabilities(source) {
+	if (source.size <= MAX_SHARED_RECOVERY_CAPABILITIES) return new Map(source);
+	const entries = [...source.entries()];
+	const suspended = entries.filter(([, capability]) => capability.kind === "suspended");
+	const retained = /* @__PURE__ */ new Set();
+	for (const [key] of suspended.slice(-MAX_SHARED_RECOVERY_CAPABILITIES)) retained.add(key);
+	for (let index = entries.length - 1; index >= 0 && retained.size < MAX_SHARED_RECOVERY_CAPABILITIES; index -= 1) {
+		const entry = entries[index];
+		if (entry) retained.add(entry[0]);
+	}
+	const bounded = /* @__PURE__ */ new Map();
+	for (const [key, capability] of entries) if (retained.has(key)) bounded.set(key, capability);
+	return bounded;
+}
+function retainedRecoveryIdentityCapabilities(source, capabilities) {
+	const retained = /* @__PURE__ */ new Map();
+	for (const [identity, capabilityKey] of source) if (capabilities.has(capabilityKey)) retained.set(identity, capabilityKey);
+	return retained;
+}
+function registrationStateLifecycleId(state) {
+	return state.admissionRequest.scope.lifecycle_id;
+}
+function authorityLifecycleId(authority) {
+	return authority.admissionRequest.scope.lifecycle_id;
+}
+function recoveryStateLifecycleId(state) {
+	return state.context.admissionRequest.scope.lifecycle_id;
+}
+function exportStateLifecycleId(state) {
+	return state.request.scope.lifecycle_id;
+}
+function requireLifecycleId(value) {
+	const lifecycleId = value.trim();
+	if (!lifecycleId || lifecycleId.length > 256 || !/^[\x21-\x7e]+$/u.test(lifecycleId)) throw new Error("Ed25519 Yao ceremony lifecycle ID is invalid");
+	return lifecycleId;
+}
+//#endregion
+export { boundedRouterAbEd25519YaoProductRegistrationSharedStateV1, mergeRouterAbEd25519YaoProductRegistrationStatePartitionV1, partitionRouterAbEd25519YaoProductRegistrationStateV1 };
+
+//# sourceMappingURL=routerAbEd25519YaoProductRegistrationPartitioning.js.map

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

@@ -0,0 +1,270 @@
+import { ROUTER_AB_ED25519_YAO_EXPORT_ADMISSION_PATH_V1, ROUTER_AB_ED25519_YAO_EXPORT_EXECUTE_PATH_V1, ROUTER_AB_ED25519_YAO_RECOVERY_ACTIVATE_PATH_V1, ROUTER_AB_ED25519_YAO_RECOVERY_ADMISSION_PATH_V1, ROUTER_AB_ED25519_YAO_RECOVERY_EXECUTE_PATH_V1, ROUTER_AB_ED25519_YAO_REGISTRATION_ADMISSION_PATH_V1, ROUTER_AB_ED25519_YAO_REGISTRATION_EXECUTE_PATH_V1 } from "../../../../shared-ts/src/utils/routerAbEd25519Yao.js";
+import { parseRouterAbEd25519YaoProductRegistrationStateV1 } from "./routerAbEd25519YaoProductRegistration.js";
+//#region src/router/domains/ed25519Yao/capabilityLifecycle/routerAbEd25519YaoProductRegistrationPersistence.ts
+/** Bind the generic JSON adapter to the validated opaque ceremony key. */
+function createRouterAbEd25519YaoCeremonyStateStoreV1(store) {
+	return {
+		read: async (key) => await store.read(key.lifecycleId),
+		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 MAP_KIND = "map_v1";
+const SET_KIND = "set_v1";
+const BYTES_KIND = "bytes_v1";
+function encodeRouterAbEd25519YaoProductRegistrationStateV1(state) {
+	const encoded = encodeStateValue(state);
+	if (!isEncodedStateObject(encoded)) throw new Error("Ed25519 Yao product state must encode to a JSON object");
+	return {
+		kind: CODEC_KIND,
+		state: encoded
+	};
+}
+function parseRouterAbEd25519YaoProductRegistrationStateJsonV1(input) {
+	const record = exactRouterAbEd25519YaoProductRegistrationStateEnvelopeV1(input);
+	if (record === null || record.kind !== CODEC_KIND) return null;
+	const decoded = decodeRouterAbEd25519YaoProductRegistrationStateValueV1(record.state);
+	if (!decoded.ok || !isRouterAbEd25519YaoProductRegistrationJsonObjectV1(decoded.value)) return null;
+	const parsed = parseRouterAbEd25519YaoProductRegistrationStateV1(decoded.value);
+	return parsed.ok ? parsed.value : null;
+}
+function parseRouterAbEd25519YaoCeremonyKeyV1(input) {
+	const record = readRouterAbEd25519YaoCeremonyKeyObjectV1(input);
+	if (record === null) return null;
+	const lifecycleId = record.lifecycleId;
+	if (!isVisibleLifecycleId(lifecycleId)) return null;
+	return {
+		kind: "router_ab_ed25519_yao_ceremony_key_v1",
+		lifecycleId
+	};
+}
+/**
+* Resolve only fields owned by the route's wire contract. This function does
+* not recursively search arbitrary JSON, which prevents unrelated identifiers
+* from silently becoming persistence keys.
+*/
+async function resolveRouterAbEd25519YaoCeremonyKeyFromRequestV1(request) {
+	const pathname = new URL(request.url).pathname;
+	const source = ceremonyFieldSource(pathname);
+	if (source.kind === "none") return source;
+	let body;
+	try {
+		body = await request.clone().json();
+	} catch {
+		return {
+			kind: "invalid",
+			message: "Yao ceremony request body must be valid JSON"
+		};
+	}
+	const lifecycleId = readLifecycleId(body, source.field);
+	if (lifecycleId === null) return {
+		kind: "invalid",
+		message: "Yao ceremony lifecycle_id is required"
+	};
+	if (!isVisibleLifecycleId(lifecycleId)) return {
+		kind: "invalid",
+		message: "Yao ceremony lifecycle_id is invalid"
+	};
+	return {
+		kind: "ceremony",
+		value: {
+			kind: "router_ab_ed25519_yao_ceremony_key_v1",
+			lifecycleId
+		}
+	};
+}
+function ceremonyFieldSource(pathname) {
+	switch (pathname) {
+		case ROUTER_AB_ED25519_YAO_REGISTRATION_ADMISSION_PATH_V1:
+		case ROUTER_AB_ED25519_YAO_RECOVERY_ADMISSION_PATH_V1:
+		case ROUTER_AB_ED25519_YAO_EXPORT_ADMISSION_PATH_V1: return {
+			kind: "field",
+			field: "scope.lifecycle_id"
+		};
+		case ROUTER_AB_ED25519_YAO_REGISTRATION_EXECUTE_PATH_V1:
+		case ROUTER_AB_ED25519_YAO_RECOVERY_EXECUTE_PATH_V1:
+		case ROUTER_AB_ED25519_YAO_RECOVERY_ACTIVATE_PATH_V1: return {
+			kind: "field",
+			field: "binding.lifecycle.lifecycle_id"
+		};
+		case ROUTER_AB_ED25519_YAO_EXPORT_EXECUTE_PATH_V1: return {
+			kind: "field",
+			field: "binding.ceremony.lifecycle.lifecycle_id"
+		};
+		default: return /^\/wallets\/[^/]+\/signers\/finalize$/u.test(pathname) ? {
+			kind: "field",
+			field: "ed25519.activationReference.lifecycle_id"
+		} : { kind: "none" };
+	}
+}
+function readLifecycleId(input, field) {
+	if (!isRouterAbEd25519YaoProductRegistrationJsonObjectV1(input)) return null;
+	switch (field) {
+		case "scope.lifecycle_id": return readRouterAbEd25519YaoProductRegistrationLifecycleStringV1(input.scope);
+		case "binding.lifecycle.lifecycle_id": return readRouterAbEd25519YaoProductRegistrationLifecycleStringV1(isRouterAbEd25519YaoProductRegistrationJsonObjectV1(input.binding) ? input.binding.lifecycle : null);
+		case "binding.ceremony.lifecycle.lifecycle_id": {
+			const binding = isRouterAbEd25519YaoProductRegistrationJsonObjectV1(input.binding) ? input.binding : null;
+			const ceremony = isRouterAbEd25519YaoProductRegistrationJsonObjectV1(binding?.ceremony) ? binding.ceremony : null;
+			return readRouterAbEd25519YaoProductRegistrationLifecycleStringV1(isRouterAbEd25519YaoProductRegistrationJsonObjectV1(ceremony?.lifecycle) ? ceremony.lifecycle : null);
+		}
+		case "ed25519.activationReference.lifecycle_id": {
+			const ed25519 = isRouterAbEd25519YaoProductRegistrationJsonObjectV1(input.ed25519) ? input.ed25519 : null;
+			return readRouterAbEd25519YaoProductRegistrationLifecycleStringV1(isRouterAbEd25519YaoProductRegistrationJsonObjectV1(ed25519?.activationReference) ? ed25519.activationReference : null);
+		}
+		default: return assertNever(field);
+	}
+}
+function readRouterAbEd25519YaoProductRegistrationLifecycleStringV1(input) {
+	if (!isRouterAbEd25519YaoProductRegistrationJsonObjectV1(input) || typeof input.lifecycle_id !== "string") return null;
+	return input.lifecycle_id;
+}
+function isVisibleLifecycleId(value) {
+	return typeof value === "string" && value.length > 0 && value.length <= 256 && /^[\x21-\x7e]+$/u.test(value);
+}
+function encodeStateValue(value) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) throw new Error("Ed25519 Yao state contains a non-finite number");
+		return value;
+	}
+	if (value instanceof Uint8Array) return {
+		__seamsType: BYTES_KIND,
+		values: Array.from(value)
+	};
+	if (value instanceof Map) {
+		const entries = [];
+		for (const [key, entry] of value) {
+			if (typeof key !== "string") throw new Error("Ed25519 Yao state Map keys must be strings");
+			entries.push([key, encodeStateValue(entry)]);
+		}
+		return {
+			__seamsType: MAP_KIND,
+			entries
+		};
+	}
+	if (value instanceof Set) return {
+		__seamsType: SET_KIND,
+		values: Array.from(value, encodeStateValue)
+	};
+	if (Array.isArray(value)) return value.map(encodeStateValue);
+	if (isRouterAbEd25519YaoProductRegistrationJsonObjectV1(value)) {
+		const object = {};
+		for (const [key, entry] of Object.entries(value)) object[key] = encodeStateValue(entry);
+		return object;
+	}
+	throw new Error(`Ed25519 Yao state contains unsupported value: ${typeof value}`);
+}
+function decodeRouterAbEd25519YaoProductRegistrationStateValueV1(value) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return {
+		ok: true,
+		value
+	};
+	if (typeof value === "number") return Number.isFinite(value) ? {
+		ok: true,
+		value
+	} : { ok: false };
+	if (Array.isArray(value)) {
+		const decoded = [];
+		for (const entry of value) {
+			const result = decodeRouterAbEd25519YaoProductRegistrationStateValueV1(entry);
+			if (!result.ok) return result;
+			decoded.push(result.value);
+		}
+		return {
+			ok: true,
+			value: decoded
+		};
+	}
+	if (!isRouterAbEd25519YaoProductRegistrationJsonObjectV1(value)) return { ok: false };
+	if (Object.hasOwn(value, "__seamsType")) switch (value.__seamsType) {
+		case BYTES_KIND: return decodeRouterAbEd25519YaoProductRegistrationBytesV1(value);
+		case MAP_KIND: return decodeRouterAbEd25519YaoProductRegistrationMapV1(value);
+		case SET_KIND: return decodeRouterAbEd25519YaoProductRegistrationSetV1(value);
+		default: return { ok: false };
+	}
+	const object = {};
+	for (const [key, entry] of Object.entries(value)) {
+		const decoded = decodeRouterAbEd25519YaoProductRegistrationStateValueV1(entry);
+		if (!decoded.ok) return decoded;
+		object[key] = decoded.value;
+	}
+	return {
+		ok: true,
+		value: object
+	};
+}
+function decodeRouterAbEd25519YaoProductRegistrationBytesV1(value) {
+	if (!hasExactRouterAbEd25519YaoProductRegistrationJsonKeys(value, ["__seamsType", "values"]) || value.__seamsType !== BYTES_KIND || !Array.isArray(value.values)) return { ok: false };
+	const bytes = [];
+	for (const entry of value.values) {
+		if (typeof entry !== "number" || !Number.isSafeInteger(entry) || entry < 0 || entry > 255) return { ok: false };
+		bytes.push(entry);
+	}
+	return {
+		ok: true,
+		value: Uint8Array.from(bytes)
+	};
+}
+function decodeRouterAbEd25519YaoProductRegistrationMapV1(value) {
+	if (!hasExactRouterAbEd25519YaoProductRegistrationJsonKeys(value, ["__seamsType", "entries"]) || value.__seamsType !== MAP_KIND || !Array.isArray(value.entries)) return { ok: false };
+	const map = /* @__PURE__ */ new Map();
+	const keys = /* @__PURE__ */ new Set();
+	for (const entry of value.entries) {
+		if (!Array.isArray(entry) || entry.length !== 2 || typeof entry[0] !== "string") return { ok: false };
+		if (keys.has(entry[0])) return { ok: false };
+		keys.add(entry[0]);
+		const decoded = decodeRouterAbEd25519YaoProductRegistrationStateValueV1(entry[1]);
+		if (!decoded.ok) return decoded;
+		map.set(entry[0], decoded.value);
+	}
+	return {
+		ok: true,
+		value: map
+	};
+}
+function decodeRouterAbEd25519YaoProductRegistrationSetV1(value) {
+	if (!hasExactRouterAbEd25519YaoProductRegistrationJsonKeys(value, ["__seamsType", "values"]) || value.__seamsType !== SET_KIND || !Array.isArray(value.values)) return { ok: false };
+	const set = /* @__PURE__ */ new Set();
+	const encodedEntries = /* @__PURE__ */ new Set();
+	for (const entry of value.values) {
+		let encoded;
+		try {
+			encoded = JSON.stringify(entry);
+		} catch {
+			return { ok: false };
+		}
+		if (encodedEntries.has(encoded)) return { ok: false };
+		encodedEntries.add(encoded);
+		const decoded = decodeRouterAbEd25519YaoProductRegistrationStateValueV1(entry);
+		if (!decoded.ok) return decoded;
+		set.add(decoded.value);
+	}
+	return {
+		ok: true,
+		value: set
+	};
+}
+function isEncodedStateObject(value) {
+	return isRouterAbEd25519YaoProductRegistrationJsonObjectV1(value) && !Object.hasOwn(value, "__seamsType");
+}
+function isRouterAbEd25519YaoProductRegistrationJsonObjectV1(input) {
+	return typeof input === "object" && input !== null && !Array.isArray(input);
+}
+function readRouterAbEd25519YaoCeremonyKeyObjectV1(input) {
+	return isRouterAbEd25519YaoProductRegistrationJsonObjectV1(input) ? input : null;
+}
+function exactRouterAbEd25519YaoProductRegistrationStateEnvelopeV1(input) {
+	if (!isRouterAbEd25519YaoProductRegistrationJsonObjectV1(input)) return null;
+	return hasExactRouterAbEd25519YaoProductRegistrationJsonKeys(input, ["kind", "state"]) ? input : null;
+}
+function hasExactRouterAbEd25519YaoProductRegistrationJsonKeys(input, fields) {
+	const actual = Object.keys(input);
+	return actual.length === fields.length && actual.every((field) => fields.some((expectedField) => expectedField === field));
+}
+function assertNever(value) {
+	throw new Error(`Unsupported Ed25519 Yao ceremony field: ${String(value)}`);
+}
+//#endregion
+export { createRouterAbEd25519YaoCeremonyStateStoreV1, encodeRouterAbEd25519YaoProductRegistrationStateV1, parseRouterAbEd25519YaoCeremonyKeyV1, parseRouterAbEd25519YaoProductRegistrationStateJsonV1, resolveRouterAbEd25519YaoCeremonyKeyFromRequestV1 };
+
+//# sourceMappingURL=routerAbEd25519YaoProductRegistrationPersistence.js.map

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

@@ -0,0 +1,31 @@
+//#region src/router/domains/ed25519Yao/capabilityLifecycle/routerAbEd25519YaoProductRegistrationRequestScopedRunner.ts
+/**
+* Runs one request against a request-local product-state snapshot.
+*
+* The executor owns the Yao-specific state transition. Non-Yao request
+* handling stays outside this boundary until the Gateway route can prove an
+* equivalent side-effect and commit boundary.
+*/
+async function runRouterAbEd25519YaoProductRegistrationRequestScopedV1(input) {
+	const loaded = await input.store.load(input.lifecycleId);
+	const execution = await input.execute(loaded.state);
+	const committed = await input.store.commit(buildCommitInput(input.lifecycleId, loaded, execution.state));
+	if (committed.kind === "version_mismatch") return committed;
+	return {
+		kind: "committed",
+		value: execution.value,
+		sharedVersion: committed.sharedVersion,
+		ceremonyVersion: committed.ceremonyVersion
+	};
+}
+function buildCommitInput(lifecycleId, loaded, state) {
+	return {
+		lifecycleId,
+		state,
+		baseline: loaded.baseline
+	};
+}
+//#endregion
+export { runRouterAbEd25519YaoProductRegistrationRequestScopedV1 };
+
+//# sourceMappingURL=routerAbEd25519YaoProductRegistrationRequestScopedRunner.js.map

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

@@ -0,0 +1,162 @@
+import { InMemoryRouterAbEd25519YaoRegistrationService } from "../registration/routerAbEd25519YaoRegistration.js";
+import { InMemoryRouterAbEd25519YaoRegistrationIntentAuthorizationAdapter } from "../registration/routerAbEd25519YaoRegistrationIntentAuthorization.js";
+import { InMemoryRouterAbEd25519YaoRecoveryService } from "../recovery/routerAbEd25519YaoRecovery.js";
+import { routerAbEd25519YaoPersistedCapabilityMatchesLookupV1 } from "./routerAbEd25519YaoProductRegistration.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,
+	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
+* deterministic state transition. External account, wallet, and session
+* effects stay outside this adapter and are never repeated here.
+*/
+function createRouterAbEd25519YaoProductRegistrationRequestScopedRuntimeV1(input) {
+	return new RouterAbEd25519YaoProductRegistrationRequestScopedRuntime(input);
+}
+var RouterAbEd25519YaoProductRegistrationRequestScopedRuntime = class {
+	constructor(input) {
+		this.input = input;
+		this.kind = "router_ab_ed25519_yao_product_registration_runtime_v1";
+		this.signingWorkerId = input.signingWorkerId.trim();
+		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));
+	}
+	async bindAndAdmitVerifiedRegistration(input) {
+		return await bindAndAdmitVerifiedRegistration({
+			input,
+			store: this.input.store,
+			backend: this.input.registrationBackend
+		});
+	}
+	async consumeActivated(input) {
+		return await this.input.store.consumeRegistrationExecution(input);
+	}
+	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));
+	}
+	async resolveActiveCapability(input) {
+		const result = recoveryService((await this.input.store.load(SHARED_CAPABILITY_READ_LIFECYCLE_ID)).state).resolveActiveCapability(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;
+		const installed = await this.installPersistedActiveCapability(persisted);
+		if (!installed.ok) return {
+			ok: false,
+			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");
+	}
+};
+async function bindAndAdmitVerifiedRegistration(input) {
+	const lifecycleId = input.input.admissionRequest.scope.lifecycle_id;
+	let backendResult = 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);
+		if (!bound.ok) return bound;
+		const service = new InMemoryRouterAbEd25519YaoRegistrationService(input.backend, loaded.state.registration);
+		const preparation = service.prepareAdmit(input.input.admissionRequest);
+		if (preparation.kind === "completed") return {
+			ok: true,
+			status: 200,
+			value: preparation.value
+		};
+		if (preparation.kind === "failed") return preparation.failure;
+		if (backendResult === null) try {
+			backendResult = await input.backend.admit(input.input.admissionRequest);
+		} catch (error) {
+			return {
+				ok: false,
+				status: 503,
+				code: "admission_uncertain",
+				message: error instanceof Error ? error.message : String(error)
+			};
+		}
+		const admitted = service.commitAdmit({
+			request: input.input.admissionRequest,
+			claim: preparation.claim,
+			outcome: {
+				kind: "backend_response",
+				result: backendResult
+			}
+		});
+		if (!admitted.ok) return admitted;
+		if ((await input.store.commit(commitInput(lifecycleId, loaded))).kind === "stored") return admitted;
+	}
+	return {
+		ok: false,
+		status: 503,
+		code: "admission_uncertain",
+		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
+	};
+}
+async function rejectUnusedBackend() {
+	throw new Error("Request-scoped product runtime invoked an unavailable protocol backend");
+}
+//#endregion
+export { createRouterAbEd25519YaoProductRegistrationRequestScopedRuntimeV1 };
+
+//# sourceMappingURL=routerAbEd25519YaoProductRegistrationRequestScopedRuntime.js.map