@seams/wallet-server 0.7.3 → 0.9.0

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

@@ -1,7 +1,9 @@
+import { type WalletLifecycleRoutingPublisher } from '../../../../authorization/lifecycleRouting';
 import { type RouterAbEd25519YaoCapabilityPersistenceV1, type RouterAbEd25519YaoRecoveryAuthorizationAdapter, type RouterAbEd25519YaoRecoveryBackend, type RouterAbEd25519YaoActiveCapabilityResolverV1, type WarmBootstrapLinkedEd25519AuthorityReaderV1 } from './routerAbEd25519YaoRecovery';
 export type { WarmBootstrapLinkedEd25519AuthorityReaderV1 } from './routerAbEd25519YaoRecovery';
 import type { RouterAbEd25519YaoProductRegistrationPartitionedStateStoreV1 } from '../capabilityLifecycle/routerAbEd25519YaoProductRegistrationPartitionedStateStore';
 export type RouterAbEd25519YaoRecoveryRequestScopedCloudflareInputV1 = {
+    readonly lifecycleRouting?: WalletLifecycleRoutingPublisher;
     readonly request: Request;
     readonly store: RouterAbEd25519YaoProductRegistrationPartitionedStateStoreV1;
     readonly backend: RouterAbEd25519YaoRecoveryBackend;

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

@@ -1,3 +1,4 @@
+import type { WalletExecutionAuthority } from '../../walletRegistration/walletRegistrationReservation';
 import type { RouterApiAuthorizationSessionService, RouterApiWalletRegistrationService } from '../../../framework/authServicePort';
 import type { PreparedEd25519RecoveryAdmissionV1 } from '../../passkeyCustody/walletRecoveryKeyManifest';
 import type { RouterAbEd25519YaoRecoveryAuthorizationAdapter, RouterAbEd25519YaoRecoveryAuthorizationInput, RouterAbEd25519YaoRecoveryAuthorizationResult } from './routerAbEd25519YaoRecovery';
@@ -8,6 +9,7 @@ export interface PreparedEd25519RecoveryAdmissionReaderV1 {
     }): Promise<PreparedEd25519RecoveryAdmissionV1 | null>;
 }
 export type RouterAbEd25519YaoRecoveryAuthorizationServicesV1 = {
+    readonly admitEstablishedHome: WalletExecutionAuthority['admitEstablishedHome'];
     readonly authorizationSessions: RouterApiAuthorizationSessionService;
     readonly preparedRecoveryAdmission: PreparedEd25519RecoveryAdmissionReaderV1;
     readonly resolveEd25519MaterialActivation: RouterApiWalletRegistrationService['resolveEd25519MaterialActivation'];

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

@@ -1,8 +1,9 @@
+import type { RouterAbEd25519YaoRegistrationExecutionAuthorityV1 } from './routerAbEd25519YaoRegistrationExecutionRecord';
 import { type RouterAbEd25519YaoActivationExecuteRequestV1, type RouterAbEd25519YaoActivationKeysetV1, type RouterAbEd25519YaoRecoveryActivationRequestV1, type RouterAbEd25519YaoRecoveryAdmissionRequestV1, type RouterAbEd25519YaoRegistrationAdmissionRequestV1, type RouterAbEd25519YaoExportAdmissionRequestV1, type RouterAbEd25519YaoExportExecuteRequestV1 } from '../../../../../../shared-ts/src/utils/routerAbEd25519Yao';
 import type { RouterAbEd25519YaoRegistrationBackend, RouterAbEd25519YaoRegistrationBackendResult } from './routerAbEd25519YaoRegistration';
-import type { RouterAbEd25519YaoExportBackend } from '../export/routerAbEd25519YaoExport';
-import type { RouterAbEd25519YaoRecoveryBackend } from '../recovery/routerAbEd25519YaoRecovery';
-import { type RouterAbEd25519YaoTenantRootResolverV1, type RouterAbEd25519YaoTenantRootWireV1 } from '../routerAbEd25519YaoGatewayEnvelope';
+import type { RouterAbEd25519YaoExportBackend, RouterAbEd25519YaoExportExecuteClaimV1 } from '../export/routerAbEd25519YaoExport';
+import type { RouterAbEd25519YaoRecoveryBackend, RouterAbEd25519YaoRecoveryExecuteClaimV1 } from '../recovery/routerAbEd25519YaoRecovery';
+import { type RouterAbEd25519YaoRegistrationSigningRootIdV1, type RouterAbEd25519YaoTenantRootResolverV1, type RouterAbEd25519YaoTenantRootWireV1 } from '../routerAbEd25519YaoGatewayEnvelope';
 import { type RouterAbTraceContextV1 } from '../../../../../../shared-ts/src/utils/routerAbTraceContext';
 type RouterAbEd25519YaoRegistrationExecuteRequestV1 = RouterAbEd25519YaoActivationExecuteRequestV1<'registration'>;
 type RouterAbEd25519YaoRecoveryExecuteRequestV1 = RouterAbEd25519YaoActivationExecuteRequestV1<'recovery'>;
@@ -28,14 +29,12 @@ export type RouterAbEd25519YaoGatewaySpanV1 = {
 export type RouterAbEd25519YaoHttpRegistrationBackendRawEnv = Readonly<Record<string, unknown>>;
 export declare function parseRouterAbEd25519YaoActivationKeysetFromEnvV1(env: RouterAbEd25519YaoHttpRegistrationBackendRawEnv): RouterAbEd25519YaoActivationKeysetV1;
 export interface RouterAbEd25519YaoPinnedRegistrationBackend extends RouterAbEd25519YaoRegistrationBackend {
-    resolveRegistrationDispatchRoot(admissionRequest: RouterAbEd25519YaoRegistrationAdmissionRequestV1): Promise<RouterAbEd25519YaoTenantRootWireV1>;
-    executePinnedRegistration(request: RouterAbEd25519YaoRegistrationExecuteRequestV1, admissionRequest: RouterAbEd25519YaoRegistrationAdmissionRequestV1, dispatchRoot: RouterAbEd25519YaoTenantRootWireV1, traceContext: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRegistrationBackendResult>;
+    resolveRegistrationDispatchRoot(signingRootId: RouterAbEd25519YaoRegistrationSigningRootIdV1): Promise<RouterAbEd25519YaoTenantRootWireV1>;
+    executePinnedRegistration(request: RouterAbEd25519YaoRegistrationExecuteRequestV1, authority: RouterAbEd25519YaoRegistrationExecutionAuthorityV1, traceContext: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRegistrationBackendResult>;
     consumeRegistration(input: RouterAbEd25519YaoRegistrationConsumeInputV1): Promise<RouterAbEd25519YaoRegistrationConsumeOutcomeV1>;
 }
 export type RouterAbEd25519YaoRegistrationConsumeInputV1 = {
-    readonly tenantRoot: RouterAbEd25519YaoTenantRootWireV1;
-    readonly walletId: string;
-    readonly lifecycleId: string;
+    readonly authority: RouterAbEd25519YaoRegistrationExecutionAuthorityV1;
     readonly sessionId: readonly number[];
     readonly consumerBinding: string;
 };
@@ -61,18 +60,18 @@ export declare class RouterAbEd25519YaoHttpRegistrationBackend implements Router
     admit(request: RouterAbEd25519YaoRegistrationAdmissionRequestV1, _traceContext?: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRegistrationBackendResult>;
     admitRecovery(request: RouterAbEd25519YaoRecoveryAdmissionRequestV1, _traceContext?: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRegistrationBackendResult>;
     admitExport(request: RouterAbEd25519YaoExportAdmissionRequestV1, _traceContext?: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRegistrationBackendResult>;
-    executeExport(request: RouterAbEd25519YaoExportExecuteRequestV1, admissionRequest: RouterAbEd25519YaoExportAdmissionRequestV1, traceContext?: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRegistrationBackendResult>;
+    executeExport(request: RouterAbEd25519YaoExportExecuteRequestV1, claim: RouterAbEd25519YaoExportExecuteClaimV1, traceContext?: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRegistrationBackendResult>;
     private keyset;
     private admitActivation;
-    execute(request: RouterAbEd25519YaoRegistrationExecuteRequestV1, admissionRequest: RouterAbEd25519YaoRegistrationAdmissionRequestV1, traceContext?: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRegistrationBackendResult>;
-    resolveRegistrationDispatchRoot(admissionRequest: RouterAbEd25519YaoRegistrationAdmissionRequestV1): Promise<RouterAbEd25519YaoTenantRootWireV1>;
-    executePinnedRegistration(request: RouterAbEd25519YaoRegistrationExecuteRequestV1, admissionRequest: RouterAbEd25519YaoRegistrationAdmissionRequestV1, dispatchRoot: RouterAbEd25519YaoTenantRootWireV1, traceContext: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRegistrationBackendResult>;
+    execute(request: RouterAbEd25519YaoRegistrationExecuteRequestV1, admissionRequest: RouterAbEd25519YaoRegistrationAdmissionRequestV1, ownershipGeneration: number, traceContext?: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRegistrationBackendResult>;
+    resolveRegistrationDispatchRoot(signingRootId: RouterAbEd25519YaoRegistrationSigningRootIdV1): Promise<RouterAbEd25519YaoTenantRootWireV1>;
+    executePinnedRegistration(request: RouterAbEd25519YaoRegistrationExecuteRequestV1, authority: RouterAbEd25519YaoRegistrationExecutionAuthorityV1, 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>;
+    executeRecovery(request: RouterAbEd25519YaoRecoveryExecuteRequestV1, claim: RouterAbEd25519YaoRecoveryExecuteClaimV1, traceContext?: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRegistrationBackendResult>;
     private executeRouterRequest;
     private sendRouterRequest;
-    activateRecovery(request: RouterAbEd25519YaoRecoveryActivationRequestV1, dispatchRoot: RouterAbEd25519YaoTenantRootWireV1, traceContext?: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRegistrationBackendResult>;
+    activateRecovery(request: RouterAbEd25519YaoRecoveryActivationRequestV1, dispatchRoot: RouterAbEd25519YaoTenantRootWireV1, ownershipGeneration: number, traceContext?: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRegistrationBackendResult>;
     private post;
     private headers;
     private request;

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

@@ -1,5 +1,6 @@
 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 { Variant } from '../../../../../../shared-ts/src/utils/variant';
 import { type RouterApiModule } from '../../../framework/modules';
 import type { RouterAbEd25519YaoRegistrationExecuteAdmissionContextV1, RouterAbEd25519YaoTenantRootWireV1 } from '../routerAbEd25519YaoGatewayEnvelope';
 type RouterAbEd25519YaoRegistrationAdmissionReceiptV1 = RouterAbEd25519YaoActivationAdmissionReceiptV1<'registration'>;
@@ -30,11 +31,11 @@ export type RouterAbEd25519YaoRegistrationBackendResult = {
 export interface RouterAbEd25519YaoRegistrationBackend {
     takeLastRouterServerTiming?(): string | null;
     admit(request: RouterAbEd25519YaoRegistrationAdmissionRequestV1, traceContext?: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRegistrationBackendResult> | RouterAbEd25519YaoRegistrationBackendResult;
-    execute(request: RouterAbEd25519YaoRegistrationExecuteRequestV1, admissionRequest: RouterAbEd25519YaoRegistrationExecuteAdmissionContextV1, traceContext?: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRegistrationBackendResult> | RouterAbEd25519YaoRegistrationBackendResult;
+    execute(request: RouterAbEd25519YaoRegistrationExecuteRequestV1, admissionRequest: RouterAbEd25519YaoRegistrationExecuteAdmissionContextV1, ownershipGeneration: number, traceContext?: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRegistrationBackendResult> | RouterAbEd25519YaoRegistrationBackendResult;
 }
 export interface RouterAbEd25519YaoRegistrationService {
     admit(request: RouterAbEd25519YaoRegistrationAdmissionRequestV1, traceContext?: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRegistrationServiceResult<RouterAbEd25519YaoRegistrationAdmissionReceiptV1>>;
-    execute(request: RouterAbEd25519YaoRegistrationExecuteRequestV1, traceContext?: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRegistrationServiceResult<RouterAbEd25519YaoRegistrationResultV1>>;
+    execute(request: RouterAbEd25519YaoRegistrationExecuteRequestV1, ownershipGeneration: number, traceContext?: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRegistrationServiceResult<RouterAbEd25519YaoRegistrationResultV1>>;
 }
 export type RouterAbEd25519YaoRegistrationAdmissionClaimV1 = {
     readonly kind: 'router_ab_ed25519_yao_registration_admission_claim_v1';
@@ -109,12 +110,15 @@ export type RouterAbEd25519YaoRegistrationAuthorizationInput = {
 };
 export type RouterAbEd25519YaoRegistrationAuthorizationResult = {
     ok: true;
+    ownershipGeneration: number;
 } | {
     ok: false;
+    ownershipGeneration?: never;
     status: 401 | 403 | 409 | 429 | 503;
     code: string;
     message: string;
 };
+export type RouterAbEd25519YaoRegistrationAuthorizationFailure = Variant<RouterAbEd25519YaoRegistrationAuthorizationResult, 'ok', false>;
 export interface RouterAbEd25519YaoRegistrationAuthorizationAdapter {
     authorize(input: RouterAbEd25519YaoRegistrationAuthorizationInput): Promise<RouterAbEd25519YaoRegistrationAuthorizationResult> | RouterAbEd25519YaoRegistrationAuthorizationResult;
 }
@@ -191,7 +195,7 @@ export declare class InMemoryRouterAbEd25519YaoRegistrationService implements Ro
     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>>;
+    execute(request: RouterAbEd25519YaoRegistrationExecuteRequestV1, ownershipGeneration: number, traceContext?: RouterAbTraceContextV1): Promise<RouterAbEd25519YaoRegistrationServiceResult<RouterAbEd25519YaoRegistrationResultV1>>;
     prepareExecute(request: RouterAbEd25519YaoRegistrationExecuteRequestV1): RouterAbEd25519YaoRegistrationExecutePreparationV1;
     commitExecute(input: RouterAbEd25519YaoRegistrationExecuteCommitInputV1): RouterAbEd25519YaoRegistrationServiceResult<RouterAbEd25519YaoRegistrationResultV1>;
     consumeActivated(request: RouterAbEd25519YaoActivationConsumptionRequestV1): RouterAbEd25519YaoActivationConsumptionResultV1;

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

@@ -11,6 +11,7 @@ type AdmissionReceipt = RouterAbEd25519YaoActivationAdmissionReceiptV1<'registra
  * that consumes it) belongs to the Router's wallet object.
  */
 export type RouterAbEd25519YaoRegistrationExecutionAuthorityV1 = {
+    readonly ownershipGeneration: number;
     readonly lifecycleId: string;
     readonly admissionRequest: RouterAbEd25519YaoRegistrationAdmissionRequestV1;
     readonly admissionReceipt: AdmissionReceipt;

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

@@ -1,7 +1,8 @@
 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';
+import type { RouterAbEd25519YaoRegistrationAuthorizationAdapter, RouterAbEd25519YaoRegistrationAuthorizationInput, RouterAbEd25519YaoRegistrationAuthorizationFailure, RouterAbEd25519YaoRegistrationAuthorizationResult } from './routerAbEd25519YaoRegistration';
 type AvailableIntentAuthority = {
+    readonly ownershipGeneration: number;
     readonly kind: 'available';
     readonly purpose: RouterAbEd25519YaoActivationIntentPurposeV1;
     readonly credentialDigestSha256: Uint8Array;
@@ -10,6 +11,7 @@ type AvailableIntentAuthority = {
     readonly expiresAtMs: number;
 };
 type AdmittedIntentAuthority = {
+    readonly ownershipGeneration: number;
     readonly kind: 'admitted';
     readonly purpose: RouterAbEd25519YaoActivationIntentPurposeV1;
     readonly credentialDigestSha256: Uint8Array;
@@ -20,6 +22,7 @@ type AdmittedIntentAuthority = {
 type IntentAuthority = AvailableIntentAuthority | AdmittedIntentAuthority;
 type RouterAbEd25519YaoActivationIntentPurposeV1 = 'wallet_registration' | 'wallet_add_signer';
 export type RouterAbEd25519YaoVerifiedRegistrationIntentV1 = {
+    readonly ownershipGeneration: number;
     readonly kind: 'verified_registration_intent';
     readonly registrationIntentGrant: RegistrationIntentGrant;
     readonly intent: RegistrationIntentV1;
@@ -27,6 +30,7 @@ export type RouterAbEd25519YaoVerifiedRegistrationIntentV1 = {
     readonly expiresAtMs: number;
 };
 type RouterAbEd25519YaoVerifiedAddSignerIntentV1 = {
+    readonly ownershipGeneration: number;
     readonly kind: 'verified_add_signer_intent';
     readonly addSignerIntentGrant: AddSignerIntentGrant;
     readonly intent: AddSignerIntentV1 & {
@@ -72,6 +76,7 @@ export declare class InMemoryRouterAbEd25519YaoRegistrationIntentAuthorizationAd
     constructor(state?: InMemoryRouterAbEd25519YaoRegistrationIntentAuthorizationStateV1);
     bindVerifiedIntent(verified: RouterAbEd25519YaoVerifiedActivationIntentV1): Promise<RouterAbEd25519YaoRegistrationIntentBindingResult>;
     bindVerifiedContinuation(verified: VerifiedNearRegistrationContinuationV1): Promise<RouterAbEd25519YaoRegistrationIntentBindingResult>;
+    bindAndAuthorizeAdmission(input: RouterAbEd25519YaoVerifiedActivationIntentV1): Promise<RouterAbEd25519YaoRegistrationIntentBindingResult | RouterAbEd25519YaoRegistrationAuthorizationFailure>;
     authorize(input: RouterAbEd25519YaoRegistrationAuthorizationInput): Promise<RouterAbEd25519YaoRegistrationAuthorizationResult>;
     private authorizeAdmission;
     private authorizeExecution;

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

@@ -1,4 +1,5 @@
 import type { VersionedJsonRecordPutResult, VersionedJsonRecordReadResult } from '../../../framework/versionedJsonRecordStore';
+import type { RouterAbEd25519YaoPreparedWriteV1 } from '../capabilityLifecycle/routerAbEd25519YaoProductRegistrationPartitionedStateStore';
 export type RouterAbEd25519YaoRegistrationSideEffectOperationV1 = 'finalize' | 'registration_activate' | 'near_provisioning' | 'registration_start' | 'add_signer_start' | 'add_signer_finalize';
 type RouterAbEd25519YaoRetryableSideEffectFailureV1 = {
     readonly ok: false;
@@ -54,6 +55,8 @@ export type RouterAbEd25519YaoRegistrationSideEffectRecordV2<C, P> = RouterAbEd2
 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>;
+    /** As `put`, with another store's write that commits in the same batch or not at all. */
+    putWithCompanion(key: string, value: RouterAbEd25519YaoRegistrationSideEffectRecordV2<C, P>, expectedVersion: string | null, companionWrite: RouterAbEd25519YaoPreparedWriteV1): Promise<VersionedJsonRecordPutResult>;
 }
 export declare function parseRouterAbEd25519YaoRegistrationSideEffectRecordV2<C, P>(raw: unknown, input: {
     readonly operation: RouterAbEd25519YaoRegistrationSideEffectOperationV1;
@@ -111,6 +114,8 @@ type RouterAbEd25519YaoRegistrationSideEffectRunInputV2<T, C, P> = {
     readonly kind: 'prepared_resumable';
     readonly operation: RouterAbEd25519YaoRegistrationSideEffectOperationV1;
     readonly key: string;
+    /** Read for this request. CAS reconciliation always reads the store again. */
+    readonly initialRecord: VersionedJsonRecordReadResult<RouterAbEd25519YaoRegistrationSideEffectRecordV2<C, P>>;
     readonly requestFingerprint: string;
     readonly resumeAfterMs: number;
     readonly nowMs: () => number;
@@ -118,6 +123,12 @@ type RouterAbEd25519YaoRegistrationSideEffectRunInputV2<T, C, P> = {
     readonly derivePreparedArtifactFingerprint: (prepared: P) => Promise<string>;
     readonly execute: (prepared: P, attempt: RouterAbEd25519YaoRegistrationSideEffectAttemptV1) => Promise<T>;
     readonly projectReceipt: (response: T) => Promise<C> | C;
+    /**
+     * Another store's write that the execution left for its completion, or
+     * none. It commits with the completion record: a completed operation
+     * implies that write, and a lost completion leaves it undone.
+     */
+    readonly completionWrite: (response: T) => RouterAbEd25519YaoPreparedWriteV1 | null;
     readonly replay: (receipt: C) => Promise<T>;
 };
 type RouterAbEd25519YaoRegistrationSideEffectRunResultV2<T, P> = RouterAbEd25519YaoRegistrationSideEffectRunResultV1<T, P>;

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

@@ -11,10 +11,19 @@ export type RouterAbEd25519YaoTenantRootWireV1 = {
 };
 export declare function parseRouterAbEd25519YaoTenantRootWireV1(input: unknown): RouterAbEd25519YaoTenantRootWireV1 | null;
 export declare function routerAbEd25519YaoTenantRootWireV1(root: RouterAbEd25519YaoResolvedTenantRootV1): Promise<RouterAbEd25519YaoTenantRootWireV1>;
-export type RouterAbEd25519YaoTenantRootResolutionInputV1 = {
+/**
+ * Identifies the signing root that a registration is created under. Its
+ * tenant root depends on these two values alone, so it can be read before the
+ * admission request exists.
+ */
+export type RouterAbEd25519YaoRegistrationSigningRootIdV1 = {
+    readonly signing_root_id: string;
+    readonly root_share_epoch: string;
+};
+export declare function routerAbEd25519YaoRegistrationSigningRootIdV1(admissionRequest: RouterAbEd25519YaoRegistrationAdmissionRequestV1): RouterAbEd25519YaoRegistrationSigningRootIdV1;
+export type RouterAbEd25519YaoTenantRootResolutionInputV1 = ({
     readonly operation: 'registration';
-    readonly admissionRequest: RouterAbEd25519YaoRegistrationAdmissionRequestV1;
-} | {
+} & RouterAbEd25519YaoRegistrationSigningRootIdV1) | {
     readonly operation: 'recovery';
     readonly admissionRequest: RouterAbEd25519YaoRecoveryAdmissionRequestV1;
 } | {

package/dist/types/wallet-server/src/router/domains/passkeyCustody/passkeyCustodyEnvelopeRetrieval.d.ts

@@ -60,10 +60,8 @@ export type PasskeyCustodyEnvelopeRetrievalResult = {
     readonly kind: 'credential_mismatch';
 } | {
     readonly kind: 'retired';
-    readonly retiredAtMs: number;
 } | {
     readonly kind: 'revoked';
-    readonly revokedAtMs: number;
 } | {
     readonly kind: 'missing';
 } | {

package/dist/types/wallet-server/src/router/domains/passkeyCustody/registrationCustodyOutcome.d.ts

@@ -5,12 +5,13 @@ import type { WalletCustodyCeremonyCommitPayload } from './walletCustodyRegistra
 import { type VerifiedEmailOtpEnrollmentFacts } from './verifiedCustodyFactor';
 import type { CloudflareD1WalletCustodyCommitStore } from '../../cloudflare/d1/passkeyCustody/d1WalletCustodyCommitStore';
 /**
- * The whole custody side-effect of one registration leg, in one call: resolve
- * the factor from the authority the leg verified, then admit the payload
- * against the wallet the leg registered.
+ * The whole custody side-effect of one registration leg, in two steps: resolve
+ * the factor from the authority the leg verified and admit the payload against
+ * the wallet the leg registers, which claims the recovery-code routes; then
+ * store the records once that wallet is committed.
  *
  * **Activation never fails because of custody.** The wallet's registration is
- * already committed by the time this runs, and the seed exists only in the
+ * already committed by the time the records are stored, and the seed exists only in the
  * client's worker — so the client is the one party that can retry, re-enter as
  * a join, or abandon the run. Failing activation here would leave the server
  * registered, the response an error, and the client with no instruction; the
@@ -25,7 +26,10 @@ import type { CloudflareD1WalletCustodyCommitStore } from '../../cloudflare/d1/p
  * payload it answers.
  */
 type RegistrationCustodyOutcome = WalletCustodyRegistrationOutcome;
-export declare function commitRegistrationCustody(input: {
+/** Stores the admitted custody records. It reports every failure and never throws. */
+export type RegistrationCustodyCommit = () => Promise<RegistrationCustodyOutcome>;
+/** Admits the custody payload and claims its routes. It never throws either. */
+export declare function reserveRegistrationCustody(input: {
     /** Absent when the client did not run a custody ceremony for this leg. */
     readonly payload?: WalletCustodyCeremonyCommitPayload;
     readonly verifiedWalletId: WalletId;
@@ -34,6 +38,6 @@ export declare function commitRegistrationCustody(input: {
     readonly verifiedEmailOtpEnrollment?: VerifiedEmailOtpEnrollmentFacts;
     readonly nowMs: number;
     readonly store: CloudflareD1WalletCustodyCommitStore;
-}): Promise<RegistrationCustodyOutcome>;
+}): Promise<RegistrationCustodyCommit>;
 export {};
 //# sourceMappingURL=registrationCustodyOutcome.d.ts.map

package/dist/types/wallet-server/src/router/domains/passkeyCustody/walletCustodyRegistrationAdmission.d.ts

@@ -1,6 +1,6 @@
 import type { WalletId } from '../../../../../shared-ts/src/utils/domainIds';
 import type { WalletCustodyEnvelopeFactor } from '../../../../../shared-ts/src/passkey-custody';
-import { type WalletCustodyCeremonyCommitPayload, type WalletCustodyRegistrationCommitOutcome } from './walletCustodyRegistrationCommit';
+import { type WalletCustodyCeremonyCommitPayload, type WalletCustodyRegistrationCommitOutcome, type WalletCustodyRegistrationReserved } from './walletCustodyRegistrationCommit';
 import type { CloudflareD1WalletCustodyCommitStore } from '../../cloudflare/d1/passkeyCustody/d1WalletCustodyCommitStore';
 /**
  * Admits one ceremony's custody commit against a registration this server has
@@ -12,7 +12,7 @@ import type { CloudflareD1WalletCustodyCommitStore } from '../../cloudflare/d1/p
  * leg's own auth proof. A separate endpoint would be a second, weaker way in.
  *
  * This module is where that decision is enforced, and it is deliberately the
- * only path to `commitWalletCustodyRegistration` from a route. Two checks, both
+ * only path to `reserveWalletCustodyRegistration` from a route. Two checks, both
  * cheap and both load-bearing:
  *
  * 1. **The payload names the wallet the registration named.** A ceremony
@@ -52,6 +52,13 @@ type WalletCustodyRegistrationAdmissionInput = {
     readonly nowMs: number;
     readonly store: CloudflareD1WalletCustodyCommitStore;
 };
-export declare function admitWalletCustodyRegistrationCommit(input: WalletCustodyRegistrationAdmissionInput): Promise<WalletCustodyRegistrationAdmissionOutcome>;
+/**
+ * An admitted commit with its recovery-code routes claimed, or the outcome
+ * that ends the admission with nothing claimed or written.
+ */
+export type WalletCustodyRegistrationAdmission = WalletCustodyRegistrationReserved | Extract<WalletCustodyRegistrationAdmissionOutcome, {
+    kind: 'rejected' | 'no_custody_records';
+}>;
+export declare function admitWalletCustodyRegistrationCommit(input: WalletCustodyRegistrationAdmissionInput): Promise<WalletCustodyRegistrationAdmission>;
 export {};
 //# sourceMappingURL=walletCustodyRegistrationAdmission.d.ts.map

package/dist/types/wallet-server/src/router/domains/passkeyCustody/walletCustodyRegistrationCommit.d.ts

@@ -1,5 +1,4 @@
 import { type WalletCustodyCeremonyCommitPayload } from '../../../../../shared-ts/src/passkey-custody';
-import { type WalletId } from '../../../../../shared-ts/src/utils/domainIds';
 export type { WalletCustodyCeremonyCommitPayload };
 import type { CloudflareD1WalletCustodyCommitStore, WalletCustodyRegistrationCommitResult } from '../../cloudflare/d1/passkeyCustody/d1WalletCustodyCommitStore';
 export type WalletCustodyRegistrationCommitOutcome = ({
@@ -8,7 +7,6 @@ export type WalletCustodyRegistrationCommitOutcome = ({
     kind: 'committed';
 }>, 'kind'>) | {
     readonly kind: 'already_exists';
-    readonly key: string;
 }
 /**
  * Another ceremony established this wallet's custody first. The route should
@@ -17,23 +15,29 @@ export type WalletCustodyRegistrationCommitOutcome = ({
  */
  | {
     readonly kind: 'custody_already_established';
-    readonly walletId: WalletId;
 } | {
     readonly kind: 'rejected';
     readonly reason: string;
 };
+/** The write that a reservation left for after the registration's wallet commit. */
+export type WalletCustodyRegistrationReserved = {
+    readonly kind: 'reserved';
+    readonly commit: () => Promise<WalletCustodyRegistrationCommitOutcome>;
+};
 /**
- * Builds and commits in one call.
+ * Builds the records and claims their recovery-code routes.
  *
  * A payload this server cannot parse becomes `rejected` rather than an
  * exception, so a malformed ceremony result is a request outcome and not a
- * route crash. Nothing is written in that case: the records are built before
- * the store is touched.
+ * route crash. Nothing is claimed or written in that case: the records are
+ * built before the store is touched.
  */
-export declare function commitWalletCustodyRegistration(input: {
+export declare function reserveWalletCustodyRegistration(input: {
     readonly payload: WalletCustodyCeremonyCommitPayload;
     readonly factor: unknown;
     readonly nowMs: number;
     readonly store: CloudflareD1WalletCustodyCommitStore;
-}): Promise<WalletCustodyRegistrationCommitOutcome>;
+}): Promise<WalletCustodyRegistrationReserved | Extract<WalletCustodyRegistrationCommitOutcome, {
+    kind: 'rejected';
+}>>;
 //# sourceMappingURL=walletCustodyRegistrationCommit.d.ts.map

package/dist/types/wallet-server/src/router/domains/signingOperations/authorizedOperationWire.d.ts

@@ -0,0 +1,97 @@
+import type { Ed25519ReusableAuthorizedOperationReceipt } from './ed25519AuthorizedOperationReceipt';
+import type { AuthorizedOperation } from '../../../authorization/domain';
+export type AuthorizedOperationBindingWire = {
+    readonly kind: 'reusable_wallet_session';
+    readonly authorization_id: string;
+    readonly wallet_session_id: string;
+    readonly quota_id: string;
+} | {
+    readonly kind: 'gateway_owner_wallet_session';
+    readonly ownership_generation: number;
+    readonly subject_id: string;
+    readonly account_id: string;
+    readonly authorization_id: string;
+    readonly wallet_session_id: string;
+    readonly quota_id: string;
+    readonly threshold_session_id: string;
+    readonly org_id: string;
+    readonly project_id: string;
+    readonly environment: string;
+    readonly project_environment_id: string;
+    readonly signing_worker_id: string;
+    readonly expires_at_ms: number;
+} | {
+    readonly kind: 'operation_step_up';
+    readonly ownership_generation: number;
+    readonly authorization_session_id: string;
+    readonly org_id: string;
+    readonly project_id: string;
+    readonly environment: string;
+    readonly project_environment_id: string;
+    readonly subject_id: string;
+    readonly account_id: string;
+};
+export type AuthorizedOperationWireInput = {
+    readonly operation: AuthorizedOperation;
+    readonly binding: {
+        readonly kind: 'reusable_wallet_session';
+        readonly walletSessionId: string;
+        readonly quotaId: string;
+    };
+} | {
+    readonly operation: AuthorizedOperation;
+    readonly binding: {
+        readonly kind: 'gateway_owner_wallet_session';
+        readonly ownershipGeneration: number;
+        readonly subjectId: string;
+        readonly accountId: string;
+        readonly authorizationId: string;
+        readonly walletSessionId: string;
+        readonly quotaId: string;
+        readonly thresholdSessionId: string;
+        readonly orgId: string;
+        readonly projectId: string;
+        readonly environment: string;
+        readonly projectEnvironmentId: string;
+        readonly signingWorkerId: string;
+        readonly expiresAtMs: number;
+    };
+} | {
+    readonly operation: AuthorizedOperation;
+    readonly binding: OperationStepUpBinding;
+};
+export type OperationStepUpBinding = {
+    readonly kind: 'operation_step_up';
+    readonly ownershipGeneration: number;
+    readonly authorizationSessionId: string;
+    readonly orgId: string;
+    readonly projectId: string;
+    readonly environment: string;
+    readonly projectEnvironmentId: string;
+    readonly subjectId: string;
+    readonly accountId: string;
+};
+type AuthorizedOperationFields = {
+    readonly authorized_operation_id: string;
+    readonly operation_id: string;
+    readonly lane_digest_b64u: string;
+    readonly intent_digest_b64u: string;
+    readonly display_digest_b64u: string;
+    readonly operation_fingerprint_digest: string;
+} & ({
+    readonly capability_kind: 'evm_ecdsa_mpc_signing';
+    readonly operation_kind: 'evm.sign_transaction';
+} | Pick<Ed25519ReusableAuthorizedOperationReceipt, 'capability_kind' | 'operation_kind'>);
+type AuthorizedOperationWire<T extends AuthorizedOperationFields> = {
+    readonly binding: AuthorizedOperationBindingWire;
+    readonly authorized_operation: (T & {
+        readonly kind: 'reusable_wallet_session_authorized_operation_v1';
+    }) | (T & {
+        readonly kind: 'verified_step_up_authorized_operation_v1';
+        readonly authorization_session_id: string;
+        readonly evidence_set_digest: string;
+    });
+};
+export declare function buildAuthorizedOperationWire<T extends AuthorizedOperationFields>(input: AuthorizedOperationWireInput, commonAuthorizedOperation: T): AuthorizedOperationWire<T>;
+export {};
+//# sourceMappingURL=authorizedOperationWire.d.ts.map

package/dist/types/wallet-server/src/router/domains/signingOperations/ecdsaSigningResponse.d.ts

@@ -0,0 +1,13 @@
+import type { AuthorizedOperation } from '../../../authorization/domain';
+import type { RouterApiAuthorizedOperationService } from '../../framework/authServicePort';
+export declare function finishRouterAbEcdsaSigningResponse(input: {
+    readonly upstream: Response;
+    readonly operation: AuthorizedOperation;
+    readonly authorizedOperations: RouterApiAuthorizedOperationService;
+    readonly timing: {
+        proxy: number | null;
+        complete: number | null;
+    };
+    readonly proxyStartedAt: number;
+}): Promise<Response>;
+//# sourceMappingURL=ecdsaSigningResponse.d.ts.map