@seams/wallet-server 0.5.0

package/dist/types/wallet-server/src/router/cloudflare/runtime/walletControlOps.d.ts

@@ -0,0 +1,21 @@
+import type { CloudflareServiceBindingFetcher } from './routerAbServiceBindings';
+import type { WalletRuntimeServiceBinding } from './walletRuntimeOps';
+export declare const WALLET_CONTROL_SERVICE_ORIGIN_V1 = "https://wallet-runtime.internal";
+export declare const WALLET_CONTROL_BASE_PATH_V1 = "/internal/wallet-runtime/v1/tenant-root-control";
+export declare const WALLET_CONTROL_AUTH_MARKER_V1 = "wallet-control-private-binding-v1";
+export interface WalletControlRuntimeBindings {
+    readonly MPC_ROUTER: CloudflareServiceBindingFetcher;
+    readonly TENANT_ROOT_CONTROL_PLANE: CloudflareServiceBindingFetcher;
+    readonly DERIVER_A: CloudflareServiceBindingFetcher;
+    readonly DERIVER_B: CloudflareServiceBindingFetcher;
+    readonly ROUTER_AB_INTERNAL_SERVICE_AUTH_SECRET?: string;
+}
+export interface WalletControlClientBindings {
+    readonly router: CloudflareServiceBindingFetcher;
+    readonly controlPlane: CloudflareServiceBindingFetcher;
+    readonly deriverA: CloudflareServiceBindingFetcher;
+    readonly deriverB: CloudflareServiceBindingFetcher;
+}
+export declare function createWalletControlClientBindings(binding: WalletRuntimeServiceBinding): WalletControlClientBindings;
+export declare function handleWalletControlRequest(request: Request, env: WalletControlRuntimeBindings): Promise<Response | null>;
+//# sourceMappingURL=walletControlOps.d.ts.map

package/dist/types/wallet-server/src/router/cloudflare/runtime/walletGateway.d.ts

@@ -0,0 +1,30 @@
+import { type CloudflareD1RouterAbNormalSigningAdmissionStoreOptions } from '../d1/signingAdmission/d1RouterAbNormalSigningAdmissionStore';
+import type { RouterApiOptions } from '../../framework/routerApi';
+import type { RouteDefinition } from '../../framework/routeDefinitions';
+import type { RouterApiRouteExtension } from '../../framework/routeExtensions';
+import type { FetchHandler } from './cloudflare.types';
+import { createCloudflareRouter } from './createCloudflareRouter';
+import { type WalletConsoleServiceBinding } from './walletConsoleOpsClient';
+export declare const WALLET_CONSOLE_API_WALLET_DETAIL_PREFIX_V1 = "/v1/wallets/";
+export declare const WALLET_CONSOLE_SIGNED_DELEGATE_ROUTE_ID_V1 = "signed_delegate";
+export declare const WALLET_CONSOLE_SPONSORED_EVM_CALL_ROUTE_ID_V1 = "sponsored_evm_call";
+export declare const DEFAULT_WALLET_CONSOLE_SIGNED_DELEGATE_ROUTE_V1 = "/signed-delegate";
+export declare const DEFAULT_WALLET_CONSOLE_SPONSORED_EVM_CALL_ROUTE_V1 = "/sponsorships/evm/call";
+export declare function walletConsoleApiWalletListRouteDefinitionV1(): RouteDefinition;
+export declare function walletConsoleApiWalletSearchRouteDefinitionV1(): RouteDefinition;
+export declare function walletConsoleApiWalletGetRouteDefinitionV1(): RouteDefinition;
+export declare function walletConsoleSignedDelegateRouteDefinitionV1(routePath: string): RouteDefinition;
+export declare function walletConsoleSponsoredEvmCallRouteDefinitionV1(routePath?: string): RouteDefinition;
+export declare function walletConsoleRelayRouteDefinitionsV1(): readonly RouteDefinition[];
+export declare function createWalletConsoleRelayProxyExtensionV1(binding: WalletConsoleServiceBinding): RouterApiRouteExtension;
+type WalletGatewayManagedRouterOption = 'apiKeyAuth' | 'publishableKeyAuth' | 'apiKeyUsageMeter' | 'orgProjectEnv' | 'routerAbNormalSigningAdmission' | 'routeExtensions';
+export interface CloudflareWalletGatewayRouterOptionsV1 {
+    readonly service: Parameters<typeof createCloudflareRouter>[0];
+    readonly walletConsole: WalletConsoleServiceBinding;
+    readonly signerDatabase: CloudflareD1RouterAbNormalSigningAdmissionStoreOptions['database'];
+    readonly signerStorageNamespace: string;
+    readonly router: Omit<RouterApiOptions, WalletGatewayManagedRouterOption>;
+}
+export declare function createCloudflareWalletGatewayRouterV1(input: CloudflareWalletGatewayRouterOptionsV1): FetchHandler;
+export {};
+//# sourceMappingURL=walletGateway.d.ts.map

package/dist/types/wallet-server/src/router/cloudflare/runtime/walletRuntimeOps.d.ts

@@ -0,0 +1,64 @@
+import type { RelayedSignedDelegate } from '../../../../../shared-ts/src/near/delegate';
+export interface WalletRuntimeDelegatePolicy {
+    readonly allowedReceivers?: string[];
+    readonly allowedMethods?: string[];
+    readonly maxTotalDepositYocto?: string;
+}
+export interface WalletRuntimeExecuteSignedDelegateRequest {
+    readonly hash: string;
+    readonly signedDelegate: RelayedSignedDelegate;
+    readonly policy?: WalletRuntimeDelegatePolicy;
+}
+export type WalletRuntimeExecuteSignedDelegateResult = {
+    readonly ok: true;
+    readonly transactionHash?: string;
+    readonly outcome?: unknown;
+} | {
+    readonly ok: false;
+    readonly error?: string;
+    readonly code?: string;
+    readonly outcome?: unknown;
+};
+export declare function parseWalletRuntimeExecuteSignedDelegateRequest(value: unknown): WalletRuntimeExecuteSignedDelegateRequest | null;
+export declare function parseWalletRuntimeExecuteSignedDelegateResult(value: unknown): WalletRuntimeExecuteSignedDelegateResult | null;
+export declare function parseWalletRuntimeExecuteSignedDelegateResponse(value: unknown): WalletRuntimeExecuteSignedDelegateResult | null;
+export declare function parseWalletRuntimeRelayerAccount(value: unknown): {
+    accountId: string;
+    publicKey: string;
+} | null;
+export interface WalletRuntimeWalletIdentityRequest {
+    readonly orgId: string;
+    readonly wallets: readonly {
+        readonly walletId: string;
+        readonly projectId: string;
+    }[];
+}
+export interface WalletRuntimeWalletIdentity {
+    readonly walletId: string;
+    readonly nearAccountId: string;
+    readonly evmAddress: `0x${string}`;
+}
+export interface WalletRuntimeWalletIdentitiesResult {
+    readonly identities: readonly WalletRuntimeWalletIdentity[];
+}
+export declare function parseWalletRuntimeWalletIdentityRequest(value: unknown): WalletRuntimeWalletIdentityRequest | null;
+export declare function parseWalletRuntimeWalletIdentitiesResult(value: unknown): WalletRuntimeWalletIdentitiesResult | null;
+export declare const WALLET_RUNTIME_SERVICE_ORIGIN_V1 = "https://wallet-runtime.internal";
+export declare const WALLET_RUNTIME_OPS_BASE_PATH_V1 = "/internal/wallet-runtime/v1";
+export declare const WALLET_RUNTIME_OP_PATHS_V1: {
+    readonly executeSignedDelegate: "/internal/wallet-runtime/v1/execute-signed-delegate";
+    readonly relayerAccount: "/internal/wallet-runtime/v1/relayer-account";
+    readonly walletIdentities: "/internal/wallet-runtime/v1/wallet-identities";
+};
+export interface WalletRuntimeOps {
+    readonly executeSignedDelegate: (input: WalletRuntimeExecuteSignedDelegateRequest) => Promise<WalletRuntimeExecuteSignedDelegateResult>;
+    readonly getRelayerAccount: () => Promise<{
+        accountId: string;
+        publicKey: string;
+    }>;
+    readonly getWalletIdentities: (input: WalletRuntimeWalletIdentityRequest) => Promise<WalletRuntimeWalletIdentitiesResult>;
+}
+export interface WalletRuntimeServiceBinding {
+    fetch(input: Request | string, init?: RequestInit): Promise<Response>;
+}
+//# sourceMappingURL=walletRuntimeOps.d.ts.map

