@seams/wallet-server 0.5.0

package/dist/types/wallet-server/src/router/domains/ed25519Yao/registration/routerAbEd25519YaoRegistration.d.ts

@@ -0,0 +1,200 @@
+import { type RouterAbEd25519YaoActivationAdmissionReceiptV1, type RouterAbEd25519YaoActivationExecuteRequestV1, type RouterAbEd25519YaoActivationResultV1, type RouterAbEd25519YaoRegistrationAdmissionRequestV1, type RouterAbEd25519YaoBytes32V1 } from '../../../../../../shared-ts/src/utils/routerAbEd25519Yao';
+import { type RouterAbTraceContextV1 } from '../../../../../../shared-ts/src/utils/routerAbTraceContext';
+import { type RouterApiModule } from '../../../framework/modules';
+import type { RouterAbEd25519YaoRegistrationExecuteAdmissionContextV1 } from '../routerAbEd25519YaoGatewayEnvelope';
+type RouterAbEd25519YaoRegistrationAdmissionReceiptV1 = RouterAbEd25519YaoActivationAdmissionReceiptV1<'registration'>;
+export type RouterAbEd25519YaoRegistrationExecuteRequestV1 = RouterAbEd25519YaoActivationExecuteRequestV1<'registration'>;
+export type RouterAbEd25519YaoRegistrationResultV1 = RouterAbEd25519YaoActivationResultV1<'registration'>;
+export type RouterAbEd25519YaoRegistrationFailureCode = 'invalid_backend_response' | 'admission_failed' | 'admission_in_progress' | 'admission_uncertain' | 'unknown_registration' | 'binding_mismatch' | 'execution_in_progress' | 'execution_failed' | 'ceremony_expired';
+export type RouterAbEd25519YaoRegistrationFailure = {
+    ok: false;
+    status: 400 | 401 | 403 | 404 | 408 | 409 | 429 | 500 | 502 | 503;
+    code: RouterAbEd25519YaoRegistrationFailureCode;
+    message: string;
+};
+export type RouterAbEd25519YaoRegistrationServiceResult<T> = {
+    ok: true;
+    status: 200;
+    value: T;
+} | RouterAbEd25519YaoRegistrationFailure;
+export type RouterAbEd25519YaoRegistrationBackendFailure = {
+    ok: false;
+    status: 400 | 408 | 409 | 429 | 500 | 502 | 503;
+    code: string;
+    message: string;
+};
+export type RouterAbEd25519YaoRegistrationBackendResult = {
+    ok: true;
+    body: unknown;
+} | RouterAbEd25519YaoRegistrationBackendFailure;
+export interface RouterAbEd25519YaoRegistrationBackend {
+    takeLastRouterServerTiming?(): string | null;
+    admit(request: RouterAbEd25519YaoRegistrationAdmissionRequestV1, traceContext?: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRegistrationBackendResult> | RouterAbEd25519YaoRegistrationBackendResult;
+    execute(request: RouterAbEd25519YaoRegistrationExecuteRequestV1, admissionRequest: RouterAbEd25519YaoRegistrationExecuteAdmissionContextV1, traceContext?: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRegistrationBackendResult> | RouterAbEd25519YaoRegistrationBackendResult;
+}
+export interface RouterAbEd25519YaoRegistrationService {
+    admit(request: RouterAbEd25519YaoRegistrationAdmissionRequestV1, traceContext?: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRegistrationServiceResult<RouterAbEd25519YaoRegistrationAdmissionReceiptV1>>;
+    execute(request: RouterAbEd25519YaoRegistrationExecuteRequestV1, traceContext?: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRegistrationServiceResult<RouterAbEd25519YaoRegistrationResultV1>>;
+}
+export type RouterAbEd25519YaoRegistrationAdmissionClaimV1 = {
+    readonly kind: 'router_ab_ed25519_yao_registration_admission_claim_v1';
+    readonly lifecycleId: string;
+    readonly admissionFingerprint: string;
+};
+export type RouterAbEd25519YaoRegistrationAdmissionPreparationV1 = {
+    readonly kind: 'claimed';
+    readonly claim: RouterAbEd25519YaoRegistrationAdmissionClaimV1;
+} | {
+    readonly kind: 'completed';
+    readonly value: RouterAbEd25519YaoRegistrationAdmissionReceiptV1;
+} | {
+    readonly kind: 'failed';
+    readonly failure: RouterAbEd25519YaoRegistrationFailure;
+};
+export type RouterAbEd25519YaoRegistrationAdmissionCommitInputV1 = {
+    readonly request: RouterAbEd25519YaoRegistrationAdmissionRequestV1;
+    readonly claim: RouterAbEd25519YaoRegistrationAdmissionClaimV1;
+    readonly outcome: {
+        readonly kind: 'backend_response';
+        readonly result: RouterAbEd25519YaoRegistrationBackendResult;
+    } | {
+        readonly kind: 'backend_uncertain';
+        readonly message: string;
+    };
+};
+export interface RouterAbEd25519YaoRegistrationAdmissionBoundaryV1 {
+    prepareAdmit(request: RouterAbEd25519YaoRegistrationAdmissionRequestV1): RouterAbEd25519YaoRegistrationAdmissionPreparationV1;
+    commitAdmit(input: RouterAbEd25519YaoRegistrationAdmissionCommitInputV1): RouterAbEd25519YaoRegistrationServiceResult<RouterAbEd25519YaoRegistrationAdmissionReceiptV1>;
+}
+export type RouterAbEd25519YaoRegistrationExecuteClaimV1 = {
+    readonly kind: 'router_ab_ed25519_yao_registration_execute_claim_v1';
+    readonly lifecycleId: string;
+    readonly sessionId: string;
+    readonly executeFingerprint: string;
+    readonly admissionRequest: RouterAbEd25519YaoRegistrationExecuteAdmissionContextV1;
+};
+export type RouterAbEd25519YaoRegistrationExecutePreparationV1 = {
+    readonly kind: 'claimed';
+    readonly claim: RouterAbEd25519YaoRegistrationExecuteClaimV1;
+} | {
+    readonly kind: 'completed';
+    readonly value: RouterAbEd25519YaoRegistrationResultV1;
+} | {
+    readonly kind: 'failed';
+    readonly failure: RouterAbEd25519YaoRegistrationFailure;
+};
+export type RouterAbEd25519YaoRegistrationExecuteCommitInputV1 = {
+    readonly request: RouterAbEd25519YaoRegistrationExecuteRequestV1;
+    readonly claim: RouterAbEd25519YaoRegistrationExecuteClaimV1;
+    readonly outcome: {
+        readonly kind: 'backend_response';
+        readonly result: RouterAbEd25519YaoRegistrationBackendResult;
+    } | {
+        readonly kind: 'backend_uncertain';
+        readonly message: string;
+    };
+};
+export interface RouterAbEd25519YaoRegistrationExecuteBoundaryV1 {
+    prepareExecute(request: RouterAbEd25519YaoRegistrationExecuteRequestV1): RouterAbEd25519YaoRegistrationExecutePreparationV1;
+    commitExecute(input: RouterAbEd25519YaoRegistrationExecuteCommitInputV1): RouterAbEd25519YaoRegistrationServiceResult<RouterAbEd25519YaoRegistrationResultV1>;
+}
+export type RouterAbEd25519YaoRegistrationAuthorizationInput = {
+    kind: 'admit';
+    request: Request;
+    body: RouterAbEd25519YaoRegistrationAdmissionRequestV1;
+} | {
+    kind: 'execute';
+    request: Request;
+    body: RouterAbEd25519YaoRegistrationExecuteRequestV1;
+};
+export type RouterAbEd25519YaoRegistrationAuthorizationResult = {
+    ok: true;
+} | {
+    ok: false;
+    status: 401 | 403 | 409 | 429 | 503;
+    code: string;
+    message: string;
+};
+export interface RouterAbEd25519YaoRegistrationAuthorizationAdapter {
+    authorize(input: RouterAbEd25519YaoRegistrationAuthorizationInput): Promise<RouterAbEd25519YaoRegistrationAuthorizationResult> | RouterAbEd25519YaoRegistrationAuthorizationResult;
+}
+type RegistrationAdmittedState = {
+    kind: 'admitted';
+    admissionRequest: RouterAbEd25519YaoRegistrationAdmissionRequestV1;
+    admissionReceipt: RouterAbEd25519YaoRegistrationAdmissionReceiptV1;
+};
+type RegistrationExecutingState = {
+    kind: 'executing';
+    admissionRequest: RouterAbEd25519YaoRegistrationAdmissionRequestV1;
+    admissionReceipt: RouterAbEd25519YaoRegistrationAdmissionReceiptV1;
+    executeFingerprint: string;
+};
+type RegistrationActivatedState = {
+    kind: 'activated';
+    admissionRequest: RouterAbEd25519YaoRegistrationAdmissionRequestV1;
+    admissionReceipt: RouterAbEd25519YaoRegistrationAdmissionReceiptV1;
+    executeFingerprint: string;
+    result: RouterAbEd25519YaoRegistrationResultV1;
+    activationConsumerBinding: string | null;
+};
+type RegistrationFailedState = {
+    kind: 'failed';
+    admissionRequest: RouterAbEd25519YaoRegistrationAdmissionRequestV1;
+    admissionReceipt: RouterAbEd25519YaoRegistrationAdmissionReceiptV1;
+    executeFingerprint: string;
+    failure: RouterAbEd25519YaoRegistrationFailure;
+};
+type RegistrationLifecycleState = RegistrationAdmittedState | RegistrationExecutingState | RegistrationActivatedState | RegistrationFailedState;
+export declare class InMemoryRouterAbEd25519YaoRegistrationStateV1 {
+    readonly states: Map<string, RegistrationLifecycleState>;
+    readonly lifecycleSessions: Map<string, string>;
+    readonly admissionClaims: Map<string, RouterAbEd25519YaoRegistrationAdmissionClaimV1>;
+}
+export type RouterAbEd25519YaoActivationReferenceV1 = {
+    lifecycleId: string;
+    sessionId: RouterAbEd25519YaoBytes32V1;
+};
+export type RouterAbEd25519YaoActivationConsumptionRequestV1 = {
+    reference: RouterAbEd25519YaoActivationReferenceV1;
+    consumerBinding: string;
+};
+export type RouterAbEd25519YaoActivatedRegistrationV1 = {
+    admissionRequest: RouterAbEd25519YaoRegistrationAdmissionRequestV1;
+    admissionReceipt: RouterAbEd25519YaoRegistrationAdmissionReceiptV1;
+    result: RouterAbEd25519YaoRegistrationResultV1;
+};
+export type RouterAbEd25519YaoActivationConsumptionResultV1 = {
+    ok: true;
+    activation: RouterAbEd25519YaoActivatedRegistrationV1;
+} | {
+    ok: false;
+    code: 'unknown_registration' | 'registration_not_activated' | 'activation_reference_mismatch' | 'activation_consumed';
+    message: string;
+};
+export interface RouterAbEd25519YaoActivationConsumerV1 {
+    consumeActivated(request: RouterAbEd25519YaoActivationConsumptionRequestV1): Promise<RouterAbEd25519YaoActivationConsumptionResultV1> | RouterAbEd25519YaoActivationConsumptionResultV1;
+}
+export declare function encodeRouterAbEd25519YaoRegistrationAdmissionFingerprintV1(request: RouterAbEd25519YaoRegistrationAdmissionRequestV1): string;
+export declare function routerAbEd25519YaoExecutionMatchesAdmissionV1(request: RouterAbEd25519YaoRegistrationExecuteRequestV1, receipt: RouterAbEd25519YaoRegistrationAdmissionReceiptV1): boolean;
+export declare function routerAbEd25519YaoResultMatchesExecutionV1(request: RouterAbEd25519YaoRegistrationExecuteRequestV1, result: RouterAbEd25519YaoRegistrationResultV1): boolean;
+export declare function createRouterAbEd25519YaoRegistrationModule(input: {
+    service: RouterAbEd25519YaoRegistrationService;
+    authorization: RouterAbEd25519YaoRegistrationAuthorizationAdapter;
+}): RouterApiModule;
+export declare class InMemoryRouterAbEd25519YaoRegistrationService implements RouterAbEd25519YaoRegistrationService, RouterAbEd25519YaoRegistrationAdmissionBoundaryV1, RouterAbEd25519YaoRegistrationExecuteBoundaryV1, RouterAbEd25519YaoActivationConsumerV1 {
+    private readonly backend;
+    private readonly states;
+    private readonly lifecycleSessions;
+    private readonly admissionClaims;
+    constructor(backend: RouterAbEd25519YaoRegistrationBackend, state?: InMemoryRouterAbEd25519YaoRegistrationStateV1);
+    admit(request: RouterAbEd25519YaoRegistrationAdmissionRequestV1, traceContext?: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRegistrationServiceResult<RouterAbEd25519YaoRegistrationAdmissionReceiptV1>>;
+    prepareAdmit(request: RouterAbEd25519YaoRegistrationAdmissionRequestV1): RouterAbEd25519YaoRegistrationAdmissionPreparationV1;
+    commitAdmit(input: RouterAbEd25519YaoRegistrationAdmissionCommitInputV1): RouterAbEd25519YaoRegistrationServiceResult<RouterAbEd25519YaoRegistrationAdmissionReceiptV1>;
+    execute(request: RouterAbEd25519YaoRegistrationExecuteRequestV1, traceContext?: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRegistrationServiceResult<RouterAbEd25519YaoRegistrationResultV1>>;
+    prepareExecute(request: RouterAbEd25519YaoRegistrationExecuteRequestV1): RouterAbEd25519YaoRegistrationExecutePreparationV1;
+    commitExecute(input: RouterAbEd25519YaoRegistrationExecuteCommitInputV1): RouterAbEd25519YaoRegistrationServiceResult<RouterAbEd25519YaoRegistrationResultV1>;
+    consumeActivated(request: RouterAbEd25519YaoActivationConsumptionRequestV1): RouterAbEd25519YaoActivationConsumptionResultV1;
+    private storeFailure;
+}
+export {};
+//# sourceMappingURL=routerAbEd25519YaoRegistration.d.ts.map

package/dist/types/wallet-server/src/router/domains/ed25519Yao/registration/routerAbEd25519YaoRegistrationExecutionRecord.d.ts

@@ -0,0 +1,70 @@
+import { type RouterAbEd25519YaoActivationAdmissionReceiptV1, type RouterAbEd25519YaoActivationExecuteRequestV1, type RouterAbEd25519YaoActivationResultV1, type RouterAbEd25519YaoRegistrationAdmissionRequestV1 } from '../../../../../../shared-ts/src/utils/routerAbEd25519Yao';
+import type { VersionedJsonObject } from '../../../framework/versionedJsonRecordStore';
+import type { RouterAbEd25519YaoRegistrationFailure } from './routerAbEd25519YaoRegistration';
+import type { InMemoryRouterAbEd25519YaoRegistrationStateV1 } from './routerAbEd25519YaoRegistration';
+import type { InMemoryRouterAbEd25519YaoRegistrationIntentAuthorizationStateV1 } from './routerAbEd25519YaoRegistrationIntentAuthorization';
+export declare const ROUTER_AB_ED25519_YAO_REGISTRATION_EXECUTION_RECORD_KIND_V1 = "router_ab_ed25519_yao_registration_execution_record_v1";
+type AdmissionReceipt = RouterAbEd25519YaoActivationAdmissionReceiptV1<'registration'>;
+type ExecuteRequest = RouterAbEd25519YaoActivationExecuteRequestV1<'registration'>;
+type ActivationResult = RouterAbEd25519YaoActivationResultV1<'registration'>;
+type RegistrationExecutionAuthority = {
+    readonly lifecycleId: string;
+    readonly admissionRequest: RouterAbEd25519YaoRegistrationAdmissionRequestV1;
+    readonly admissionReceipt: AdmissionReceipt;
+    readonly admissionBindingJson: string;
+    readonly credentialDigestSha256Hex: string;
+    readonly expiresAtMs: number;
+};
+export type RouterAbEd25519YaoRegistrationExecutionRecordV1 = (RegistrationExecutionAuthority & {
+    readonly kind: 'ready';
+    readonly requestDigestSha256Hex?: never;
+    readonly request?: never;
+    readonly result?: never;
+    readonly failure?: never;
+    readonly consumerBinding?: never;
+}) | (RegistrationExecutionAuthority & {
+    readonly kind: 'claimed';
+    readonly requestDigestSha256Hex: string;
+    readonly request: ExecuteRequest;
+    readonly claimedAtMs: number;
+    readonly reconcileAfterMs: number;
+    readonly result?: never;
+    readonly failure?: never;
+    readonly consumerBinding?: never;
+}) | (RegistrationExecutionAuthority & {
+    readonly kind: 'completed';
+    readonly requestDigestSha256Hex: string;
+    readonly request: ExecuteRequest;
+    readonly claimedAtMs: number;
+    readonly reconcileAfterMs: number;
+    readonly result: ActivationResult;
+    readonly consumerBinding: string | null;
+    readonly failure?: never;
+}) | (RegistrationExecutionAuthority & {
+    readonly kind: 'failed';
+    readonly requestDigestSha256Hex: string;
+    readonly request: ExecuteRequest;
+    readonly claimedAtMs: number;
+    readonly reconcileAfterMs: number;
+    readonly failure: RouterAbEd25519YaoRegistrationFailure;
+    readonly result?: never;
+    readonly consumerBinding?: never;
+});
+type MapValue<T> = T extends Map<string, infer Value> ? Value : never;
+type RegistrationLifecycleState = MapValue<InMemoryRouterAbEd25519YaoRegistrationStateV1['states']>;
+type AdmittedRegistration = Extract<RegistrationLifecycleState, {
+    readonly kind: 'admitted';
+}>;
+type BoundRegistrationIntentAuthority = InMemoryRouterAbEd25519YaoRegistrationIntentAuthorizationStateV1['authorities'][number];
+export declare function buildRouterAbEd25519YaoRegistrationExecutionReadyRecordV1(input: {
+    readonly lifecycleId: string;
+    readonly registration: AdmittedRegistration;
+    readonly authority: BoundRegistrationIntentAuthority;
+}): RouterAbEd25519YaoRegistrationExecutionRecordV1 | null;
+export declare function routerAbEd25519YaoRegistrationExecutionRecordKeyV1(lifecycleId: string): string;
+export declare function encodeRouterAbEd25519YaoRegistrationExecutionRecordV1(record: RouterAbEd25519YaoRegistrationExecutionRecordV1): VersionedJsonObject;
+export declare function parseRouterAbEd25519YaoRegistrationExecutionRecordV1(input: unknown): RouterAbEd25519YaoRegistrationExecutionRecordV1 | null;
+export declare function routerAbEd25519YaoRegistrationExecutionRequestDigestV1(request: ExecuteRequest): Promise<string>;
+export declare function routerAbEd25519YaoRegistrationAdmissionBindingJsonV1(receipt: AdmissionReceipt): string;
+export {};
+//# sourceMappingURL=routerAbEd25519YaoRegistrationExecutionRecord.d.ts.map

package/dist/types/wallet-server/src/router/domains/ed25519Yao/registration/routerAbEd25519YaoRegistrationIntentAuthorization.d.ts

@@ -0,0 +1,73 @@
+import { type RouterAbEd25519YaoRegistrationAdmissionRequestV1 } from '../../../../../../shared-ts/src/utils/routerAbEd25519Yao';
+import { type AddSignerIntentGrant, type AddSignerIntentV1, type RegistrationIntentGrant, type RegistrationIntentV1 } from '../../../../../../shared-ts/src/utils/registrationIntent';
+import type { RouterAbEd25519YaoRegistrationAuthorizationAdapter, RouterAbEd25519YaoRegistrationAuthorizationInput, RouterAbEd25519YaoRegistrationAuthorizationResult } from './routerAbEd25519YaoRegistration';
+type AvailableIntentAuthority = {
+    readonly kind: 'available';
+    readonly purpose: RouterAbEd25519YaoActivationIntentPurposeV1;
+    readonly credentialDigestSha256: Uint8Array;
+    readonly admissionRequest: RouterAbEd25519YaoRegistrationAdmissionRequestV1;
+    readonly admissionFingerprint: string;
+    readonly expiresAtMs: number;
+};
+type AdmittedIntentAuthority = {
+    readonly kind: 'admitted';
+    readonly purpose: RouterAbEd25519YaoActivationIntentPurposeV1;
+    readonly credentialDigestSha256: Uint8Array;
+    readonly admissionRequest: RouterAbEd25519YaoRegistrationAdmissionRequestV1;
+    readonly admissionFingerprint: string;
+    readonly expiresAtMs: number;
+};
+type IntentAuthority = AvailableIntentAuthority | AdmittedIntentAuthority;
+type RouterAbEd25519YaoActivationIntentPurposeV1 = 'wallet_registration' | 'wallet_add_signer';
+export type RouterAbEd25519YaoVerifiedRegistrationIntentV1 = {
+    readonly kind: 'verified_registration_intent';
+    readonly registrationIntentGrant: RegistrationIntentGrant;
+    readonly intent: RegistrationIntentV1;
+    readonly admissionRequest: RouterAbEd25519YaoRegistrationAdmissionRequestV1;
+    readonly expiresAtMs: number;
+};
+export type RouterAbEd25519YaoVerifiedAddSignerIntentV1 = {
+    readonly kind: 'verified_add_signer_intent';
+    readonly addSignerIntentGrant: AddSignerIntentGrant;
+    readonly intent: AddSignerIntentV1 & {
+        readonly signerSelection: Extract<AddSignerIntentV1['signerSelection'], {
+            mode: 'ed25519';
+        }>;
+    };
+    readonly admissionRequest: RouterAbEd25519YaoRegistrationAdmissionRequestV1;
+    readonly expiresAtMs: number;
+};
+export type RouterAbEd25519YaoVerifiedActivationIntentV1 = RouterAbEd25519YaoVerifiedRegistrationIntentV1 | RouterAbEd25519YaoVerifiedAddSignerIntentV1;
+export type RouterAbEd25519YaoRegistrationIntentBindingResult = {
+    readonly ok: true;
+    readonly code?: never;
+    readonly message?: never;
+} | {
+    readonly ok: false;
+    readonly code: 'invalid_registration_intent' | 'registration_intent_conflict';
+    readonly message: string;
+};
+export type RouterAbEd25519YaoBearerCredentialDigestResultV1 = {
+    readonly ok: true;
+    readonly digestSha256Hex: string;
+} | {
+    readonly ok: false;
+    readonly result: Extract<RouterAbEd25519YaoRegistrationAuthorizationResult, {
+        readonly ok: false;
+    }>;
+};
+export declare function routerAbEd25519YaoBearerCredentialDigestV1(request: Request): Promise<RouterAbEd25519YaoBearerCredentialDigestResultV1>;
+export declare function routerAbEd25519YaoCredentialDigestHexV1(digest: Uint8Array): string;
+export declare class InMemoryRouterAbEd25519YaoRegistrationIntentAuthorizationStateV1 {
+    readonly authorities: IntentAuthority[];
+}
+export declare class InMemoryRouterAbEd25519YaoRegistrationIntentAuthorizationAdapter implements RouterAbEd25519YaoRegistrationAuthorizationAdapter {
+    private readonly authorities;
+    constructor(state?: InMemoryRouterAbEd25519YaoRegistrationIntentAuthorizationStateV1);
+    bindVerifiedIntent(verified: RouterAbEd25519YaoVerifiedActivationIntentV1): Promise<RouterAbEd25519YaoRegistrationIntentBindingResult>;
+    authorize(input: RouterAbEd25519YaoRegistrationAuthorizationInput): Promise<RouterAbEd25519YaoRegistrationAuthorizationResult>;
+    private authorizeAdmission;
+    private authorizeExecution;
+}
+export {};
+//# sourceMappingURL=routerAbEd25519YaoRegistrationIntentAuthorization.d.ts.map

package/dist/types/wallet-server/src/router/domains/ed25519Yao/registration/routerAbEd25519YaoRegistrationRequestScopedCloudflare.d.ts

@@ -0,0 +1,9 @@
+import type { RouterAbEd25519YaoRegistrationBackend } from './routerAbEd25519YaoRegistration';
+import type { RouterAbEd25519YaoProductRegistrationPartitionedStateStoreV1 } from '../capabilityLifecycle/routerAbEd25519YaoProductRegistrationPartitionedStateStore';
+export type RouterAbEd25519YaoRegistrationRequestScopedCloudflareInputV1 = {
+    readonly request: Request;
+    readonly store: RouterAbEd25519YaoProductRegistrationPartitionedStateStoreV1;
+    readonly backend: RouterAbEd25519YaoRegistrationBackend;
+};
+export declare function handleRouterAbEd25519YaoRegistrationRequestScopedCloudflareV1(input: RouterAbEd25519YaoRegistrationRequestScopedCloudflareInputV1): Promise<Response>;
+//# sourceMappingURL=routerAbEd25519YaoRegistrationRequestScopedCloudflare.d.ts.map

package/dist/types/wallet-server/src/router/domains/ed25519Yao/registration/routerAbEd25519YaoRegistrationSideEffectBoundary.d.ts

@@ -0,0 +1,131 @@
+import type { VersionedJsonRecordPutResult, VersionedJsonRecordReadResult } from '../../../framework/versionedJsonRecordStore';
+export type RouterAbEd25519YaoRegistrationSideEffectOperationV1 = 'finalize' | 'registration_activate' | 'near_provisioning' | 'registration_start' | 'add_signer_start' | 'add_signer_finalize';
+export type RouterAbEd25519YaoRetryableSideEffectFailureV1 = {
+    readonly ok: false;
+    readonly code: string;
+    readonly message: string;
+    readonly retryAfterMs?: number;
+};
+export declare function throwIfRouterAbEd25519YaoRetryableSideEffectFailureV1<T extends RouterAbEd25519YaoRetryableSideEffectFailureV1>(failure: T): T;
+/**
+ * The semantic request fingerprint detects idempotency conflicts before
+ * preparation. The prepared artifact fingerprint binds the exact durable
+ * bytes that execution may replay after an ambiguous outcome.
+ */
+export type RouterAbEd25519YaoRegistrationSideEffectClaimV1<P> = {
+    readonly kind: 'router_ab_ed25519_yao_registration_side_effect_claim_v1';
+    readonly operation: RouterAbEd25519YaoRegistrationSideEffectOperationV1;
+    readonly requestFingerprint: string;
+    readonly preparedArtifactFingerprint: string;
+    readonly claimedAtMs: number;
+    readonly prepared: P;
+};
+export type RouterAbEd25519YaoRegistrationSideEffectCompletionV1<T, P> = {
+    readonly kind: 'router_ab_ed25519_yao_registration_side_effect_completion_v1';
+    readonly operation: RouterAbEd25519YaoRegistrationSideEffectOperationV1;
+    readonly requestFingerprint: string;
+    readonly preparedArtifactFingerprint: string;
+    readonly claimedAtMs: number;
+    readonly completedAtMs: number;
+    readonly prepared: P;
+    readonly response: T;
+};
+export type RouterAbEd25519YaoRegistrationSideEffectRecordV1<T, P> = RouterAbEd25519YaoRegistrationSideEffectClaimV1<P> | RouterAbEd25519YaoRegistrationSideEffectCompletionV1<T, P>;
+export interface RouterAbEd25519YaoRegistrationSideEffectStoreV1<T, P> {
+    read(key: string): Promise<VersionedJsonRecordReadResult<RouterAbEd25519YaoRegistrationSideEffectRecordV1<T, P>>>;
+    put(key: string, value: RouterAbEd25519YaoRegistrationSideEffectRecordV1<T, P>, expectedVersion: string | null): Promise<VersionedJsonRecordPutResult>;
+}
+/**
+ * Registration completion rows carry a committed credential-free receipt. The
+ * claim remains shared with the older journal shape because it contains no
+ * response or bearer material.
+ */
+export type RouterAbEd25519YaoRegistrationSideEffectCompletionV2<C, P> = {
+    readonly kind: 'router_ab_ed25519_yao_registration_side_effect_completion_v2';
+    readonly operation: RouterAbEd25519YaoRegistrationSideEffectOperationV1;
+    readonly requestFingerprint: string;
+    readonly preparedArtifactFingerprint: string;
+    readonly claimedAtMs: number;
+    readonly completedAtMs: number;
+    readonly prepared: P;
+    readonly receipt: C;
+};
+export type RouterAbEd25519YaoRegistrationSideEffectRecordV2<C, P> = RouterAbEd25519YaoRegistrationSideEffectClaimV1<P> | RouterAbEd25519YaoRegistrationSideEffectCompletionV2<C, P>;
+export interface RouterAbEd25519YaoRegistrationSideEffectStoreV2<C, P> {
+    read(key: string): Promise<VersionedJsonRecordReadResult<RouterAbEd25519YaoRegistrationSideEffectRecordV2<C, P>>>;
+    put(key: string, value: RouterAbEd25519YaoRegistrationSideEffectRecordV2<C, P>, expectedVersion: string | null): Promise<VersionedJsonRecordPutResult>;
+}
+export declare function parseRouterAbEd25519YaoRegistrationSideEffectRecordV2<C, P>(raw: unknown, input: {
+    readonly operation: RouterAbEd25519YaoRegistrationSideEffectOperationV1;
+    readonly parsePrepared: (value: unknown) => P | null;
+    readonly parseReceipt: (value: unknown) => C | null;
+}): RouterAbEd25519YaoRegistrationSideEffectRecordV2<C, P> | null;
+export declare function parseRouterAbEd25519YaoRegistrationSideEffectRecordV1<T, P>(raw: unknown, input: {
+    readonly operation: RouterAbEd25519YaoRegistrationSideEffectOperationV1;
+    readonly parsePrepared: (value: unknown) => P | null;
+    readonly parseResponse: (value: unknown) => T | null;
+}): RouterAbEd25519YaoRegistrationSideEffectRecordV1<T, P> | null;
+/**
+ * `resumed` means a prior attempt persisted this exact artifact and may have
+ * broadcast it without observing the outcome. Execution must reconcile before
+ * it repeats any network effect.
+ */
+export type RouterAbEd25519YaoRegistrationSideEffectAttemptV1 = 'fresh' | 'resumed';
+export type RouterAbEd25519YaoRegistrationSideEffectRunInputV1<T, P> = {
+    readonly kind: 'prepared_resumable';
+    readonly operation: RouterAbEd25519YaoRegistrationSideEffectOperationV1;
+    readonly key: string;
+    readonly requestFingerprint: string;
+    readonly resumeAfterMs: number;
+    readonly nowMs: () => number;
+    readonly prepare: () => Promise<P>;
+    readonly derivePreparedArtifactFingerprint: (prepared: P) => Promise<string>;
+    readonly execute: (prepared: P, attempt: RouterAbEd25519YaoRegistrationSideEffectAttemptV1) => Promise<T>;
+};
+export type RouterAbEd25519YaoRegistrationSideEffectExecutionV1<T, P> = RouterAbEd25519YaoRegistrationSideEffectRunInputV1<T, P>['execute'];
+export type RouterAbEd25519YaoRegistrationSideEffectRunResultV1<T, P> = {
+    readonly kind: 'executed';
+    readonly value: T;
+} | {
+    readonly kind: 'exact_replay';
+    readonly value: T;
+} | {
+    readonly kind: 'in_progress';
+    readonly prepared: P;
+    readonly preparedArtifactFingerprint: string;
+} | {
+    readonly kind: 'request_conflict';
+} | {
+    readonly kind: 'uncertain';
+    readonly phase: 'claim' | 'effect' | 'terminal_commit';
+    readonly message: string;
+};
+/**
+ * Persists an exact prepared artifact before its one-use effect. A stale claim
+ * resumes from that artifact without running preparation again. Claim and
+ * completion reads verify the artifact fingerprint before returning a result
+ * or allowing a network effect.
+ */
+export declare function runRouterAbEd25519YaoRegistrationSideEffectV1<T, P>(store: RouterAbEd25519YaoRegistrationSideEffectStoreV1<T, P>, input: RouterAbEd25519YaoRegistrationSideEffectRunInputV1<T, P>): Promise<RouterAbEd25519YaoRegistrationSideEffectRunResultV1<T, P>>;
+export type RouterAbEd25519YaoRegistrationSideEffectRunInputV2<T, C, P> = {
+    readonly kind: 'prepared_resumable';
+    readonly operation: RouterAbEd25519YaoRegistrationSideEffectOperationV1;
+    readonly key: string;
+    readonly requestFingerprint: string;
+    readonly resumeAfterMs: number;
+    readonly nowMs: () => number;
+    readonly prepare: () => Promise<P>;
+    readonly derivePreparedArtifactFingerprint: (prepared: P) => Promise<string>;
+    readonly execute: (prepared: P, attempt: RouterAbEd25519YaoRegistrationSideEffectAttemptV1) => Promise<T>;
+    readonly projectReceipt: (response: T) => Promise<C> | C;
+    readonly replay: (receipt: C) => Promise<T>;
+};
+export type RouterAbEd25519YaoRegistrationSideEffectRunResultV2<T, P> = RouterAbEd25519YaoRegistrationSideEffectRunResultV1<T, P>;
+/**
+ * Registration-only journal runner. Completion CAS stores a credential-free
+ * receipt instead of the public response, and replay rebuilds the committed
+ * projection from that receipt. A committed credential cannot be recovered
+ * from its digest, so replay never reconstructs one.
+ */
+export declare function runRouterAbEd25519YaoRegistrationSideEffectV2<T, C, P>(store: RouterAbEd25519YaoRegistrationSideEffectStoreV2<C, P>, input: RouterAbEd25519YaoRegistrationSideEffectRunInputV2<T, C, P>): Promise<RouterAbEd25519YaoRegistrationSideEffectRunResultV2<T, P>>;
+//# sourceMappingURL=routerAbEd25519YaoRegistrationSideEffectBoundary.d.ts.map

package/dist/types/wallet-server/src/router/domains/ed25519Yao/registration/routerAbEd25519YaoRegistrationSideEffectBoundary.typecheck.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=routerAbEd25519YaoRegistrationSideEffectBoundary.typecheck.d.ts.map

package/dist/types/wallet-server/src/router/domains/ed25519Yao/registration/routerAbEd25519YaoRegistrationTwoPhaseRunner.d.ts

@@ -0,0 +1,62 @@
+import type { RouterAbEd25519YaoProductRegistrationStateV1 } from '../capabilityLifecycle/routerAbEd25519YaoProductRegistration';
+import type { RouterAbEd25519YaoProductRegistrationPartitionedStateStoreV1 } from '../capabilityLifecycle/routerAbEd25519YaoProductRegistrationPartitionedStateStore';
+export type RouterAbEd25519YaoRegistrationTwoPhaseBackendResultV1<T> = {
+    readonly kind: 'response';
+    readonly value: T;
+} | {
+    readonly kind: 'uncertain';
+    readonly message: string;
+};
+export type RouterAbEd25519YaoRegistrationTwoPhasePrepareResultV1<TClaim, TResponse, TRejection> = {
+    readonly kind: 'claimed';
+    readonly state: RouterAbEd25519YaoProductRegistrationStateV1;
+    readonly claim: TClaim;
+} | {
+    readonly kind: 'completed';
+    readonly value: TResponse;
+} | {
+    readonly kind: 'rejected';
+    readonly value: TRejection;
+};
+export type RouterAbEd25519YaoRegistrationTwoPhaseCompletionV1<TResponse> = {
+    readonly state: RouterAbEd25519YaoProductRegistrationStateV1;
+    readonly value: TResponse;
+};
+export type RouterAbEd25519YaoRegistrationTwoPhaseRunResultV1<TClaim, TResponse, TRejection> = {
+    readonly kind: 'committed';
+    readonly value: TResponse;
+    readonly sharedVersion: string | null;
+    readonly ceremonyVersion: string;
+} | {
+    readonly kind: 'completed';
+    readonly value: TResponse;
+} | {
+    readonly kind: 'rejected';
+    readonly value: TRejection;
+} | {
+    readonly kind: 'preclaim_version_mismatch';
+    readonly key: 'shared' | 'ceremony' | 'execution';
+} | {
+    readonly kind: 'backend_uncertain';
+    readonly claim: TClaim;
+    readonly message: string;
+} | {
+    readonly kind: 'terminal_version_mismatch';
+    readonly claim: TClaim;
+    readonly key: 'shared' | 'ceremony' | 'execution';
+};
+export type RouterAbEd25519YaoRegistrationTwoPhaseRunInputV1<TClaim, TBackend, TResponse, TRejection> = {
+    readonly lifecycleId: string;
+    readonly store: RouterAbEd25519YaoProductRegistrationPartitionedStateStoreV1;
+    readonly prepare: (state: RouterAbEd25519YaoProductRegistrationStateV1) => Promise<RouterAbEd25519YaoRegistrationTwoPhasePrepareResultV1<TClaim, TResponse, TRejection>>;
+    readonly backend: (claim: TClaim) => Promise<RouterAbEd25519YaoRegistrationTwoPhaseBackendResultV1<TBackend>>;
+    readonly complete: (state: RouterAbEd25519YaoProductRegistrationStateV1, claim: TClaim, backend: TBackend) => Promise<RouterAbEd25519YaoRegistrationTwoPhaseCompletionV1<TResponse>>;
+};
+/**
+ * Persists a typed execution claim before calling a remote backend, then
+ * persists the terminal state through a fresh CAS snapshot. The backend is
+ * never retried here. A terminal CAS conflict is reported as uncertain so a
+ * caller can reconcile the already-issued backend request.
+ */
+export declare function runRouterAbEd25519YaoRegistrationTwoPhaseV1<TClaim, TBackend, TResponse, TRejection>(input: RouterAbEd25519YaoRegistrationTwoPhaseRunInputV1<TClaim, TBackend, TResponse, TRejection>): Promise<RouterAbEd25519YaoRegistrationTwoPhaseRunResultV1<TClaim, TResponse, TRejection>>;
+//# sourceMappingURL=routerAbEd25519YaoRegistrationTwoPhaseRunner.d.ts.map

package/dist/types/wallet-server/src/router/domains/ed25519Yao/routerAbEd25519YaoGatewayEnvelope.d.ts

@@ -0,0 +1,17 @@
+import type { RouterAbEd25519YaoExportAdmissionRequestV1, RouterAbEd25519YaoRecoveryAdmissionRequestV1, RouterAbEd25519YaoRegistrationAdmissionRequestV1 } from '../../../../../shared-ts/src/utils/routerAbEd25519Yao';
+import type { TenantRootActiveLineageV1 } from '../tenantRoot/tenantRootCustodyLineage';
+export type RouterAbEd25519YaoTenantRootResolutionInputV1 = {
+    readonly operation: 'registration';
+    readonly admissionRequest: RouterAbEd25519YaoRegistrationAdmissionRequestV1;
+} | {
+    readonly operation: 'recovery';
+    readonly admissionRequest: RouterAbEd25519YaoRecoveryAdmissionRequestV1;
+} | {
+    readonly operation: 'export';
+    readonly admissionRequest: RouterAbEd25519YaoExportAdmissionRequestV1;
+};
+export type RouterAbEd25519YaoTenantRootResolverV1 = (input: RouterAbEd25519YaoTenantRootResolutionInputV1) => Promise<TenantRootActiveLineageV1>;
+export type RouterAbEd25519YaoRegistrationExecuteAdmissionContextV1 = RouterAbEd25519YaoRegistrationAdmissionRequestV1;
+export type RouterAbEd25519YaoRecoveryExecuteAdmissionContextV1 = RouterAbEd25519YaoRecoveryAdmissionRequestV1;
+export type RouterAbEd25519YaoExportExecuteAdmissionContextV1 = RouterAbEd25519YaoExportAdmissionRequestV1;
+//# sourceMappingURL=routerAbEd25519YaoGatewayEnvelope.d.ts.map