@seams/wallet-server 0.6.2 → 0.7.1

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

@@ -4,15 +4,16 @@ import { type RuntimePolicyScope } from '../../../../../../shared-ts/src/thresho
 import { type RouterAbEd25519NormalSigningState } from '../../../../../../shared-ts/src/utils/signingSessionSeal';
 import { type RouterApiModule } from '../../../framework/modules';
 import type { RouterApiWalletSessionAuthorizationV2AdmissionContext, RouterApiWalletSessionAuthorizationV2ExhaustedCandidateContext } from '../../../framework/authServicePort';
-import type { RouterAbEd25519YaoRecoveryExecuteAdmissionContextV1 } from '../routerAbEd25519YaoGatewayEnvelope';
+import type { RouterAbEd25519YaoRecoveryExecuteAdmissionContextV1, RouterAbEd25519YaoTenantRootWireV1 } from '../routerAbEd25519YaoGatewayEnvelope';
 import type { WalletEd25519YaoActiveCapabilityRecord } from '../../../../core/WalletStore';
+import type { RouterAbEd25519YaoPreparedWriteV1 } from '../capabilityLifecycle/routerAbEd25519YaoProductRegistrationPartitionedStateStore';
 import { type MpcMaterialActivationRef, type ThresholdEd25519SessionId } from '../../../../../../shared-ts/src/utils/domainIds';
 import { type RouterAbMpcMaterialActivationRefWire } from '../../../../../../shared-ts/src/utils/routerAbNormalSigningIdentity';
 type RecoveryAdmissionReceipt = RouterAbEd25519YaoActivationAdmissionReceiptV1<'recovery'>;
 type RecoveryExecuteRequest = RouterAbEd25519YaoActivationExecuteRequestV1<'recovery'>;
 type RecoveryExecutionResult = RouterAbEd25519YaoActivationResultV1<'recovery'>;
 type RegistrationResult = RouterAbEd25519YaoActivationResultV1<'registration'>;