package/dist/types/wallet-server/src/router/cloudflare/runtime/walletRuntimeOpsHandler.d.ts

@@ -0,0 +1,3 @@
+import { type WalletRuntimeOps } from './walletRuntimeOps';
+export declare function createWalletRuntimeOpsHandler(resolveOps: () => Promise<WalletRuntimeOps>): (request: Request) => Promise<Response | null>;
+//# sourceMappingURL=walletRuntimeOpsHandler.d.ts.map

package/dist/types/wallet-server/src/router/cloudflare/signingLanes/cloudflareLaneCurveExecution.d.ts

@@ -0,0 +1,217 @@
+import type { EcdsaAdditiveLaneHolderRoundV1, EcdsaAdditiveLaneJobV1, Ed25519YaoLaneJobV1, LaneHolderDeliveryReceiptV1, LaneProtocolCommitReceiptV1, LaneServerActivationReceiptV1, LaneServerRetirementReceiptV1, LaneHolderPackageWireV1, LaneProductEpochActiveV1, RevokeSigningLaneV1 } from '../../../../../shared-ts/src/signing-lanes';
+import { type DigestB64u } from '../../../../../shared-ts/src/utils/canonicalPrimitives';
+import { type MpcMaterialActivationRef } from '../../../../../shared-ts/src/utils/domainIds';
+import type { LaneLifecycleCurveExecutionPortsV1 } from '../../../core/signingLanes/LaneLifecycleApplicationService';
+import type { LaneLifecycleStore, LaneProductEpochLookup } from '../../../core/signingLanes/LaneLifecycleStore';
+import type { WalletEcdsaSignerRecord } from '../../../core/WalletStore';
+import { type EcdsaServerRetirementBindingV1 } from '../../../core/signingLanes/ecdsaServerRetirement';
+import { type Ed25519ServerRetirementBindingV1 } from '../../../core/signingLanes/ed25519ServerRetirement';
+import type { EcdsaSigningWorkerLaneMaterialIdentityV1, SigningWorkerLaneMaterialIdentityV1 } from '../../../core/signingLanes/signingWorkerLaneMaterialIdentity';
+import type { CloudflareEd25519LaneProtocolTransportV1 } from './cloudflareLaneProtocolCommitter';
+type LaneMaterialMutationOutcomeV1 = 'applied' | 'replayed';
+export type SigningWorkerLaneProtocolCommitProjectionV1 = {
+    readonly kind: 'signing_worker_lane_protocol_commit_projection_v1';
+    readonly outcome: LaneMaterialMutationOutcomeV1;
+    readonly receipt: LaneProtocolCommitReceiptV1;
+};
+export type SigningWorkerLaneServerActivationProjectionV1 = {
+    readonly kind: 'signing_worker_lane_server_activation_projection_v1';
+    readonly outcome: LaneMaterialMutationOutcomeV1;
+    readonly receipt: LaneServerActivationReceiptV1;
+};
+export type SigningWorkerLaneRetirementProjectionV1 = {
+    readonly kind: 'signing_worker_lane_retirement_projection_v1';
+    readonly outcome: LaneMaterialMutationOutcomeV1;
+    readonly command: RevokeSigningLaneV1;
+    readonly retirementEffectBindingDigestB64u: string;
+    readonly retirementReceipt: LaneServerRetirementReceiptV1;
+};
+/**
+ * Receipt-only projection of the private SigningWorker material journal. The
+ * encrypted active record and all plaintext material are intentionally absent.
+ */
+export interface SigningWorkerLaneMaterialReceiptPortV1 {
+    commitEcdsaProtocolV1(input: {
+        readonly job: EcdsaAdditiveLaneJobV1;
+        readonly holderRound: EcdsaAdditiveLaneHolderRoundV1;
+        readonly holderPackage: Extract<LaneHolderPackageWireV1, {
+            kind: 'ecdsa_additive_lane_holder_package_v1';
+        }>;
+        readonly encryptedDeltaPackageJson: string;
+    }): Promise<SigningWorkerLaneProtocolCommitProjectionV1>;
+    activateServerMaterialV1(input: {
+        readonly curve: 'ed25519_yao';
+        readonly job: Ed25519YaoLaneJobV1;
+        readonly protocolCommitReceipt: LaneProtocolCommitReceiptV1;
+        readonly holderDeliveryReceipt: LaneHolderDeliveryReceiptV1;
+    } | {
+        readonly curve: 'ecdsa_additive';
+        readonly job: EcdsaAdditiveLaneJobV1;
+        readonly protocolCommitReceipt: LaneProtocolCommitReceiptV1;
+        readonly holderDeliveryReceipt: LaneHolderDeliveryReceiptV1;
+    }): Promise<SigningWorkerLaneServerActivationProjectionV1>;
+    retireServerMaterialV1(input: {
+        readonly curve: 'ed25519_yao' | 'ecdsa_additive';
+        readonly command: RevokeSigningLaneV1;
+    }): Promise<SigningWorkerLaneRetirementProjectionV1>;
+}
+export declare const CLOUDFLARE_SIGNING_WORKER_ECDSA_LANE_EXECUTE_PATH_V1: "/router-ab/internal/signing-worker/ecdsa-additive-lane/execute";
+export declare const CLOUDFLARE_SIGNING_WORKER_ECDSA_LANE_ACTIVATE_PATH_V1: "/router-ab/internal/signing-worker/ecdsa-additive-lane/activate";
+export declare const CLOUDFLARE_SIGNING_WORKER_ED25519_YAO_LANE_ACTIVATE_PATH_V1: "/router-ab/internal/signing-worker/ed25519-yao-lane/activate";
+export declare const CLOUDFLARE_SIGNING_WORKER_ECDSA_LANE_RETIRE_PATH_V1: "/router-ab/internal/signing-worker/ecdsa-additive-lane/retire";
+export declare const CLOUDFLARE_SIGNING_WORKER_ED25519_YAO_LANE_RETIRE_PATH_V1: "/router-ab/internal/signing-worker/ed25519-yao-lane/retire";
+export interface EcdsaLanePrivateBindingResolverPortV1 {
+    resolveSourceMaterialV1(input: {
+        readonly job: EcdsaAdditiveLaneJobV1;
+    }): Promise<CloudflareEcdsaLaneSourceMaterialV1>;
+    resolveActivationBindingV1(input: {
+        readonly job: EcdsaAdditiveLaneJobV1;
+        readonly protocolCommitReceipt: LaneProtocolCommitReceiptV1;
+    }): Promise<{
+        readonly identity: EcdsaSigningWorkerLaneMaterialIdentityV1;
+        readonly targetMaterialActivation: MpcMaterialActivationRef;
+    }>;
+    resolveRetirementBindingV1(input: {
+        readonly command: RevokeSigningLaneV1;
+    }): Promise<EcdsaServerRetirementBindingV1>;
+}
+export interface Ed25519LanePrivateBindingResolverPortV1 {
+    resolveRetirementBindingV1(input: {
+        readonly command: RevokeSigningLaneV1;
+    }): Promise<Ed25519ServerRetirementBindingV1>;
+}
+export declare class LaneLifecycleStoreEd25519LanePrivateBindingResolverV1 implements Ed25519LanePrivateBindingResolverPortV1 {
+    private readonly lifecycleStore;
+    constructor(lifecycleStore: Pick<LaneLifecycleStore, 'getProductEpoch' | 'getProtocol'>);
+    resolveRetirementBindingV1(input: {
+        readonly command: RevokeSigningLaneV1;
+    }): Promise<Ed25519ServerRetirementBindingV1>;
+}
+export type CloudflareEcdsaLaneSourceMaterialV1 = {
+    readonly kind: 'lane_material';
+    readonly lookup: {
+        readonly identity: EcdsaSigningWorkerLaneMaterialIdentityV1;
+        readonly admittedLaneIdentityDigestB64u: DigestB64u;
+    };
+} | {
+    readonly kind: 'registration_activation';
+    readonly lookup: {
+        readonly accountId: EcdsaAdditiveLaneJobV1['walletId'];
+        readonly materialActivationId: EcdsaAdditiveLaneJobV1['source']['materialActivation']['activationId'];
+        readonly signingWorkerId: string;
+    };
+    readonly sourceDerivation: {
+        readonly applicationBindingDigestB64u: string;
+        readonly clientShareRetryCounter: number;
+    };
+};
+export interface EcdsaOwnerSourceSignerContinuityPortV1 {
+    listWalletEcdsaCustodyContinuity(input: {
+        readonly walletId: string;
+    }): Promise<readonly WalletEcdsaSignerRecord[]>;
+}
+export declare class LaneLifecycleStoreEcdsaLanePrivateBindingResolverV1 implements EcdsaLanePrivateBindingResolverPortV1 {
+    private readonly lifecycleStore;
+    private readonly walletRegistration;
+    constructor(lifecycleStore: Pick<LaneLifecycleStore, 'getProductEpoch' | 'getProtocol'>, walletRegistration: EcdsaOwnerSourceSignerContinuityPortV1);
+    resolveSourceMaterialV1(input: {
+        readonly job: EcdsaAdditiveLaneJobV1;
+    }): Promise<CloudflareEcdsaLaneSourceMaterialV1>;
+    resolveActivationBindingV1(input: {
+        readonly job: EcdsaAdditiveLaneJobV1;
+        readonly protocolCommitReceipt: LaneProtocolCommitReceiptV1;
+    }): Promise<{
+        readonly identity: EcdsaSigningWorkerLaneMaterialIdentityV1;
+        readonly targetMaterialActivation: MpcMaterialActivationRef;
+    }>;
+    resolveRetirementBindingV1(input: {
+        readonly command: RevokeSigningLaneV1;
+    }): Promise<EcdsaServerRetirementBindingV1>;
+}
+export type CloudflareSigningWorkerEcdsaLaneTransportOptionsV1 = {
+    readonly signingWorker: {
+        fetch(request: Request): Promise<Response>;
+    };
+    readonly internalServiceAuth: string;
+    readonly bindingResolver: EcdsaLanePrivateBindingResolverPortV1;
+    readonly retirementTransport: Pick<SigningWorkerLaneMaterialReceiptPortV1, 'retireServerMaterialV1'>;
+};
+export type CloudflareSigningWorkerEcdsaRetirementTransportOptionsV1 = {
+    readonly signingWorker: {
+        fetch(request: Request): Promise<Response>;
+    };
+    readonly internalServiceAuth: string;
+    readonly bindingResolver: Pick<EcdsaLanePrivateBindingResolverPortV1, 'resolveRetirementBindingV1'>;
+    readonly ed25519BindingResolver: Ed25519LanePrivateBindingResolverPortV1;
+};
+export declare class CloudflareSigningWorkerEcdsaRetirementTransportV1 implements Pick<SigningWorkerLaneMaterialReceiptPortV1, 'retireServerMaterialV1'> {
+    private readonly options;
+    private readonly internalServiceAuth;
+    constructor(options: CloudflareSigningWorkerEcdsaRetirementTransportOptionsV1);
+    retireServerMaterialV1(input: {
+        readonly curve: 'ed25519_yao' | 'ecdsa_additive';
+        readonly command: RevokeSigningLaneV1;
+    }): Promise<SigningWorkerLaneRetirementProjectionV1>;
+}
+export declare class CloudflareSigningWorkerEcdsaLaneTransportV1 implements SigningWorkerLaneMaterialReceiptPortV1 {
+    private readonly options;
+    private readonly internalServiceAuth;
+    constructor(options: CloudflareSigningWorkerEcdsaLaneTransportOptionsV1);
+    commitEcdsaProtocolV1(input: {
+        readonly job: EcdsaAdditiveLaneJobV1;
+        readonly holderRound: EcdsaAdditiveLaneHolderRoundV1;
+        readonly holderPackage: Extract<LaneHolderPackageWireV1, {
+            kind: 'ecdsa_additive_lane_holder_package_v1';
+        }>;
+        readonly encryptedDeltaPackageJson: string;
+    }): Promise<SigningWorkerLaneProtocolCommitProjectionV1>;
+    activateServerMaterialV1(input: {
+        readonly curve: 'ed25519_yao';
+        readonly job: Ed25519YaoLaneJobV1;
+        readonly protocolCommitReceipt: LaneProtocolCommitReceiptV1;
+        readonly holderDeliveryReceipt: LaneHolderDeliveryReceiptV1;
+    } | {
+        readonly curve: 'ecdsa_additive';
+        readonly job: EcdsaAdditiveLaneJobV1;
+        readonly protocolCommitReceipt: LaneProtocolCommitReceiptV1;
+        readonly holderDeliveryReceipt: LaneHolderDeliveryReceiptV1;
+    }): Promise<SigningWorkerLaneServerActivationProjectionV1>;
+    retireServerMaterialV1(input: {
+        readonly curve: 'ed25519_yao' | 'ecdsa_additive';
+        readonly command: RevokeSigningLaneV1;
+    }): Promise<SigningWorkerLaneRetirementProjectionV1>;
+}
+export type CloudflareLaneCurveExecutionOptionsV1 = {
+    readonly ed25519Transport: CloudflareEd25519LaneProtocolTransportV1;
+    readonly signingWorker: SigningWorkerLaneMaterialReceiptPortV1;
+};
+export declare function createCloudflareLaneCurveExecutionPortsV1(options: CloudflareLaneCurveExecutionOptionsV1): LaneLifecycleCurveExecutionPortsV1;
+export type CloudflareNormalSigningLaneMaterialAdmissionV1 = {
+    readonly product: LaneProductEpochActiveV1;
+    readonly source: {
+        readonly kind: 'rotatable_lane';
+        readonly lookup: {
+            readonly identity: SigningWorkerLaneMaterialIdentityV1;
+            readonly admittedLaneIdentityDigestB64u: DigestB64u;
+        };
+        readonly group_public_key: string;
+    };
+};
+/**
+ * Resolves one exact active child product before a normal-signing request is
+ * forwarded to SigningWorker. The resolver deliberately requires immutable
+ * lane coordinates and the full activation reference; activation IDs alone
+ * cannot select a private lane artifact.
+ */
+export declare class LaneLifecycleStoreNormalSigningLaneMaterialResolverV1 {
+    private readonly lifecycleStore;
+    constructor(lifecycleStore: Pick<LaneLifecycleStore, 'getEnrollment' | 'getProductEpoch' | 'getProtocol'>);
+    resolveV1(input: {
+        readonly lookup: LaneProductEpochLookup;
+        readonly materialActivation: MpcMaterialActivationRef;
+        readonly keyFamily: 'ed25519' | 'ecdsa_secp256k1';
+    }): Promise<CloudflareNormalSigningLaneMaterialAdmissionV1>;
+}
+export declare function digestSigningWorkerLaneIdentityV1(identity: SigningWorkerLaneMaterialIdentityV1): Promise<DigestB64u>;
+export {};
+//# sourceMappingURL=cloudflareLaneCurveExecution.d.ts.map

package/dist/types/wallet-server/src/router/cloudflare/signingLanes/cloudflareLaneProtocolCommitter.d.ts

@@ -0,0 +1,73 @@
+import type { EcdsaAdditiveLaneHolderRoundV1, EcdsaAdditiveLaneJobV1, Ed25519YaoLaneJobV1, LaneEnrollmentGatewayV1, LaneProtocolCasResultV1, LaneProtocolCommitReceiptV1, LaneHolderPackageWireV1 } from '../../../../../shared-ts/src/signing-lanes';
+import type { RouterAbEd25519YaoCeremonyBindingV1 } from '../../../../../shared-ts/src/utils/routerAbEd25519Yao';
+import { type LaneLifecycleAuthorizationPortV1, type LaneLifecycleCurveExecutionPortsV1 } from '../../../core/signingLanes/LaneLifecycleApplicationService';
+export declare const ROUTER_AB_ED25519_YAO_LANE_EXECUTE_PATH_V1: "/router-ab/internal/ed25519-yao/lane/execute";
+export interface CloudflareLaneServiceBindingV1 {
+    fetch(request: Request): Promise<Response>;
+}
+/**
+ * Resolves the public admitted binding for an already-encrypted client lane
+ * dispatch. Client-root contributions and Deriver envelopes stay client-side.
+ */
+export interface Ed25519YaoLaneBindingResolverPortV1 {
+    resolveBindingV1(input: {
+        readonly job: Ed25519YaoLaneJobV1;
+    }): Promise<RouterAbEd25519YaoCeremonyBindingV1>;
+}
+export type CloudflareEd25519LaneProtocolTransportOptionsV1 = {
+    readonly router: CloudflareLaneServiceBindingV1;
+    readonly internalServiceAuth: string;
+    readonly bindingResolver: Ed25519YaoLaneBindingResolverPortV1;
+};
+export type CloudflareEd25519LaneProtocolExecutionV1 = {
+    readonly receipt: LaneProtocolCommitReceiptV1;
+    readonly responseJson: string;
+};
+export declare class CloudflareEd25519LaneProtocolTransportV1 {
+    private readonly options;
+    private readonly internalServiceAuth;
+    constructor(options: CloudflareEd25519LaneProtocolTransportOptionsV1);
+    executeProtocolCommitV1(input: {
+        readonly job: Ed25519YaoLaneJobV1;
+        readonly requestJson: string;
+    }): Promise<CloudflareEd25519LaneProtocolExecutionV1>;
+}
+export type CloudflareLaneProtocolCommitterOptionsV1 = {
+    readonly gateway: LaneEnrollmentGatewayV1;
+    readonly authorization: LaneLifecycleAuthorizationPortV1;
+    readonly execution: LaneLifecycleCurveExecutionPortsV1;
+    readonly ed25519Transport: CloudflareEd25519LaneProtocolTransportV1;
+};
+export type CloudflareEd25519LaneProtocolCommitResultV1 = {
+    readonly receipt: LaneProtocolCommitReceiptV1;
+    readonly protocolCasResult: LaneProtocolCasResultV1;
+    readonly responseJson: string;
+};
+export type CloudflareEcdsaLaneProtocolCommitResultV1 = {
+    readonly receipt: LaneProtocolCommitReceiptV1;
+    readonly protocolCasResult: LaneProtocolCasResultV1;
+};
+/**
+ * Runs one private MPC effect, then records its exact receipt through Gateway
+ * CAS. A transport retry submits byte-identical input and relies on the
+ * operation-scoped worker journal for replay.
+ */
+export declare class CloudflareLaneProtocolCommitterV1 {
+    private readonly options;
+    constructor(options: CloudflareLaneProtocolCommitterOptionsV1);
+    executeAndRecordEd25519YaoLaneV1(input: {
+        readonly job: Ed25519YaoLaneJobV1;
+        readonly requestJson: string;
+        readonly expectedVersion: number;
+    }): Promise<CloudflareEd25519LaneProtocolCommitResultV1>;
+    executeAndRecordEcdsaAdditiveLaneV1(input: {
+        readonly job: EcdsaAdditiveLaneJobV1;
+        readonly holderRound: EcdsaAdditiveLaneHolderRoundV1;
+        readonly holderPackage: Extract<LaneHolderPackageWireV1, {
+            kind: 'ecdsa_additive_lane_holder_package_v1';
+        }>;
+        readonly encryptedDeltaPackageJson: string;
+        readonly expectedVersion: number;
+    }): Promise<CloudflareEcdsaLaneProtocolCommitResultV1>;
+}
+//# sourceMappingURL=cloudflareLaneProtocolCommitter.d.ts.map