-export type RouterAbEd25519YaoRecoveryFailureCode = 'invalid_request' | 'invalid_backend_response' | 'admission_failed' | 'admission_in_progress' | 'unknown_recovery' | 'binding_mismatch' | 'execution_in_progress' | 'execution_failed' | 'ceremony_expired' | 'recovery_not_staged' | 'activation_in_progress' | 'activation_failed' | 'unknown_capability' | 'capability_suspended' | 'capability_retired' | 'capability_conflict' | 'continuity_mismatch' | 'stale_epoch';
+type RouterAbEd25519YaoRecoveryFailureCode = 'invalid_request' | 'invalid_backend_response' | 'admission_failed' | 'admission_in_progress' | 'unknown_recovery' | 'binding_mismatch' | 'execution_in_progress' | 'execution_failed' | 'ceremony_expired' | 'recovery_not_staged' | 'activation_in_progress' | 'activation_failed' | 'unknown_capability' | 'capability_suspended' | 'capability_retired' | 'capability_conflict' | 'continuity_mismatch' | 'stale_epoch' | 'execution_interrupted' | 'recovery_superseded';
 export type RouterAbEd25519YaoRecoveryFailure = {
     readonly ok: false;
     readonly status: 400 | 404 | 408 | 409 | 429 | 500 | 502 | 503;
@@ -24,7 +25,7 @@ export type RouterAbEd25519YaoRecoveryServiceResult<T> = {
     readonly status: 200;
     readonly value: T;
 } | RouterAbEd25519YaoRecoveryFailure;
-export type RouterAbEd25519YaoRecoveryBackendFailure = {
+type RouterAbEd25519YaoRecoveryBackendFailure = {
     readonly ok: false;
     readonly status: 400 | 408 | 409 | 429 | 500 | 502 | 503;
     readonly code: string;
@@ -34,12 +35,12 @@ export type RouterAbEd25519YaoRecoveryBackendResult = {
     readonly ok: true;
     readonly body: unknown;
 } | RouterAbEd25519YaoRecoveryBackendFailure;
-export type RouterAbEd25519YaoRecoveryAuthorityProjectionV1 = {
+type RouterAbEd25519YaoRecoveryAuthorityProjectionV1 = {
     readonly kind: 'replace_continuity_authority_projections';
 } | {
     readonly kind: 'replace_active_authority_projection';
 };
-export type RouterAbEd25519YaoRecoveryAuthorizationBindingV1 = {
+type RouterAbEd25519YaoRecoveryAuthorizationBindingV1 = {
     readonly kind: 'wallet_recovery';
     readonly walletId: string;
 } | {
@@ -56,8 +57,20 @@ export type RouterAbEd25519YaoRecoveryAuthorizationBindingV1 = {
 };
 export interface RouterAbEd25519YaoRecoveryBackend {
     admitRecovery(request: RouterAbEd25519YaoRecoveryAdmissionRequestV1, traceContext?: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRecoveryBackendResult> | RouterAbEd25519YaoRecoveryBackendResult;
-    executeRecovery(request: RecoveryExecuteRequest, admissionRequest: RouterAbEd25519YaoRecoveryExecuteAdmissionContextV1, traceContext?: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRecoveryBackendResult> | RouterAbEd25519YaoRecoveryBackendResult;
-    activateRecovery(request: RouterAbEd25519YaoRecoveryActivationRequestV1, traceContext?: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRecoveryBackendResult> | RouterAbEd25519YaoRecoveryBackendResult;
+    /**
+     * The tenant root one recovery attempt runs under, resolved once when the
+     * attempt is admitted. Its executions and its promotion use that root.
+     */
+    resolveRecoveryDispatchRoot(admissionRequest: RouterAbEd25519YaoRecoveryAdmissionRequestV1): Promise<RouterAbEd25519YaoTenantRootWireV1>;
+    /**
+     * Runs one recovery execution at the Router, for the Gateway's attempt
+     * `attempt`. `replay` marks a payload whose earlier claim may have reached
+     * the Router, which then reconciles the roles' records instead of starting
+     * fresh.
+     */
+    executeRecovery(request: RecoveryExecuteRequest, admissionRequest: RouterAbEd25519YaoRecoveryExecuteAdmissionContextV1, dispatchRoot: RouterAbEd25519YaoTenantRootWireV1, attempt: number, replay: boolean, traceContext?: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRecoveryBackendResult> | RouterAbEd25519YaoRecoveryBackendResult;
+    /** Promotes the recovery at the SigningWorker of the attempt's tenant root. */
+    activateRecovery(request: RouterAbEd25519YaoRecoveryActivationRequestV1, dispatchRoot: RouterAbEd25519YaoTenantRootWireV1, traceContext?: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRecoveryBackendResult> | RouterAbEd25519YaoRecoveryBackendResult;
 }
 export interface RouterAbEd25519YaoRecoveryService {
     admitRecovery(request: RouterAbEd25519YaoRecoveryAdmissionRequestV1, authorization: RouterAbEd25519YaoRecoveryAuthorizationBindingV1, traceContext?: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRecoveryServiceResult<RecoveryAdmissionReceipt>>;
@@ -69,7 +82,7 @@ export type RouterAbEd25519YaoRecoveryAdmissionClaimV1 = {
     readonly lifecycleId: string;
     readonly recoveryKey: string;
 };
-export type RouterAbEd25519YaoRecoveryAdmissionPreparationV1 = {
+type RouterAbEd25519YaoRecoveryAdmissionPreparationV1 = {
     readonly kind: 'claimed';
     readonly claim: RouterAbEd25519YaoRecoveryAdmissionClaimV1;
 } | {
@@ -79,7 +92,7 @@ export type RouterAbEd25519YaoRecoveryAdmissionPreparationV1 = {
     readonly kind: 'failed';
     readonly failure: RouterAbEd25519YaoRecoveryFailure;
 };
-export type RouterAbEd25519YaoRecoveryAdmissionCommitInputV1 = {
+type RouterAbEd25519YaoRecoveryAdmissionCommitInputV1 = {
     readonly request: RouterAbEd25519YaoRecoveryAdmissionRequestV1;
     readonly claim: RouterAbEd25519YaoRecoveryAdmissionClaimV1;
     readonly outcome: {
@@ -87,8 +100,8 @@ export type RouterAbEd25519YaoRecoveryAdmissionCommitInputV1 = {
         readonly result: RouterAbEd25519YaoRecoveryBackendResult;
     };
 };
-export interface RouterAbEd25519YaoRecoveryAdmissionBoundaryV1 {
-    prepareAdmitRecovery(request: RouterAbEd25519YaoRecoveryAdmissionRequestV1, authorization: RouterAbEd25519YaoRecoveryAuthorizationBindingV1): RouterAbEd25519YaoRecoveryAdmissionPreparationV1;
+interface RouterAbEd25519YaoRecoveryAdmissionBoundaryV1 {
+    prepareAdmitRecovery(request: RouterAbEd25519YaoRecoveryAdmissionRequestV1, authorization: RouterAbEd25519YaoRecoveryAuthorizationBindingV1, dispatchRoot: RouterAbEd25519YaoTenantRootWireV1, nowMs: number): RouterAbEd25519YaoRecoveryAdmissionPreparationV1;
     commitAdmitRecovery(input: RouterAbEd25519YaoRecoveryAdmissionCommitInputV1): RouterAbEd25519YaoRecoveryServiceResult<RecoveryAdmissionReceipt>;
 }
 export type RouterAbEd25519YaoRecoveryExecuteClaimV1 = {
@@ -98,8 +111,13 @@ export type RouterAbEd25519YaoRecoveryExecuteClaimV1 = {
     readonly sessionId: string;
     readonly executeFingerprint: string;
     readonly admissionRequest: RouterAbEd25519YaoRecoveryExecuteAdmissionContextV1;
+    readonly dispatchRoot: RouterAbEd25519YaoTenantRootWireV1;
+    /** The attempt this execution runs for. */
+    readonly attempt: number;
+    /** An earlier claim of this payload may have reached the Router. */
+    readonly replay: boolean;
 };
-export type RouterAbEd25519YaoRecoveryExecutePreparationV1 = {
+type RouterAbEd25519YaoRecoveryExecutePreparationV1 = {
     readonly kind: 'claimed';
     readonly claim: RouterAbEd25519YaoRecoveryExecuteClaimV1;
 } | {
@@ -109,7 +127,7 @@ export type RouterAbEd25519YaoRecoveryExecutePreparationV1 = {
     readonly kind: 'failed';
     readonly failure: RouterAbEd25519YaoRecoveryFailure;
 };
-export type RouterAbEd25519YaoRecoveryExecuteCommitInputV1 = {
+type RouterAbEd25519YaoRecoveryExecuteCommitInputV1 = {
     readonly request: RecoveryExecuteRequest;
     readonly claim: RouterAbEd25519YaoRecoveryExecuteClaimV1;
     readonly outcome: {
@@ -117,8 +135,8 @@ export type RouterAbEd25519YaoRecoveryExecuteCommitInputV1 = {
         readonly result: RouterAbEd25519YaoRecoveryBackendResult;
     };
 };
-export interface RouterAbEd25519YaoRecoveryExecuteBoundaryV1 {
-    prepareExecuteRecovery(request: RecoveryExecuteRequest, authorization: RouterAbEd25519YaoRecoveryAuthorizationBindingV1): RouterAbEd25519YaoRecoveryExecutePreparationV1;
+interface RouterAbEd25519YaoRecoveryExecuteBoundaryV1 {
+    prepareExecuteRecovery(request: RecoveryExecuteRequest, authorization: RouterAbEd25519YaoRecoveryAuthorizationBindingV1, nowMs: number): RouterAbEd25519YaoRecoveryExecutePreparationV1;
     commitExecuteRecovery(input: RouterAbEd25519YaoRecoveryExecuteCommitInputV1): RouterAbEd25519YaoRecoveryServiceResult<RecoveryExecutionResult>;
 }
 export type RouterAbEd25519YaoRecoveryActivationClaimV1 = {
@@ -129,8 +147,9 @@ export type RouterAbEd25519YaoRecoveryActivationClaimV1 = {
     readonly activationFingerprint: string;
     readonly authorityProjection: RouterAbEd25519YaoRecoveryAuthorityProjectionV1;
     readonly disposition: 'initial' | 'reconciliation';
+    readonly dispatchRoot: RouterAbEd25519YaoTenantRootWireV1;
 };
-export type RouterAbEd25519YaoRecoveryActivationPreparationV1 = {
+type RouterAbEd25519YaoRecoveryActivationPreparationV1 = {
     readonly kind: 'claimed';
     readonly claim: RouterAbEd25519YaoRecoveryActivationClaimV1;
 } | {
@@ -148,14 +167,27 @@ export type RouterAbEd25519YaoRecoveryActivationCommitInputV1 = {
         readonly result: RouterAbEd25519YaoRecoveryBackendResult;
     };
 };
-export type RouterAbEd25519YaoRecoveryActivationCommitResultV1 = {
+type RouterAbEd25519YaoRecoveryActivationCommitResultV1 = {
     readonly kind: 'completed';
     readonly value: RouterAbEd25519YaoRecoveryServiceResult<RouterAbEd25519YaoRecoveryActivationReceiptV1>;
+}
+/**
+ * Promoted in this state. The capability replacement commits with it, or
+ * neither does.
+ */
+ | {
+    readonly kind: 'promoted';
+    readonly value: {
+        readonly ok: true;
+        readonly status: 200;
+        readonly value: RouterAbEd25519YaoRecoveryActivationReceiptV1;
+    };
+    readonly write: RouterAbEd25519YaoPreparedWriteV1;
 } | {
     readonly kind: 'uncertain';
     readonly failure: RouterAbEd25519YaoRecoveryFailure;
 };
-export interface RouterAbEd25519YaoRecoveryActivationBoundaryV1 {
+interface RouterAbEd25519YaoRecoveryActivationBoundaryV1 {
     prepareActivateRecovery(request: RouterAbEd25519YaoRecoveryActivationRequestV1, authorization: RouterAbEd25519YaoRecoveryAuthorizationBindingV1): RouterAbEd25519YaoRecoveryActivationPreparationV1;
     commitActivateRecovery(input: RouterAbEd25519YaoRecoveryActivationCommitInputV1): Promise<RouterAbEd25519YaoRecoveryActivationCommitResultV1>;
 }
@@ -239,17 +271,31 @@ export type RouterAbEd25519YaoCapabilityReplacementOperationV1 = {
     readonly operationFingerprint: string;
     readonly authorityProjection: RouterAbEd25519YaoRecoveryAuthorityProjectionV1;
 };
-export type RouterAbEd25519YaoCapabilityPersistenceResultV1 = {
+export type RouterAbEd25519YaoCapabilityPersistenceResultV1 = 
+/** The replacement already committed, for this operation. */
+{
     readonly ok: true;
-    readonly disposition: 'applied' | 'exact_retry';
+    readonly disposition: 'exact_retry';
+} | {
+    readonly ok: true;
+    readonly disposition: 'prepared';
+    /** Applies the replacement. It commits with the promoted recovery or not at all. */
+    readonly write: RouterAbEd25519YaoPreparedWriteV1;
 } | {
     readonly ok: false;
     readonly disposition: 'rejected' | 'uncertain';
     readonly code: string;
     readonly message: string;
 };
+/**
+ * Replaces a wallet's active Ed25519 Yao capability in its durable records:
+ * the signer row, the replacement receipt, and the active authorities and
+ * live sessions that project it. The writes are prepared, not applied: they
+ * commit in the same batch as the promoted recovery state, so a promotion is
+ * visible everywhere or nowhere.
+ */
 export interface RouterAbEd25519YaoCapabilityPersistenceV1 {
-    replaceActiveCapability(input: {
+    prepareActiveCapabilityReplacement(input: {
         readonly operation: RouterAbEd25519YaoCapabilityReplacementOperationV1;
         readonly previous: WalletEd25519YaoActiveCapabilityRecord;
         readonly next: WalletEd25519YaoActiveCapabilityRecord;
@@ -314,7 +360,7 @@ type RouterAbEd25519YaoExactRecoverySessionBinding = {
     readonly routerAbNormalSigning: RouterAbEd25519NormalSigningState;
     readonly capability: RouterAbEd25519YaoActiveCapabilityDescriptorV1;
 };
-export type RouterAbEd25519YaoWarmRecoveryBootstrapV1 = RouterAbEd25519YaoExactRecoverySessionBinding & {
+type RouterAbEd25519YaoWarmRecoveryBootstrapV1 = RouterAbEd25519YaoExactRecoverySessionBinding & {
     readonly kind: 'router_ab_ed25519_yao_v2_session_bootstrap_v1';
 };
 export interface RouterAbEd25519YaoActiveCapabilityResolverV1 {
@@ -353,10 +399,20 @@ type RecoveryContext = {
     readonly admissionRequest: RouterAbEd25519YaoRecoveryAdmissionRequestV1;
     readonly activeCapability: CapabilityIdentity;
     readonly authorization: RouterAbEd25519YaoRecoveryAuthorizationBindingV1;
+    /** The tenant root the attempt was admitted under: its execute and promotion use it. */
+    readonly dispatchRoot: RouterAbEd25519YaoTenantRootWireV1;
+    /**
+     * The attempt's number: 1 for a recovery's first attempt, and one more than
+     * the attempt it supersedes otherwise. The SigningWorker keeps only the
+     * highest attempt delivered to it, so a superseded attempt's late delivery
+     * never displaces the current one.
+     */
+    readonly attempt: number;
 };
 type RecoveryAdmittingState = {
     readonly kind: 'admitting';
     readonly context: RecoveryContext;
+    readonly claimedAtMs: number;
 };
 type RecoveryAdmissionFailedState = {
     readonly kind: 'admission_failed';
@@ -373,6 +429,29 @@ type RecoveryExecutingState = {
     readonly context: RecoveryContext;
     readonly admissionReceipt: RecoveryAdmissionReceipt;
     readonly executeFingerprint: string;
+    readonly claimedAtMs: number;
+};
+/**
+ * The last execution of this payload ended without a definitive answer: the
+ * Router or a role was unavailable, or the reply was lost. The same payload
+ * replays, and a new attempt of the same recovery may supersede it.
+ */
+type RecoveryExecutionInterruptedState = {
+    readonly kind: 'execution_interrupted';
+    readonly context: RecoveryContext;
+    readonly admissionReceipt: RecoveryAdmissionReceipt;
+    readonly executeFingerprint: string;
+    readonly failure: RouterAbEd25519YaoRecoveryFailure;
+};
+/**
+ * A newer attempt of the same recovery took this attempt's place before it
+ * began activating. It can never execute or activate again. The capability
+ * it suspended stays suspended, now by the newer attempt.
+ */
+type RecoverySupersededState = {
+    readonly kind: 'superseded';
+    readonly context: RecoveryContext;
+    readonly supersededByRecoveryKey: string;
 };
 type RecoveryExecutionFailedState = {
     readonly kind: 'execution_failed';
@@ -414,7 +493,7 @@ type RecoveryPromotedState = {
     readonly activationFingerprint: string;
     readonly activationReceipt: RouterAbEd25519YaoRecoveryActivationReceiptV1;
 };
-type RecoveryLifecycleState = RecoveryAdmittingState | RecoveryAdmissionFailedState | RecoveryAdmittedState | RecoveryExecutingState | RecoveryExecutionFailedState | RecoveryStagedState | RecoveryActivatingState | RecoveryActivationFailedState | RecoveryPromotedState;
+type RecoveryLifecycleState = RecoveryAdmittingState | RecoveryAdmissionFailedState | RecoveryAdmittedState | RecoveryExecutingState | RecoveryExecutionInterruptedState | RecoveryExecutionFailedState | RecoveryStagedState | RecoveryActivatingState | RecoveryActivationFailedState | RecoveryPromotedState | RecoverySupersededState;
 export declare class InMemoryRouterAbEd25519YaoRecoveryStateV1 {
     readonly capabilities: Map<string, CapabilityState>;
     readonly identityCapabilities: Map<string, string>;
@@ -426,7 +505,7 @@ export declare class InMemoryRouterAbEd25519YaoRecoveryStateV1 {
  * on purpose: the concrete projection lives with the platform install service,
  * and this domain only reads the identity, binding, and receipt facts.
  */
-export type WarmBootstrapLinkedEd25519AuthorityProjectionV1 = {
+type WarmBootstrapLinkedEd25519AuthorityProjectionV1 = {
     readonly walletId: string;
     readonly authorityId: string;
     readonly walletAuthMethodId: string;
@@ -446,11 +525,6 @@ export type WarmBootstrapLinkedEd25519AuthorityReaderV1 = {
         readonly materialActivation: MpcMaterialActivationRef;
     }): Promise<WarmBootstrapLinkedEd25519AuthorityProjectionV1 | null>;
 };
-export declare function warmBootstrapCapabilityMatchesStableIdentity(input: {
-    readonly request: RouterAbEd25519YaoWarmRecoveryBootstrapRequestV1;
-    readonly context: WarmBootstrapWalletSessionContext;
-    readonly capability: RouterAbEd25519YaoActiveCapabilityDescriptorV1;
-}): boolean;
 export declare function buildWarmRecoveryBootstrapResponse(input: {
     readonly request: RouterAbEd25519YaoWarmRecoveryBootstrapRequestV1;
     readonly authorization: Extract<RouterAbEd25519YaoRecoveryAuthorizationResult, {
@@ -459,7 +533,7 @@ export declare function buildWarmRecoveryBootstrapResponse(input: {
     readonly capability: RouterAbEd25519YaoActiveCapabilityDescriptorV1;
     readonly linkedAuthorities?: WarmBootstrapLinkedEd25519AuthorityReaderV1 | null;
 }): Promise<RouterAbEd25519YaoWarmRecoveryBootstrapV1 | null>;
-export type RouterAbEd25519YaoActiveCapabilityRecordBuildResultV1 = {
+type RouterAbEd25519YaoActiveCapabilityRecordBuildResultV1 = {
     readonly ok: true;
     readonly record: WalletEd25519YaoActiveCapabilityRecord;
 } | Extract<RouterAbEd25519YaoRegistrationFinalizeCapabilityInstallResultV1, {
@@ -480,10 +554,10 @@ export declare class InMemoryRouterAbEd25519YaoRecoveryService implements Router
     private installCapabilityIdentity;
     resolveActiveCapability(input: RouterAbEd25519YaoActiveCapabilityLookupV1): RouterAbEd25519YaoActiveCapabilityLookupResultV1;
     admitRecovery(request: RouterAbEd25519YaoRecoveryAdmissionRequestV1, authorization: RouterAbEd25519YaoRecoveryAuthorizationBindingV1, traceContext?: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRecoveryServiceResult<RecoveryAdmissionReceipt>>;
-    prepareAdmitRecovery(request: RouterAbEd25519YaoRecoveryAdmissionRequestV1, authorization: RouterAbEd25519YaoRecoveryAuthorizationBindingV1): RouterAbEd25519YaoRecoveryAdmissionPreparationV1;
+    prepareAdmitRecovery(request: RouterAbEd25519YaoRecoveryAdmissionRequestV1, authorization: RouterAbEd25519YaoRecoveryAuthorizationBindingV1, dispatchRoot: RouterAbEd25519YaoTenantRootWireV1, nowMs: number): RouterAbEd25519YaoRecoveryAdmissionPreparationV1;
     commitAdmitRecovery(input: RouterAbEd25519YaoRecoveryAdmissionCommitInputV1): RouterAbEd25519YaoRecoveryServiceResult<RecoveryAdmissionReceipt>;
     executeRecovery(request: RecoveryExecuteRequest, authorization: RouterAbEd25519YaoRecoveryAuthorizationBindingV1, traceContext?: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRecoveryServiceResult<RecoveryExecutionResult>>;
-    prepareExecuteRecovery(request: RecoveryExecuteRequest, authorization: RouterAbEd25519YaoRecoveryAuthorizationBindingV1): RouterAbEd25519YaoRecoveryExecutePreparationV1;
+    prepareExecuteRecovery(request: RecoveryExecuteRequest, authorization: RouterAbEd25519YaoRecoveryAuthorizationBindingV1, nowMs: number): RouterAbEd25519YaoRecoveryExecutePreparationV1;
     commitExecuteRecovery(input: RouterAbEd25519YaoRecoveryExecuteCommitInputV1): RouterAbEd25519YaoRecoveryServiceResult<RecoveryExecutionResult>;
     activateRecovery(request: RouterAbEd25519YaoRecoveryActivationRequestV1, authorization: RouterAbEd25519YaoRecoveryAuthorizationBindingV1, traceContext?: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRecoveryServiceResult<RouterAbEd25519YaoRecoveryActivationReceiptV1>>;
     prepareActivateRecovery(request: RouterAbEd25519YaoRecoveryActivationRequestV1, authorization: RouterAbEd25519YaoRecoveryAuthorizationBindingV1): RouterAbEd25519YaoRecoveryActivationPreparationV1;
@@ -496,6 +570,8 @@ export declare class InMemoryRouterAbEd25519YaoRecoveryService implements Router
     private failUncertainAdmission;
     private failUncertainExecution;
     private storeAdmissionFailure;
+    /** Records an execution that ended without a definitive answer: it resumes. */
+    private interruptExecution;
     private storeExecutionFailure;
     private storeActivationFailure;
 }

package/dist/types/wallet-server/src/router/domains/ed25519Yao/recovery/routerAbEd25519YaoRecoveryActivation.typecheck.d.ts

@@ -1,2 +1,7 @@
+import type { RouterAbEd25519YaoRecoveryActivationCommitInputV1 } from './routerAbEd25519YaoRecovery';
+type AssertNever<T extends never> = T;
+export type ActivationUncertaintyCannotCrossCommitBoundary = AssertNever<Extract<RouterAbEd25519YaoRecoveryActivationCommitInputV1['outcome'], {
+    readonly kind: 'backend_uncertain';
+}>>;
 export {};
 //# sourceMappingURL=routerAbEd25519YaoRecoveryActivation.typecheck.d.ts.map

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

@@ -2,7 +2,7 @@ import { type RouterAbEd25519YaoActivationExecuteRequestV1, type RouterAbEd25519
 import type { RouterAbEd25519YaoRegistrationBackend, RouterAbEd25519YaoRegistrationBackendResult } from './routerAbEd25519YaoRegistration';
 import type { RouterAbEd25519YaoExportBackend } from '../export/routerAbEd25519YaoExport';
 import type { RouterAbEd25519YaoRecoveryBackend } from '../recovery/routerAbEd25519YaoRecovery';
-import type { RouterAbEd25519YaoTenantRootResolverV1 } from '../routerAbEd25519YaoGatewayEnvelope';
+import { type RouterAbEd25519YaoTenantRootResolverV1, type RouterAbEd25519YaoTenantRootWireV1 } from '../routerAbEd25519YaoGatewayEnvelope';
 import { type RouterAbTraceContextV1 } from '../../../../../../shared-ts/src/utils/routerAbTraceContext';
 type RouterAbEd25519YaoRegistrationExecuteRequestV1 = RouterAbEd25519YaoActivationExecuteRequestV1<'registration'>;
 type RouterAbEd25519YaoRecoveryExecuteRequestV1 = RouterAbEd25519YaoActivationExecuteRequestV1<'recovery'>;
@@ -27,7 +27,33 @@ export type RouterAbEd25519YaoGatewaySpanV1 = {
 };
 export type RouterAbEd25519YaoHttpRegistrationBackendRawEnv = Readonly<Record<string, unknown>>;
 export declare function parseRouterAbEd25519YaoActivationKeysetFromEnvV1(env: RouterAbEd25519YaoHttpRegistrationBackendRawEnv): RouterAbEd25519YaoActivationKeysetV1;
-export declare class RouterAbEd25519YaoHttpRegistrationBackend implements RouterAbEd25519YaoRegistrationBackend, RouterAbEd25519YaoRecoveryBackend, RouterAbEd25519YaoExportBackend {
+export interface RouterAbEd25519YaoPinnedRegistrationBackend extends RouterAbEd25519YaoRegistrationBackend {
+    resolveRegistrationDispatchRoot(admissionRequest: RouterAbEd25519YaoRegistrationAdmissionRequestV1): Promise<RouterAbEd25519YaoTenantRootWireV1>;
+    executePinnedRegistration(request: RouterAbEd25519YaoRegistrationExecuteRequestV1, admissionRequest: RouterAbEd25519YaoRegistrationAdmissionRequestV1, dispatchRoot: RouterAbEd25519YaoTenantRootWireV1, traceContext: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRegistrationBackendResult>;
+    consumeRegistration(input: RouterAbEd25519YaoRegistrationConsumeInputV1): Promise<RouterAbEd25519YaoRegistrationConsumeOutcomeV1>;
+}
+export type RouterAbEd25519YaoRegistrationConsumeInputV1 = {
+    readonly tenantRoot: RouterAbEd25519YaoTenantRootWireV1;
+    readonly walletId: string;
+    readonly lifecycleId: string;
+    readonly sessionId: readonly number[];
+    readonly consumerBinding: string;
+};
+export type RouterAbEd25519YaoRegistrationConsumeOutcomeV1 = {
+    readonly kind: 'consumed';
+    readonly requestJson: string;
+    readonly responseJson: string;
+} | {
+    readonly kind: 'refused';
+    readonly code: 'unknown_registration' | 'registration_not_activated' | 'activation_reference_mismatch' | 'activation_consumed';
+    readonly message: string;
+} | {
+    readonly kind: 'unavailable';
+    readonly message: string;
+};
+/** The registration result a Router answer, exactly as recorded, carries. */
+export declare function parseRouterAbEd25519YaoRegistrationRouterAnswerV1(responseJson: string, request: RouterAbEd25519YaoRegistrationExecuteRequestV1): RouterAbEd25519YaoRegistrationBackendResult;
+export declare class RouterAbEd25519YaoHttpRegistrationBackend implements RouterAbEd25519YaoPinnedRegistrationBackend, RouterAbEd25519YaoRecoveryBackend, RouterAbEd25519YaoExportBackend {
     private readonly config;
     private lastRouterServerTiming;
     constructor(config: RouterAbEd25519YaoHttpRegistrationBackendConfig);
@@ -39,9 +65,14 @@ export declare class RouterAbEd25519YaoHttpRegistrationBackend implements Router
     private keyset;
     private admitActivation;
     execute(request: RouterAbEd25519YaoRegistrationExecuteRequestV1, admissionRequest: RouterAbEd25519YaoRegistrationAdmissionRequestV1, traceContext?: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRegistrationBackendResult>;
-    executeRecovery(request: RouterAbEd25519YaoRecoveryExecuteRequestV1, admissionRequest: RouterAbEd25519YaoRecoveryAdmissionRequestV1, traceContext?: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRegistrationBackendResult>;
+    resolveRegistrationDispatchRoot(admissionRequest: RouterAbEd25519YaoRegistrationAdmissionRequestV1): Promise<RouterAbEd25519YaoTenantRootWireV1>;
+    executePinnedRegistration(request: RouterAbEd25519YaoRegistrationExecuteRequestV1, admissionRequest: RouterAbEd25519YaoRegistrationAdmissionRequestV1, dispatchRoot: RouterAbEd25519YaoTenantRootWireV1, traceContext: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRegistrationBackendResult>;
+    consumeRegistration(input: RouterAbEd25519YaoRegistrationConsumeInputV1): Promise<RouterAbEd25519YaoRegistrationConsumeOutcomeV1>;
+    resolveRecoveryDispatchRoot(admissionRequest: RouterAbEd25519YaoRecoveryAdmissionRequestV1): Promise<RouterAbEd25519YaoTenantRootWireV1>;
+    executeRecovery(request: RouterAbEd25519YaoRecoveryExecuteRequestV1, admissionRequest: RouterAbEd25519YaoRecoveryAdmissionRequestV1, dispatchRoot: RouterAbEd25519YaoTenantRootWireV1, attempt: number, replay: boolean, traceContext?: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRegistrationBackendResult>;
     private executeRouterRequest;
-    activateRecovery(request: RouterAbEd25519YaoRecoveryActivationRequestV1, traceContext?: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRegistrationBackendResult>;
+    private sendRouterRequest;
+    activateRecovery(request: RouterAbEd25519YaoRecoveryActivationRequestV1, dispatchRoot: RouterAbEd25519YaoTenantRootWireV1, traceContext?: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRegistrationBackendResult>;
     private post;
     private headers;
     private request;
@@ -51,6 +82,6 @@ export declare function createRouterAbEd25519YaoHttpRegistrationBackendFromEnv(i
     resolveTenantRoot: RouterAbEd25519YaoTenantRootResolverV1;
     onSpan?: (span: RouterAbEd25519YaoGatewaySpanV1) => void;
     fetch: typeof fetch;
-}): RouterAbEd25519YaoRegistrationBackend & RouterAbEd25519YaoRecoveryBackend & RouterAbEd25519YaoExportBackend;
+}): RouterAbEd25519YaoPinnedRegistrationBackend & RouterAbEd25519YaoRecoveryBackend & RouterAbEd25519YaoExportBackend;
 export {};
 //# sourceMappingURL=routerAbEd25519YaoHttpRegistrationBackend.d.ts.map

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

@@ -1,11 +1,11 @@
 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';
+import type { RouterAbEd25519YaoRegistrationExecuteAdmissionContextV1, RouterAbEd25519YaoTenantRootWireV1 } 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';
+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;
@@ -149,6 +149,8 @@ export declare class InMemoryRouterAbEd25519YaoRegistrationStateV1 {
     readonly states: Map<string, RegistrationLifecycleState>;
     readonly lifecycleSessions: Map<string, string>;
     readonly admissionClaims: Map<string, RouterAbEd25519YaoRegistrationAdmissionClaimV1>;
+    /** The tenant root each admitted lifecycle dispatches to, pinned at admission. */
+    readonly dispatchRoots: Map<string, RouterAbEd25519YaoTenantRootWireV1>;
 }
 export type RouterAbEd25519YaoActivationReferenceV1 = {
     lifecycleId: string;
@@ -158,7 +160,7 @@ export type RouterAbEd25519YaoActivationConsumptionRequestV1 = {
     reference: RouterAbEd25519YaoActivationReferenceV1;
     consumerBinding: string;
 };
-export type RouterAbEd25519YaoActivatedRegistrationV1 = {
+type RouterAbEd25519YaoActivatedRegistrationV1 = {
     admissionRequest: RouterAbEd25519YaoRegistrationAdmissionRequestV1;
     admissionReceipt: RouterAbEd25519YaoRegistrationAdmissionReceiptV1;
     result: RouterAbEd25519YaoRegistrationResultV1;
@@ -176,7 +178,6 @@ export interface RouterAbEd25519YaoActivationConsumerV1 {
 }
 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;

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

@@ -1,70 +1,61 @@
-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 RouterAbEd25519YaoActivationAdmissionReceiptV1, type RouterAbEd25519YaoRegistrationAdmissionRequestV1 } from '../../../../../../shared-ts/src/utils/routerAbEd25519Yao';
+import { InMemoryRouterAbEd25519YaoRegistrationStateV1, type RouterAbEd25519YaoRegistrationBackend, type RouterAbEd25519YaoRegistrationBackendResult, type RouterAbEd25519YaoRegistrationExecuteRequestV1, type RouterAbEd25519YaoRegistrationResultV1, type RouterAbEd25519YaoRegistrationServiceResult } 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";
+import type { RouterAbEd25519YaoTenantRootWireV1 } from '../routerAbEd25519YaoGatewayEnvelope';
 type AdmissionReceipt = RouterAbEd25519YaoActivationAdmissionReceiptV1<'registration'>;
-type ExecuteRequest = RouterAbEd25519YaoActivationExecuteRequestV1<'registration'>;
-type ActivationResult = RouterAbEd25519YaoActivationResultV1<'registration'>;
-type RegistrationExecutionAuthority = {
+/**
+ * What the Gateway checks a registration execute against before it asks the
+ * Router to run it: the admission, the intent credential that bound it and
+ * the tenant root pinned at admission, from the Gateway's ceremony record.
+ * The execution itself (its claim, its recorded answer and the finalization
+ * that consumes it) belongs to the Router's wallet object.
+ */
+export type RouterAbEd25519YaoRegistrationExecutionAuthorityV1 = {
     readonly lifecycleId: string;
     readonly admissionRequest: RouterAbEd25519YaoRegistrationAdmissionRequestV1;
     readonly admissionReceipt: AdmissionReceipt;
     readonly admissionBindingJson: string;
     readonly credentialDigestSha256Hex: string;
     readonly expiresAtMs: number;
+    readonly dispatchRoot: RouterAbEd25519YaoTenantRootWireV1;
 };
-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: {
+/**
+ * The authority of one admitted registration, or `null` if it is
+ * inconsistent. The pinned tenant root must be the one the admission names:
+ * its signing root and version.
+ */
+export declare function buildRouterAbEd25519YaoRegistrationExecutionAuthorityV1(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;
+    readonly dispatchRoot: RouterAbEd25519YaoTenantRootWireV1 | undefined;
+}): RouterAbEd25519YaoRegistrationExecutionAuthorityV1 | null;
+/**
+ * Pins the tenant root an admitted registration dispatches to, resolved once
+ * at admission. Every execute and consumption of the lifecycle sends this
+ * root, so the Router's record of a known execution answers them without a
+ * fresh active-root lookup.
+ */
+export declare function pinRouterAbEd25519YaoRegistrationDispatchRootV1(registration: InMemoryRouterAbEd25519YaoRegistrationStateV1, lifecycleId: string, dispatchRoot: RouterAbEd25519YaoTenantRootWireV1): void;
+/**
+ * The registration result the Router's answer gives for one admitted
+ * execution, verified as the in-memory service verifies a fresh one. The
+ * Gateway derives it from the Router's answer each time: at execution, and
+ * when finalization consumes the answer the Router recorded.
+ */
+export declare function routerAbEd25519YaoRegistrationResultFromRouterAnswerV1(input: {
+    readonly backend: RouterAbEd25519YaoRegistrationBackend;
+    readonly authority: RouterAbEd25519YaoRegistrationExecutionAuthorityV1;
+    readonly request: RouterAbEd25519YaoRegistrationExecuteRequestV1;
+    readonly answer: RouterAbEd25519YaoRegistrationBackendResult;
+}): RouterAbEd25519YaoRegistrationServiceResult<RouterAbEd25519YaoRegistrationResultV1>;
+/** The Gateway's execute request inside the Router request the Router recorded. */
+export declare function routerAbEd25519YaoRegistrationExecuteRequestFromRouterRequestJsonV1(requestJson: string): RouterAbEd25519YaoRegistrationExecuteRequestV1;
 export {};
 //# sourceMappingURL=routerAbEd25519YaoRegistrationExecutionRecord.d.ts.map

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

@@ -26,7 +26,7 @@ export type RouterAbEd25519YaoVerifiedRegistrationIntentV1 = {
     readonly admissionRequest: RouterAbEd25519YaoRegistrationAdmissionRequestV1;
     readonly expiresAtMs: number;
 };
-export type RouterAbEd25519YaoVerifiedAddSignerIntentV1 = {
+type RouterAbEd25519YaoVerifiedAddSignerIntentV1 = {
     readonly kind: 'verified_add_signer_intent';
     readonly addSignerIntentGrant: AddSignerIntentGrant;
     readonly intent: AddSignerIntentV1 & {
@@ -53,7 +53,7 @@ export type VerifiedNearRegistrationContinuationV1 = {
     readonly admissionRequest: RouterAbEd25519YaoRegistrationAdmissionRequestV1;
     readonly expiresAtMs: number;
 };
-export type RouterAbEd25519YaoBearerCredentialDigestResultV1 = {
+type RouterAbEd25519YaoBearerCredentialDigestResultV1 = {
     readonly ok: true;
     readonly digestSha256Hex: string;
 } | {

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

@@ -1,6 +1,6 @@
 import type { VerifiedNearRegistrationContinuationV1 } from './routerAbEd25519YaoRegistrationIntentAuthorization';
-import type { RouterAbEd25519YaoRegistrationBackend } from './routerAbEd25519YaoRegistration';
-import type { RouterAbEd25519YaoProductRegistrationPartitionedStateStoreV1 } from '../capabilityLifecycle/routerAbEd25519YaoProductRegistrationPartitionedStateStore';
+import type { RouterAbEd25519YaoPinnedRegistrationBackend } from './routerAbEd25519YaoHttpRegistrationBackend';
+import { type RouterAbEd25519YaoProductRegistrationPartitionedStateStoreV1 } from '../capabilityLifecycle/routerAbEd25519YaoProductRegistrationPartitionedStateStore';
 export type RouterAbEd25519YaoRegistrationRequestScopedCloudflareInputV1 = {
     readonly request: Request;
     readonly authorizeContinuation?: (input: {
@@ -8,7 +8,7 @@ export type RouterAbEd25519YaoRegistrationRequestScopedCloudflareInputV1 = {
         readonly credential: string;
     }) => Promise<VerifiedNearRegistrationContinuationV1 | null>;
     readonly store: RouterAbEd25519YaoProductRegistrationPartitionedStateStoreV1;
-    readonly backend: RouterAbEd25519YaoRegistrationBackend;
+    readonly backend: RouterAbEd25519YaoPinnedRegistrationBackend;
 };
 export declare function handleRouterAbEd25519YaoRegistrationRequestScopedCloudflareV1(input: RouterAbEd25519YaoRegistrationRequestScopedCloudflareInputV1): Promise<Response>;
 //# sourceMappingURL=routerAbEd25519YaoRegistrationRequestScopedCloudflare.d.ts.map