package/dist/types/wallet-server/src/router/cloudflare/signingLanes/cloudflareOrdinaryInactiveSignerMaterialReservation.d.ts

@@ -0,0 +1,100 @@
+import { type OrdinaryEcdsaSignerMaterialReservationRequestV1, type OrdinaryEcdsaSignerMaterialDeactivationRequestV1, type OrdinaryEcdsaSignerMaterialWorkerReservationV1, type OrdinaryEd25519SignerMaterialReservationRequestV1, type OrdinaryEd25519SignerMaterialDeactivationRequestV1, type OrdinaryEd25519SignerMaterialWorkerReservationV1, type OrdinaryInactiveSignerMaterialDeactivationPortV1, type OrdinaryInactiveSignerMaterialDeactivationRequestV1, type OrdinaryInactiveSignerMaterialReservationServiceV1, type OrdinaryInactiveSignerMaterialReservationWorkerPortV1 } from '../../../core/signingMaterial/ordinaryInactiveSignerMaterialReservation';
+import { type LinkedDeviceEd25519SourceContributionPreparationV1 } from '../../../../../shared-ts/src/device-linking/sourceContribution';
+import type { DeviceLinkingEd25519SourcePreservingRouterPortV1 } from '../../transport/fetch/routes/deviceLinking';
+import type { OrdinaryInactiveSignerMaterialActivationPortV1 } from '../d1/deviceLinking/d1LinkedDeviceAuthorityInstallService';
+import type { TenantRootActiveLineageV1 } from '../../domains/tenantRoot/tenantRootCustodyLineage';
+import type { OrdinaryEcdsaSignerMaterialReservationPreparationV1, OrdinaryEd25519SignerMaterialReservationPreparationV1 } from '../../../core/signingMaterial/ordinaryInactiveSignerMaterialReservation';
+/** Source-preserving ordinary material paths implemented by the Cloudflare workers. */
+export declare const CLOUDFLARE_ROUTER_ED25519_YAO_SOURCE_PRESERVING_EXECUTE_PATH_V1: "/router-ab/router/ed25519-yao/execute-source-preserving";
+export declare const CLOUDFLARE_SIGNING_WORKER_ECDSA_RESERVE_INACTIVE_SOURCE_PRESERVING_PATH_V1: "/router-ab/signing-worker/ecdsa-derivation/reserve-inactive-source-preserving";
+export declare const CLOUDFLARE_SIGNING_WORKER_ED25519_YAO_ACTIVATE_RESERVATION_PATH_V1: "/router-ab/signing-worker/ed25519-yao/activate-reservation";
+export declare const CLOUDFLARE_SIGNING_WORKER_ECDSA_ACTIVATE_RESERVATION_PATH_V1: "/router-ab/signing-worker/ecdsa-derivation/activate-reservation";
+export declare const CLOUDFLARE_SIGNING_WORKER_ED25519_YAO_DEACTIVATE_RESERVATION_PATH_V1: "/router-ab/signing-worker/ed25519-yao/deactivate-reservation";
+export declare const CLOUDFLARE_SIGNING_WORKER_ECDSA_DEACTIVATE_RESERVATION_PATH_V1: "/router-ab/signing-worker/ecdsa-derivation/deactivate-reservation";
+/**
+ * Boundary for the dedicated ordinary reservation operation. Its response is
+ * deliberately unknown until the core reservation parser has checked the
+ * family, exact activation reference, inactive state, and package shape.
+ * Implementations call one of the dedicated paths above; activation routes
+ * are deliberately outside this port.
+ */
+export type CloudflareOrdinaryInactiveSignerMaterialReservationEndpointV1 = {
+    reserveInactiveEd25519SignerMaterialV1(input: OrdinaryEd25519SignerMaterialReservationRequestV1): Promise<unknown>;
+    reserveInactiveEcdsaSignerMaterialV1(input: OrdinaryEcdsaSignerMaterialReservationRequestV1): Promise<unknown>;
+};
+export type CloudflareLinkedDeviceEd25519SourcePreservingRouterEndpointV1 = DeviceLinkingEd25519SourcePreservingRouterPortV1;
+export declare function createCloudflareLinkedDeviceEd25519SourcePreservingRouterEndpointV1(input: {
+    readonly fetch: typeof fetch;
+    readonly internalServiceAuthSecret: string;
+    readonly resolveTenantRoot: (context: Pick<LinkedDeviceEd25519SourceContributionPreparationV1, 'applicationBinding' | 'targetAdmission' | 'participantIds'>) => Promise<TenantRootActiveLineageV1>;
+}): CloudflareLinkedDeviceEd25519SourcePreservingRouterEndpointV1;
+export type CloudflareOrdinaryInactiveSignerMaterialActivationEndpointV1 = {
+    activateInactiveEd25519SignerMaterialV1(input: {
+        readonly sourceContribution: OrdinaryEd25519SignerMaterialReservationPreparationV1['sourceContribution'];
+        readonly reservationId: string;
+    }): Promise<unknown>;
+    activateInactiveEcdsaSignerMaterialV1(input: {
+        readonly preparation: OrdinaryEcdsaSignerMaterialReservationPreparationV1;
+        readonly reservationId: string;
+    }): Promise<unknown>;
+};
+export type CloudflareOrdinaryInactiveSignerMaterialDeactivationEndpointV1 = {
+    deactivateInactiveEd25519SignerMaterialV1(input: {
+        readonly materialActivation: OrdinaryEd25519SignerMaterialDeactivationRequestV1['materialActivation'];
+    }): Promise<unknown>;
+    deactivateInactiveEcdsaSignerMaterialV1(input: {
+        readonly materialActivation: OrdinaryEcdsaSignerMaterialDeactivationRequestV1['materialActivation'];
+    }): Promise<unknown>;
+};
+export declare function createCloudflareOrdinaryInactiveSignerMaterialReservationEndpointV1(input: {
+    readonly fetch: typeof fetch;
+    readonly internalServiceAuthSecret: string;
+}): CloudflareOrdinaryInactiveSignerMaterialReservationEndpointV1;
+export declare function createCloudflareOrdinaryInactiveSignerMaterialActivationEndpointV1(input: {
+    readonly fetch: typeof fetch;
+    readonly internalServiceAuthSecret: string;
+}): CloudflareOrdinaryInactiveSignerMaterialActivationEndpointV1;
+export declare function createCloudflareOrdinaryInactiveSignerMaterialDeactivationEndpointV1(input: {
+    readonly fetch: typeof fetch;
+    readonly internalServiceAuthSecret: string;
+}): CloudflareOrdinaryInactiveSignerMaterialDeactivationEndpointV1;
+/**
+ * Adapter for the ordinary inactive reservation endpoint. The endpoint owns
+ * durable idempotency; this process-local journal prevents a retry from
+ * silently changing the request while preserving the endpoint's exact result.
+ */
+export declare class CloudflareOrdinaryInactiveSignerMaterialReservationWorkerV1 implements OrdinaryInactiveSignerMaterialReservationWorkerPortV1 {
+    private readonly endpoint;
+    private readonly ed25519Reservations;
+    private readonly ecdsaReservations;
+    constructor(endpoint: CloudflareOrdinaryInactiveSignerMaterialReservationEndpointV1);
+    reserveInactiveEd25519SignerMaterialV1(input: OrdinaryEd25519SignerMaterialReservationRequestV1): Promise<OrdinaryEd25519SignerMaterialWorkerReservationV1>;
+    reserveInactiveEcdsaSignerMaterialV1(input: OrdinaryEcdsaSignerMaterialReservationRequestV1): Promise<OrdinaryEcdsaSignerMaterialWorkerReservationV1>;
+}
+export declare function createCloudflareOrdinaryInactiveSignerMaterialReservationServiceV1(input: {
+    readonly endpoint: CloudflareOrdinaryInactiveSignerMaterialReservationEndpointV1;
+}): OrdinaryInactiveSignerMaterialReservationServiceV1;
+export declare class CloudflareOrdinaryInactiveSignerMaterialDeactivationWorkerV1 implements OrdinaryInactiveSignerMaterialDeactivationPortV1 {
+    private readonly endpoint;
+    private readonly terminalOperations;
+    constructor(endpoint: CloudflareOrdinaryInactiveSignerMaterialDeactivationEndpointV1);
+    deactivateOrdinarySignerMaterialV1(input: OrdinaryInactiveSignerMaterialDeactivationRequestV1): Promise<void>;
+    private performDeactivationV1;
+}
+export declare function createCloudflareOrdinaryInactiveSignerMaterialDeactivationPortV1(input: {
+    readonly endpoint: CloudflareOrdinaryInactiveSignerMaterialDeactivationEndpointV1;
+}): OrdinaryInactiveSignerMaterialDeactivationPortV1;
+export declare class UnavailableOrdinaryInactiveSignerMaterialDeactivationWorkerV1 implements OrdinaryInactiveSignerMaterialDeactivationPortV1 {
+    deactivateOrdinarySignerMaterialV1(_input: OrdinaryInactiveSignerMaterialDeactivationRequestV1): Promise<void>;
+}
+export declare function createUnavailableOrdinaryInactiveSignerMaterialDeactivationPortV1(): OrdinaryInactiveSignerMaterialDeactivationPortV1;
+export declare function createCloudflareOrdinaryInactiveSignerMaterialActivationPortV1(input: {
+    readonly endpoint: CloudflareOrdinaryInactiveSignerMaterialActivationEndpointV1;
+}): OrdinaryInactiveSignerMaterialActivationPortV1;
+/** Explicit fail-closed port for deployments without a configured endpoint. */
+export declare class UnavailableOrdinaryInactiveSignerMaterialReservationWorkerV1 implements OrdinaryInactiveSignerMaterialReservationWorkerPortV1 {
+    reserveInactiveEd25519SignerMaterialV1(_input: OrdinaryEd25519SignerMaterialReservationRequestV1): Promise<OrdinaryEd25519SignerMaterialWorkerReservationV1>;
+    reserveInactiveEcdsaSignerMaterialV1(_input: OrdinaryEcdsaSignerMaterialReservationRequestV1): Promise<OrdinaryEcdsaSignerMaterialWorkerReservationV1>;
+}
+export declare function createUnavailableOrdinaryInactiveSignerMaterialReservationWorkerV1(): OrdinaryInactiveSignerMaterialReservationWorkerPortV1;
+//# sourceMappingURL=cloudflareOrdinaryInactiveSignerMaterialReservation.d.ts.map

package/dist/types/wallet-server/src/router/cloudflare/signingLanes/index.d.ts

@@ -0,0 +1,4 @@
+export * from './cloudflareLaneProtocolCommitter';
+export * from './cloudflareLaneCurveExecution';
+export * from './cloudflareOrdinaryInactiveSignerMaterialReservation';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/wallet-server/src/router/cloudflare/signingLanes/linkedDeviceEd25519CeremonyBinding.d.ts

@@ -0,0 +1,6 @@
+import type { Ed25519YaoLaneJobV1 } from '../../../../../shared-ts/src/signing-lanes';
+import type { RouterAbEd25519YaoCeremonyBindingV1 } from '../../../../../shared-ts/src/utils/routerAbEd25519Yao';
+import type { Ed25519YaoLaneBindingResolverPortV1 } from './cloudflareLaneProtocolCommitter';
+export declare function createLinkedDeviceEd25519CeremonyBindingResolverV1(): Ed25519YaoLaneBindingResolverPortV1;
+export declare function buildLinkedDeviceEd25519CeremonyBindingV1(job: Ed25519YaoLaneJobV1): Promise<RouterAbEd25519YaoCeremonyBindingV1>;
+//# sourceMappingURL=linkedDeviceEd25519CeremonyBinding.d.ts.map

package/dist/types/wallet-server/src/router/cloudflare-adaptor.d.ts

@@ -0,0 +1,75 @@
+export type { RouterApiKeyAuthAdapter, RouterApiKeyAuthFailureCode, RouterApiKeyAuthRequest, RouterApiKeyAuthResult, RouterApiKeyPrincipal, RouterApiOptions, RouterApiPublishableKeyAuthAdapter, RouterApiPublishableKeyAuthFailureCode, RouterApiPublishableKeyAuthRequest, RouterApiPublishableKeyAuthResult, RouterApiRuntimePolicyScope, RouterApiRuntimeSnapshotConsumer, RouterApiRuntimeSnapshotEnvelope, RouterApiUsageMeterAction, RouterApiUsageMeterAdapter, RouterApiUsageMeterEvent, } from './framework/routerApi';
+export { ROUTER_AB_PUBLIC_KEYSET_PATH, ROUTER_AB_PUBLIC_KEYSET_VERSION_V2, ROUTER_AB_PUBLIC_KEYSET_WELL_KNOWN_PATH, parseRouterAbPublicKeysetV2, } from '../../../shared-ts/src/utils/routerAbPublicKeyset';
+export type { RouterAbPublicKeysetV2 } from '../../../shared-ts/src/utils/routerAbPublicKeyset';
+export type { RouterAbNormalSigningAdmissionAdapter, RouterAbNormalSigningAdmissionFailure, RouterAbNormalSigningAdmissionFailureCode, RouterAbNormalSigningAdmissionInput, RouterAbNormalSigningAdmissionResult, } from './domains/signingOperations/routerAbPrivateSigningWorker';
+export { InMemoryRouterAbNormalSigningAdmissionStore, createInMemoryRouterAbNormalSigningAdmissionAdapter, createInMemoryRouterAbNormalSigningAdmissionStore, createRouterAbNormalSigningAdmissionAdapter, } from './domains/signingOperations/routerAbNormalSigningAdmissionCore';
+export type { RouterAbNormalSigningAbuseDecision, RouterAbNormalSigningAbuseProvider, RouterAbNormalSigningAdmissionStore, RouterAbNormalSigningProjectPolicyDecision, RouterAbNormalSigningProjectPolicyProvider, } from './domains/signingOperations/routerAbNormalSigningAdmissionCore';
+export { CloudflareD1RouterAbNormalSigningAdmissionStore, createCloudflareD1RouterAbNormalSigningAdmissionStore, } from './cloudflare/d1/signingAdmission/d1RouterAbNormalSigningAdmissionStore';
+export type { CloudflareD1RouterAbNormalSigningAdmissionStoreOptions } from './cloudflare/d1/signingAdmission/d1RouterAbNormalSigningAdmissionStore';
+export type { RouterApiFetchRouteExtension, RouterApiFetchRouteExtensionInput, RouterApiRouteExtension, RouterApiRouteExtensionTransport, } from './framework/routeExtensions';
+export { getRouterApiRouteExtensionRoutes } from './framework/routeExtensions';
+export { matchesRouteDefinitionRequest } from './framework/routeDefinitions';
+export { coerceRouterLogger } from './framework/logger';
+export * from './cloudflare/runtime/walletConsoleOps';
+export * from './cloudflare/runtime/walletConsoleOpsClient';
+export * from './cloudflare/runtime/walletGateway';
+export * from './cloudflare/runtime/walletRuntimeOps';
+export * from './cloudflare/runtime/walletRuntimeOpsHandler';
+export * from './cloudflare/runtime/walletControlOps';
+export * from './cloudflare/runtime/walletConsoleTenantRootLineage';
+export * from './cloudflare/runtime/routerAbPrewarm';
+export * from './cloudflare/runtime/tenantRootCreationGrant';
+export * from './cloudflare/runtime/environment';
+export * from './cloudflare/runtime/staticWalletConsoleBinding';
+export type { RouterApiModule, RouterApiModuleKind, RouterApiModuleOptions, } from './framework/modules';
+export { createRouterApiModule } from './framework/modules';
+export { CloudflareD1WebAuthnStore } from './cloudflare/d1/webauthn/d1WebAuthnStore';
+export { CloudflareD1WebAuthnAuthService } from './cloudflare/d1/webauthn/d1WebAuthnAuthService';
+export { CloudflareD1AuthorizationStore, type D1AuthorizationStoreOptions, } from './cloudflare/d1/authorization/d1AuthorizationStore';
+export { CloudflareD1VaultProxyStore } from './cloudflare/d1/authorization/d1VaultProxyStore';
+export { InMemoryRouterAbEd25519YaoRegistrationService, createRouterAbEd25519YaoRegistrationModule, } from './domains/ed25519Yao/registration/routerAbEd25519YaoRegistration';
+export { InMemoryRouterAbEd25519YaoRegistrationIntentAuthorizationAdapter } from './domains/ed25519Yao/registration/routerAbEd25519YaoRegistrationIntentAuthorization';
+export { buildRouterAbEd25519YaoProductAdmissionRequestV1, createRouterAbEd25519YaoProductRegistrationCompositionFromPortsV1, createRouterAbEd25519YaoProductRegistrationStateV1, createRouterAbEd25519YaoProductRegistrationRuntimeV1, } from './domains/ed25519Yao/capabilityLifecycle/routerAbEd25519YaoProductRegistration';
+export { RouterAbEd25519YaoHttpRegistrationBackend, createRouterAbEd25519YaoHttpRegistrationBackendFromEnv, } from './domains/ed25519Yao/registration/routerAbEd25519YaoHttpRegistrationBackend';
+export type { RouterAbEd25519YaoHttpRegistrationBackendConfig, RouterAbEd25519YaoHttpRegistrationBackendRawEnv, } from './domains/ed25519Yao/registration/routerAbEd25519YaoHttpRegistrationBackend';
+export type { RouterAbEd25519YaoRegistrationAuthorizationAdapter, RouterAbEd25519YaoRegistrationAuthorizationInput, RouterAbEd25519YaoRegistrationAuthorizationResult, RouterAbEd25519YaoRegistrationBackend, RouterAbEd25519YaoRegistrationBackendFailure, RouterAbEd25519YaoRegistrationBackendResult, RouterAbEd25519YaoRegistrationFailure, RouterAbEd25519YaoRegistrationExecuteBoundaryV1, RouterAbEd25519YaoRegistrationExecuteClaimV1, RouterAbEd25519YaoRegistrationExecuteCommitInputV1, RouterAbEd25519YaoRegistrationExecutePreparationV1, RouterAbEd25519YaoRegistrationService, RouterAbEd25519YaoRegistrationServiceResult, RouterAbEd25519YaoActivationConsumerV1, RouterAbEd25519YaoActivationReferenceV1, RouterAbEd25519YaoActivationConsumptionResultV1, } from './domains/ed25519Yao/registration/routerAbEd25519YaoRegistration';
+export type { RouterAbEd25519YaoVerifiedRegistrationIntentV1, RouterAbEd25519YaoRegistrationIntentBindingResult, } from './domains/ed25519Yao/registration/routerAbEd25519YaoRegistrationIntentAuthorization';
+export type { RouterAbEd25519YaoProductRegistrationRuntimeV1, RouterAbEd25519YaoProductRegistrationCompositionV1, RouterAbEd25519YaoProductRegistrationStateV1, RouterAbEd25519YaoWalletSessionCredentialV1, } from './domains/ed25519Yao/capabilityLifecycle/routerAbEd25519YaoProductRegistration';
+export type { RouteDefinition } from './framework/routeDefinitions';
+export { defineRoute } from './framework/routeDefinitions';
+export type { CfEnv, CfExecutionContext, FetchHandler, RouterApiCloudflareSignerWorkerEnv, SeamsD1SignerTenantStorageWorkerEnv, } from './cloudflare/runtime/cloudflare.types';
+export type { CloudflareTenantStorageRoute, CloudflareTenantTopology, D1BindingName, D1DatabaseLike, D1DatabaseName, D1PreparedStatementLike, NamespaceId, OrgId, ResolveTenantStorageRouteInput, RouteVersion, SignerD1DoStorageTarget, StaticCloudflareTenantStorageRouteResolverBindingInput, StaticCloudflareTenantStorageRouteResolverInput, TenantDataJurisdiction, TenantStorageRouteResolver, } from '../storage/tenantRoute';
+export { StaticCloudflareTenantStorageRouteResolver, createCloudflareTenantStorageRoute, createSignerD1DoStorageTarget, createStaticCloudflareTenantStorageRouteResolver, createStaticCloudflareTenantStorageRouteResolverFromBindings, } from '../storage/tenantRoute';
+export type { InMemoryRouterApiRuntimeSnapshotConsumer, RouterApiRuntimeSnapshotPublishedUpdate, } from './framework/runtimeSnapshotConsumer';
+export { createInMemoryRouterApiRuntimeSnapshotConsumer, validateRuntimeSnapshotExpectation, } from './framework/runtimeSnapshotConsumer';
+export { extractBearerCredential, extractRouterApiEnvironmentId, resolveSourceIpFromExpressRequest, resolveSourceIpFromFetchHeaders, } from './auth/routerApiKeyAuth';
+export { createCloudflareRouter } from './cloudflare/runtime/createCloudflareRouter';
+export type { SelfHostedCloudflareSigningWorkerFactoryInput } from './cloudflare/runtime/createSelfHostedCloudflareSigningWorker';
+export { createSelfHostedCloudflareSigningRouter, createSelfHostedCloudflareSigningWorker, } from './cloudflare/runtime/createSelfHostedCloudflareSigningWorker';
+export { ThresholdStoreDurableObject } from './cloudflare/durableObjects/thresholdStore';
+export { CloudflareDurableObjectVersionedJsonRecordStore, CloudflareVersionedJsonRecordStoreError, createCloudflareDurableObjectVersionedJsonRecordStore, } from './cloudflare/durableObjects/versionedJsonRecordStore';
+export type { CloudflareVersionedJsonRecordStoreOptions } from './cloudflare/durableObjects/versionedJsonRecordStore';
+export type { VersionedJsonObject, VersionedJsonRecordPutResult, VersionedJsonRecordReadResult, VersionedJsonValue, } from './framework/versionedJsonRecordStore';
+export { CloudflareD1VersionedJsonRecordStore, CloudflareD1VersionedJsonRecordStoreError, createCloudflareD1VersionedJsonRecordStore, } from './cloudflare/d1/versionedJson/d1VersionedJsonRecordStore';
+export type { CloudflareD1VersionedJsonRecordScopeV1, CloudflareD1VersionedJsonRecordBatchPutResultV1, CloudflareD1VersionedJsonRecordMutationV1, CloudflareD1VersionedJsonRecordReadManyEntryV1, CloudflareD1VersionedJsonRecordStoreOptions, } from './cloudflare/d1/versionedJson/d1VersionedJsonRecordStore';
+export { createRouterAbEd25519YaoCeremonyStateStoreV1, encodeRouterAbEd25519YaoProductRegistrationStateV1, parseRouterAbEd25519YaoProductRegistrationStateJsonV1, parseRouterAbEd25519YaoCeremonyKeyV1, resolveRouterAbEd25519YaoCeremonyKeyFromRequestV1, } from './domains/ed25519Yao/capabilityLifecycle/routerAbEd25519YaoProductRegistrationPersistence';
+export type { RouterAbEd25519YaoCeremonyKeyV1, RouterAbEd25519YaoCeremonyKeyResolutionV1, RouterAbEd25519YaoCeremonyStateStoreV1, } from './domains/ed25519Yao/capabilityLifecycle/routerAbEd25519YaoProductRegistrationPersistence';
+export { mergeRouterAbEd25519YaoProductRegistrationStatePartitionV1, partitionRouterAbEd25519YaoProductRegistrationStateV1, } from './domains/ed25519Yao/capabilityLifecycle/routerAbEd25519YaoProductRegistrationPartitioning';
+export type { RouterAbEd25519YaoProductRegistrationCeremonyStateV1, RouterAbEd25519YaoProductRegistrationSharedStateV1, RouterAbEd25519YaoProductRegistrationStatePartitionV1, } from './domains/ed25519Yao/capabilityLifecycle/routerAbEd25519YaoProductRegistrationPartitioning';
+export { ROUTER_AB_ED25519_YAO_SHARED_STATE_RECORD_KEY_V1, createRouterAbEd25519YaoProductRegistrationPartitionedStateStoreV1, encodeRouterAbEd25519YaoProductRegistrationPartitionRecordV1, parseRouterAbEd25519YaoProductRegistrationPartitionRecordV1, } from './domains/ed25519Yao/capabilityLifecycle/routerAbEd25519YaoProductRegistrationPartitionedStateStore';
+export type { RouterAbEd25519YaoProductRegistrationPartitionBatchResultV1, RouterAbEd25519YaoProductRegistrationPartitionMutationV1, RouterAbEd25519YaoProductRegistrationPartitionRecordStoreV1, RouterAbEd25519YaoProductRegistrationPartitionRecordV1, RouterAbEd25519YaoProductRegistrationPartitionedStateCommitInputV1, RouterAbEd25519YaoProductRegistrationPartitionedStateCommitResultV1, RouterAbEd25519YaoProductRegistrationPartitionedStateStoreV1, RouterAbEd25519YaoProductRegistrationPartitionedStateV1, } from './domains/ed25519Yao/capabilityLifecycle/routerAbEd25519YaoProductRegistrationPartitionedStateStore';
+export { createRouterAbEd25519YaoProductRegistrationPartitionedStateStoreFromD1V1 } from './cloudflare/d1/ed25519Yao/d1Ed25519YaoProductRegistrationPartitionedStateStore';
+export type { RouterAbEd25519YaoProductRegistrationPartitionedStateD1OptionsV1 } from './cloudflare/d1/ed25519Yao/d1Ed25519YaoProductRegistrationPartitionedStateStore';
+export { runRouterAbEd25519YaoProductRegistrationRequestScopedV1 } from './domains/ed25519Yao/capabilityLifecycle/routerAbEd25519YaoProductRegistrationRequestScopedRunner';
+export type { RouterAbEd25519YaoProductRegistrationRequestScopedExecutionV1, RouterAbEd25519YaoProductRegistrationRequestScopedRunInputV1, RouterAbEd25519YaoProductRegistrationRequestScopedRunResultV1, } from './domains/ed25519Yao/capabilityLifecycle/routerAbEd25519YaoProductRegistrationRequestScopedRunner';
+export { createRouterAbEd25519YaoProductRegistrationRequestScopedRuntimeV1 } from './domains/ed25519Yao/capabilityLifecycle/routerAbEd25519YaoProductRegistrationRequestScopedRuntime';
+export type { RouterAbEd25519YaoProductRegistrationRequestScopedRuntimeInputV1 } from './domains/ed25519Yao/capabilityLifecycle/routerAbEd25519YaoProductRegistrationRequestScopedRuntime';
+export { runRouterAbEd25519YaoRegistrationSideEffectV1 } from './domains/ed25519Yao/registration/routerAbEd25519YaoRegistrationSideEffectBoundary';
+export type { RouterAbEd25519YaoRegistrationSideEffectClaimV1, RouterAbEd25519YaoRegistrationSideEffectCompletionV1, RouterAbEd25519YaoRegistrationSideEffectExecutionV1, RouterAbEd25519YaoRegistrationSideEffectOperationV1, RouterAbEd25519YaoRegistrationSideEffectRecordV1, RouterAbEd25519YaoRegistrationSideEffectRunInputV1, RouterAbEd25519YaoRegistrationSideEffectRunResultV1, RouterAbEd25519YaoRegistrationSideEffectStoreV1, } from './domains/ed25519Yao/registration/routerAbEd25519YaoRegistrationSideEffectBoundary';
+export { runRouterAbEd25519YaoRegistrationTwoPhaseV1 } from './domains/ed25519Yao/registration/routerAbEd25519YaoRegistrationTwoPhaseRunner';
+export type { RouterAbEd25519YaoRegistrationTwoPhaseBackendResultV1, RouterAbEd25519YaoRegistrationTwoPhaseCompletionV1, RouterAbEd25519YaoRegistrationTwoPhasePrepareResultV1, RouterAbEd25519YaoRegistrationTwoPhaseRunInputV1, RouterAbEd25519YaoRegistrationTwoPhaseRunResultV1, } from './domains/ed25519Yao/registration/routerAbEd25519YaoRegistrationTwoPhaseRunner';
+export type { RouterAbEd25519YaoRegistrationAdmissionBoundaryV1, RouterAbEd25519YaoRegistrationAdmissionClaimV1, RouterAbEd25519YaoRegistrationAdmissionCommitInputV1, RouterAbEd25519YaoRegistrationAdmissionPreparationV1, } from './domains/ed25519Yao/registration/routerAbEd25519YaoRegistration';
+export * from './cloudflare/signingLanes/cloudflareOrdinaryInactiveSignerMaterialReservation';
+export { handleRouterAbEd25519YaoRegistrationRequestScopedCloudflareV1 } from './domains/ed25519Yao/registration/routerAbEd25519YaoRegistrationRequestScopedCloudflare';
+export type { RouterAbEd25519YaoRegistrationRequestScopedCloudflareInputV1 } from './domains/ed25519Yao/registration/routerAbEd25519YaoRegistrationRequestScopedCloudflare';
+//# sourceMappingURL=cloudflare-adaptor.d.ts.map