@seams/wallet-server 0.5.0

package/dist/types/shared-ts/src/passkey-custody/custodyEnvelope.d.ts

@@ -0,0 +1,191 @@
+import type { PasskeyEnvelopeId, WalletAuthMethodId, WalletId, WebAuthnCredentialIdB64u, WebAuthnRpId } from '../utils/domainIds';
+import type { DigestB64u } from '../utils/canonicalPrimitives';
+import type { PasskeyCustodySecretBinding } from './custodySecretBinding';
+import type { EnvelopeCiphertextB64u, EnvelopeNonceB64u, EnvelopeRevision } from './primitives';
+export declare const WALLET_CUSTODY_ENVELOPE_VERSION_V2: "wallet_custody_envelope_v2";
+/** Refactor 109C: an envelope whose owning auth method is part of its AAD. */
+export declare const WALLET_CUSTODY_ENVELOPE_VERSION_V3: "wallet_custody_envelope_v3";
+export declare const PASSKEY_PRF_KEK_VERSION_V1: "passkey_prf_kek_hkdf_sha256_v1";
+export declare const EMAIL_OTP_FACTOR_KEK_VERSION_V1: "email_otp_factor_kek_hkdf_sha256_v1";
+export type WalletCustodyEnvelopeVersion = typeof WALLET_CUSTODY_ENVELOPE_VERSION_V2;
+export type PasskeyPrfKekVersion = typeof PASSKEY_PRF_KEK_VERSION_V1;
+export type EmailOtpFactorKekVersion = typeof EMAIL_OTP_FACTOR_KEK_VERSION_V1;
+/**
+ * Which enrolled factor sealed this envelope.
+ *
+ * Factors are interchangeable unwrap paths to the same custody seed: each has
+ * its own envelope, KEK derivation, and revocation, so enrolling or revoking
+ * one never touches another's ciphertext. Factor-specific identity lives inside
+ * the branch rather than at the record's top level, which is what stops an
+ * Email OTP envelope from carrying an RP ID or a passkey envelope from
+ * carrying an enrollment id.
+ */
+/**
+ * Mirrors `signer_core::PasskeyCustodyEnvelopeOwnershipV1`.
+ *
+ * `method_bound` is the only shape a new envelope may be written in; `unbound`
+ * exists to open envelopes sealed before ownership was authenticated, and a
+ * successful open is followed by a reseal once the exact method is known. The
+ * two encode different AAD, which is what stops a stored envelope from being
+ * relabelled to a sibling method.
+ */
+export type WalletCustodyEnvelopeOwnership = {
+    readonly kind: 'unbound';
+    readonly walletAuthMethodId?: never;
+} | {
+    readonly kind: 'method_bound';
+    readonly walletAuthMethodId: WalletAuthMethodId;
+};
+export type WalletCustodyEnvelopeFactor = {
+    kind: 'passkey';
+    rpId: WebAuthnRpId;
+    credentialIdB64u: WebAuthnCredentialIdB64u;
+    kekVersion: PasskeyPrfKekVersion;
+    enrollmentId?: never;
+    enrollmentSealKeyVersion?: never;
+} | {
+    kind: 'email_otp';
+    enrollmentId: string;
+    enrollmentSealKeyVersion: string;
+    kekVersion: EmailOtpFactorKekVersion;
+    rpId?: never;
+    credentialIdB64u?: never;
+};
+export type WalletCustodyFactorKind = WalletCustodyEnvelopeFactor['kind'];
+export type PasskeyCustodyEnvelopeLifecycle = {
+    state: 'active';
+    activatedAtMs: number;
+    retiredAtMs?: never;
+    revokedAtMs?: never;
+} | {
+    state: 'retired';
+    activatedAtMs: number;
+    retiredAtMs: number;
+    revokedAtMs?: never;
+} | {
+    state: 'revoked';
+    activatedAtMs: number;
+    revokedAtMs: number;
+    retiredAtMs?: never;
+};
+/**
+ * Ciphertext plus public binding data for one factor-sealed custody secret.
+ *
+ * This record carries no authorization identity: no `AuthorizationGrantRef`,
+ * `WalletSessionId`, `MpcWalletSigningQuotaId`, `AuthorizedOperationId`, or
+ * bearer session. Those are resolved per operation at the Refactor 90 boundary.
+ * It also carries no `MpcMaterialActivationRef` — activation identity is bound
+ * when opened material enters the canonical activation boundary, so an explicit
+ * reactivation can mint a fresh activation id without rewriting this envelope.
+ */
+export type PasskeyCustodyEnvelopeRecord = {
+    kind: 'wallet_custody_envelope_v2';
+    envelopeId: PasskeyEnvelopeId;
+    walletId: WalletId;
+    /** Which auth method owns this envelope, and whether that is authenticated. */
+    ownership: WalletCustodyEnvelopeOwnership;
+    binding: PasskeyCustodySecretBinding;
+    factor: WalletCustodyEnvelopeFactor;
+    envelopeVersion: WalletCustodyEnvelopeVersion;
+    envelopeRevision: EnvelopeRevision;
+    nonceB64u: EnvelopeNonceB64u;
+    sealedCustodySecretB64u: EnvelopeCiphertextB64u;
+    ciphertextDigestB64u: DigestB64u;
+    aadHashB64u: DigestB64u;
+    lifecycle: PasskeyCustodyEnvelopeLifecycle;
+    createdAtMs: number;
+    updatedAtMs: number;
+};
+export declare function parseWalletCustodyEnvelopeOwnership(raw: unknown, label: string): WalletCustodyEnvelopeOwnership;
+/**
+ * The exact JSON `signer_core::PasskeyCustodyEnvelopeBindingV1` deserialises.
+ *
+ * Every caller that hands a binding to wasm must build it here. The Rust struct
+ * uses `deny_unknown_fields` and now requires `ownership`, so a hand-rolled
+ * object that omits it fails to deserialise — and that failure surfaces as an
+ * unopenable envelope, not a type error.
+ */
+export declare function custodyEnvelopeBindingJsonV1(envelope: Pick<PasskeyCustodyEnvelopeRecord, 'walletId' | 'envelopeId' | 'factor' | 'envelopeRevision' | 'binding' | 'ownership'>): string;
+/**
+ * Reads the serde shape back — the inverse of `custodyEnvelopeOwnershipWireV1`.
+ *
+ * The record shape and the wire shape are deliberately different: one is
+ * TypeScript's tagged union, the other is what `serde` emits for a Rust enum.
+ * Anything that came out of wasm carries the wire shape, and passing it to the
+ * record parser would reject a perfectly valid ownership for having no `kind`.
+ */
+export declare function parseWalletCustodyEnvelopeOwnershipWireV1(raw: unknown, label: string): WalletCustodyEnvelopeOwnership;
+/** Serde's shape for the ownership enum: a bare string, or a one-key object. */
+export declare function custodyEnvelopeOwnershipWireV1(ownership: WalletCustodyEnvelopeOwnership): unknown;
+export declare function buildMethodBoundEnvelopeOwnership(walletAuthMethodId: WalletAuthMethodId): WalletCustodyEnvelopeOwnership;
+export declare function buildPasskeyEnvelopeFactor(args: {
+    rpId: WebAuthnRpId;
+    credentialIdB64u: WebAuthnCredentialIdB64u;
+}): Extract<WalletCustodyEnvelopeFactor, {
+    readonly kind: 'passkey';
+}>;
+export declare function buildEmailOtpEnvelopeFactor(args: {
+    enrollmentId: string;
+    enrollmentSealKeyVersion: string;
+}): Extract<WalletCustodyEnvelopeFactor, {
+    readonly kind: 'email_otp';
+}>;
+export declare function buildActiveEnvelopeLifecycle(args: {
+    activatedAtMs: number;
+}): PasskeyCustodyEnvelopeLifecycle;
+export declare function buildRetiredEnvelopeLifecycle(args: {
+    activatedAtMs: number;
+    retiredAtMs: number;
+}): PasskeyCustodyEnvelopeLifecycle;
+export declare function buildRevokedEnvelopeLifecycle(args: {
+    activatedAtMs: number;
+    revokedAtMs: number;
+}): PasskeyCustodyEnvelopeLifecycle;
+export declare function buildPasskeyCustodyEnvelopeRecord(args: {
+    envelopeId: PasskeyEnvelopeId;
+    walletId: WalletId;
+    ownership: WalletCustodyEnvelopeOwnership;
+    binding: PasskeyCustodySecretBinding;
+    factor: WalletCustodyEnvelopeFactor;
+    envelopeRevision: EnvelopeRevision;
+    nonceB64u: EnvelopeNonceB64u;
+    sealedCustodySecretB64u: EnvelopeCiphertextB64u;
+    ciphertextDigestB64u: DigestB64u;
+    aadHashB64u: DigestB64u;
+    lifecycle: PasskeyCustodyEnvelopeLifecycle;
+    createdAtMs: number;
+    updatedAtMs: number;
+}): PasskeyCustodyEnvelopeRecord;
+export declare function parsePasskeyCustodyEnvelopeLifecycle(raw: unknown, label?: string): PasskeyCustodyEnvelopeLifecycle;
+export declare function parseWalletCustodyEnvelopeFactor(raw: unknown, label?: string): WalletCustodyEnvelopeFactor;
+/**
+ * Parses one raw server row, wire payload, or IndexedDB cache entry into the
+ * exact envelope record. This is the single boundary: core custody code accepts
+ * `PasskeyCustodyEnvelopeRecord`, never a raw shape.
+ */
+export declare function parsePasskeyCustodyEnvelopeRecord(raw: unknown, label?: string): PasskeyCustodyEnvelopeRecord;
+export declare function isActivePasskeyCustodyEnvelope(envelope: PasskeyCustodyEnvelopeRecord): boolean;
+/** Two ownerships name the same owner. */
+export declare function sameWalletCustodyEnvelopeOwnership(left: WalletCustodyEnvelopeOwnership, right: WalletCustodyEnvelopeOwnership): boolean;
+export type WalletCustodyEnvelopeOwnershipReplacementAdmissionV1 = {
+    readonly kind: 'admitted';
+} | {
+    readonly kind: 'refused';
+    readonly reason: string;
+};
+/**
+ * Whether a stored envelope's ownership may be replaced by another.
+ *
+ * Two rules, and both are load-bearing. A replacement is always `method_bound`,
+ * because no path may write a new V2 envelope — `unbound` exists only to decode
+ * what was sealed before ownership was authenticated. And a stored owner may
+ * only be replaced by itself: an envelope already bound to one method is never
+ * rebound to a sibling, which is the whole point of putting the owner in the
+ * AAD. That leaves exactly one transition that moves anything — the pre-109C
+ * upgrade, `unbound` to the method that just proved it can open the envelope.
+ */
+export declare function admitWalletCustodyEnvelopeOwnershipReplacementV1(input: {
+    readonly stored: WalletCustodyEnvelopeOwnership;
+    readonly replacement: WalletCustodyEnvelopeOwnership;
+}): WalletCustodyEnvelopeOwnershipReplacementAdmissionV1;
+//# sourceMappingURL=custodyEnvelope.d.ts.map

package/dist/types/shared-ts/src/passkey-custody/custodySecretBinding.d.ts

@@ -0,0 +1,140 @@
+import type { LaneShareEpoch, LinkedDeviceEnrollmentId, LinkedDeviceId, LinkDeviceSessionId, SigningLaneId, WalletKeyId } from '../signing-lanes/ids';
+import type { EvmFamilySigningKeySlotId } from '../signing-lanes/evmFamilySigningKeySlotId';
+import type { ThresholdEcdsaSessionId } from '../utils/domainIds';
+import type { NearEd25519SigningKeyId } from '../utils/registrationIntent';
+import type { DigestB64u } from '../utils/canonicalPrimitives';
+import type { Ed25519PublicKeyB64u, Secp256k1CompressedPublicKeyB64u } from './primitives';
+/**
+ * The protocol capability an opened envelope restores.
+ *
+ * Owner custody is one wallet-scoped seed: every owner signing root derives
+ * from it in parallel, so there is nothing per-curve to seal separately. Lane
+ * holder shares stay per-lane because Refactor 102 provisions them
+ * individually — they are not seed-derived.
+ */
+export type PasskeyCustodySecretKind = 'wallet_custody_seed_v1' | 'ed25519_yao_client_root_v1' | 'ed25519_lane_holder_share_v1' | 'ecdsa_lane_holder_share_v1';
+/** The only derivation scheme owner custody supports. */
+export declare const WALLET_SEED_DERIVATION_SCHEME_V1: "wallet_seed_parallel_hkdf_sha256_v1";
+export type WalletSeedDerivationScheme = typeof WALLET_SEED_DERIVATION_SCHEME_V1;
+export type PasskeyCustodySecretBinding = {
+    /**
+     * One random seed per wallet. Every owner signing root derives from it in
+     * parallel with domain-separated HKDF; no signing root is ever derived
+     * from another signing root. Each enrolled factor wraps this same seed,
+     * which is what makes passkey and Email OTP interchangeable.
+     *
+     * Wallet-scoped by construction: it carries no lane identity, because it
+     * covers every owner key rather than one lane's material.
+     *
+     * It names no key set either. Key sets are provisioned independently — an
+     * EVM wallet today, NEAR later — and each records its own manifest on its
+     * own registration state. A seed that named its key sets would have to be
+     * resealed, and its recovery codes rewrapped, every time one arrived.
+     */
+    kind: 'wallet_custody_seed_v1';
+    derivationScheme: WalletSeedDerivationScheme;
+    keyManifestDigestB64u?: never;
+    nearEd25519SigningKeyId?: never;
+    registeredPublicKeyB64u?: never;
+    evmFamilySigningKeySlotId?: never;
+    clientRootPublicKey33B64u?: never;
+    walletKeyId?: never;
+    laneId?: never;
+    laneShareEpoch?: never;
+    participantBindingDigestB64u?: never;
+    thresholdSessionId?: never;
+    thresholdPublicKey33B64u?: never;
+} | {
+    kind: 'ed25519_yao_client_root_v1';
+    linkSessionId: LinkDeviceSessionId;
+    walletKeyId: WalletKeyId;
+    targetFactor: Ed25519YaoClientRootTargetFactorV1;
+    applicationBindingDigestB64u: DigestB64u;
+    registeredPublicKeyB64u: Ed25519PublicKeyB64u;
+    enrollmentId: LinkedDeviceEnrollmentId;
+    deviceId: LinkedDeviceId;
+    revocationEpoch: number;
+    derivationScheme?: never;
+    keyManifestDigestB64u?: never;
+    nearEd25519SigningKeyId?: never;
+    evmFamilySigningKeySlotId?: never;
+    clientRootPublicKey33B64u?: never;
+    laneId?: never;
+    laneShareEpoch?: never;
+    participantBindingDigestB64u?: never;
+    thresholdSessionId?: never;
+    thresholdPublicKey33B64u?: never;
+} | {
+    kind: 'ed25519_lane_holder_share_v1';
+    walletKeyId: WalletKeyId;
+    laneId: SigningLaneId;
+    laneShareEpoch: LaneShareEpoch;
+    nearEd25519SigningKeyId: NearEd25519SigningKeyId;
+    registeredPublicKeyB64u: Ed25519PublicKeyB64u;
+    participantBindingDigestB64u: DigestB64u;
+    derivationScheme?: never;
+    keyManifestDigestB64u?: never;
+    evmFamilySigningKeySlotId?: never;
+    clientRootPublicKey33B64u?: never;
+    thresholdSessionId?: never;
+    thresholdPublicKey33B64u?: never;
+} | {
+    kind: 'ecdsa_lane_holder_share_v1';
+    walletKeyId: WalletKeyId;
+    laneId: SigningLaneId;
+    laneShareEpoch: LaneShareEpoch;
+    evmFamilySigningKeySlotId: EvmFamilySigningKeySlotId;
+    thresholdSessionId: ThresholdEcdsaSessionId;
+    thresholdPublicKey33B64u: Secp256k1CompressedPublicKeyB64u;
+    derivationScheme?: never;
+    keyManifestDigestB64u?: never;
+    nearEd25519SigningKeyId?: never;
+    registeredPublicKeyB64u?: never;
+    participantBindingDigestB64u?: never;
+    clientRootPublicKey33B64u?: never;
+};
+export type Ed25519YaoClientRootTargetFactorV1 = {
+    readonly kind: 'passkey_prf';
+} | {
+    readonly kind: 'email_otp';
+};
+export type PasskeyCustodySecretBindingOfKind<TKind extends PasskeyCustodySecretKind> = Extract<PasskeyCustodySecretBinding, {
+    kind: TKind;
+}>;
+/** True when this binding covers owner custody rather than one lane's share. */
+export declare function isWalletCustodySeedBinding(binding: PasskeyCustodySecretBinding): binding is PasskeyCustodySecretBindingOfKind<'wallet_custody_seed_v1'>;
+export declare function buildWalletCustodySeedBinding(): PasskeyCustodySecretBindingOfKind<'wallet_custody_seed_v1'>;
+export declare function buildEd25519YaoClientRootBinding(args: {
+    linkSessionId: LinkDeviceSessionId;
+    walletKeyId: WalletKeyId;
+    targetFactor: Ed25519YaoClientRootTargetFactorV1;
+    applicationBindingDigestB64u: DigestB64u;
+    registeredPublicKeyB64u: Ed25519PublicKeyB64u;
+    enrollmentId: LinkedDeviceEnrollmentId;
+    deviceId: LinkedDeviceId;
+    revocationEpoch: number;
+}): PasskeyCustodySecretBindingOfKind<'ed25519_yao_client_root_v1'>;
+export declare function buildEd25519LaneHolderShareBinding(args: {
+    walletKeyId: WalletKeyId;
+    laneId: SigningLaneId;
+    laneShareEpoch: LaneShareEpoch;
+    nearEd25519SigningKeyId: NearEd25519SigningKeyId;
+    registeredPublicKeyB64u: Ed25519PublicKeyB64u;
+    participantBindingDigestB64u: DigestB64u;
+}): PasskeyCustodySecretBindingOfKind<'ed25519_lane_holder_share_v1'>;
+export declare function buildEcdsaLaneHolderShareBinding(args: {
+    walletKeyId: WalletKeyId;
+    laneId: SigningLaneId;
+    laneShareEpoch: LaneShareEpoch;
+    evmFamilySigningKeySlotId: EvmFamilySigningKeySlotId;
+    thresholdSessionId: ThresholdEcdsaSessionId;
+    thresholdPublicKey33B64u: Secp256k1CompressedPublicKeyB64u;
+}): PasskeyCustodySecretBindingOfKind<'ecdsa_lane_holder_share_v1'>;
+/**
+ * Parses one raw persistence or wire shape into an exact custody-secret branch.
+ * Cross-branch fields, unknown fields, and plaintext-secret fields are rejected
+ * rather than dropped, so a mismatched record can never be narrowed into a
+ * branch it does not satisfy.
+ */
+export declare function parsePasskeyCustodySecretBinding(raw: unknown, label?: string): PasskeyCustodySecretBinding;
+//# sourceMappingURL=custodySecretBinding.d.ts.map

package/dist/types/shared-ts/src/passkey-custody/envelopeIndex.d.ts

@@ -0,0 +1,29 @@
+import type { LaneShareEpoch, SigningLaneId, WalletKeyId } from '../signing-lanes/ids';
+import type { PasskeyEnvelopeId, WalletId } from '../utils/domainIds';
+import type { PasskeyCustodyEnvelopeLifecycle, WalletCustodyEnvelopeFactor } from './custodyEnvelope';
+import type { PasskeyCustodySecretKind } from './custodySecretBinding';
+/**
+ * Public listing row for factor management: which factor protects which custody
+ * secret, under which envelope. It holds no ciphertext, so listing a wallet's
+ * enrolled factors never moves sealed custody material.
+ *
+ * Lane scope is optional because owner custody is wallet-scoped: a
+ * `wallet_custody_seed_v1` row covers every owner key and carries no lane,
+ * while a lane holder-share row names exactly one lane.
+ */
+export type PasskeyDeviceEnvelopeIndexRecord = {
+    kind: 'wallet_custody_envelope_index_v2';
+    walletId: WalletId;
+    custodySecretKind: PasskeyCustodySecretKind;
+    factor: WalletCustodyEnvelopeFactor;
+    envelopeId: PasskeyEnvelopeId;
+    /** Absent until the owner chooses a name for this credential. */
+    deviceLabel?: string;
+    lifecycle: PasskeyCustodyEnvelopeLifecycle;
+    walletKeyId?: WalletKeyId;
+    laneId?: SigningLaneId;
+    laneShareEpoch?: LaneShareEpoch;
+    createdAtMs: number;
+    updatedAtMs: number;
+};
+//# sourceMappingURL=envelopeIndex.d.ts.map

package/dist/types/shared-ts/src/passkey-custody/index.d.ts

@@ -0,0 +1,9 @@
+export * from './primitives';
+export * from './custodySecretBinding';
+export * from './custodyEnvelope';
+export * from './ceremonyCommitPayload';
+export * from './credentialActivity';
+export * from './kekContext';
+export * from './envelopeIndex';
+export * from './credentialObservations';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/shared-ts/src/passkey-custody/kekContext.d.ts

@@ -0,0 +1,34 @@
+import type { PasskeyEnvelopeId, WalletId } from '../utils/domainIds';
+import type { EmailOtpFactorKekVersion, PasskeyCustodyEnvelopeRecord, PasskeyPrfKekVersion, WalletCustodyEnvelopeFactor } from './custodyEnvelope';
+import type { PasskeyCustodySecretKind } from './custodySecretBinding';
+export type PasskeyCustodyKekPurpose = PasskeyCustodySecretKind;
+/**
+ * The exact HKDF `info` inputs for one envelope's KEK:
+ *
+ *   factor_kek = HKDF-SHA256(
+ *     ikm  = the factor secret (WebAuthn PRF.first, or the Email OTP factor key),
+ *     salt = versioned application salt,
+ *     info = hash(factor identity, walletId, envelopeId, purpose, version))
+ *
+ * The factor secret and the salt are not part of this record: the context is
+ * public binding data, and only the secure worker ever holds the secret.
+ *
+ * The factor branch is carried whole rather than flattened, so a passkey
+ * context can never be built from an Email OTP envelope's identity — the two
+ * factors wrap the same seed but must never derive the same KEK.
+ */
+export type PasskeyCustodyKekDerivationContext = {
+    kind: 'wallet_custody_kek_derivation_context_v2';
+    walletId: WalletId;
+    envelopeId: PasskeyEnvelopeId;
+    factor: WalletCustodyEnvelopeFactor;
+    purpose: PasskeyCustodyKekPurpose;
+    kekVersion: PasskeyPrfKekVersion | EmailOtpFactorKekVersion;
+};
+/**
+ * Derives the KEK context from a parsed envelope. Callers cannot assemble one
+ * field by field, so a KEK is always bound to the factor, wallet, envelope, and
+ * custody branch the ciphertext was sealed under.
+ */
+export declare function buildPasskeyCustodyKekDerivationContext(envelope: PasskeyCustodyEnvelopeRecord): PasskeyCustodyKekDerivationContext;
+//# sourceMappingURL=kekContext.d.ts.map

package/dist/types/shared-ts/src/passkey-custody/passkeyCustody.typecheck.d.ts

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

package/dist/types/shared-ts/src/passkey-custody/primitives.d.ts

@@ -0,0 +1,34 @@
+import { type DigestB64u } from '../utils/canonicalPrimitives';
+type PasskeyCustodyBrand<TName extends string> = {
+    readonly __passkeyCustodyBrand: TName;
+};
+export type EnvelopeNonceB64u = string & PasskeyCustodyBrand<'EnvelopeNonceB64u'>;
+export type EnvelopeCiphertextB64u = string & PasskeyCustodyBrand<'EnvelopeCiphertextB64u'>;
+export type Ed25519PublicKeyB64u = string & PasskeyCustodyBrand<'Ed25519PublicKeyB64u'>;
+export type Secp256k1CompressedPublicKeyB64u = string & PasskeyCustodyBrand<'Secp256k1CompressedPublicKeyB64u'>;
+export type KeyCreationSignerSlot = number & PasskeyCustodyBrand<'KeyCreationSignerSlot'>;
+export type EnvelopeRevision = number & PasskeyCustodyBrand<'EnvelopeRevision'>;
+export declare function parseDigestField(value: unknown, label: string): DigestB64u;
+export declare const PASSKEY_CUSTODY_WRAP_ALG_V1: "chacha20poly1305-hkdf-sha256-v1";
+export declare const PASSKEY_CUSTODY_WRAP_NONCE_LENGTH: 12;
+export declare const PASSKEY_CUSTODY_WRAP_TAG_LENGTH: 16;
+export declare function parseEnvelopeNonceB64u(value: unknown, label?: string): EnvelopeNonceB64u;
+export declare function parseEnvelopeCiphertextB64u(value: unknown, label?: string): EnvelopeCiphertextB64u;
+export declare function parseEd25519PublicKeyB64u(value: unknown, label?: string): Ed25519PublicKeyB64u;
+export declare function parseSecp256k1CompressedPublicKeyB64u(value: unknown, label?: string): Secp256k1CompressedPublicKeyB64u;
+export declare function parseKeyCreationSignerSlot(value: unknown, label?: string): KeyCreationSignerSlot;
+export declare function parseEnvelopeRevision(value: unknown, label?: string): EnvelopeRevision;
+export declare function parseUnixMs(value: unknown, label: string): number;
+export declare function requireRecord(value: unknown, label: string): Record<string, unknown>;
+/**
+ * Rejects every field outside this record's exact shape.
+ *
+ * `knownOnOtherBranches` names fields that are legitimate public bindings
+ * somewhere else in the same union. Those are reported as the branch mismatch
+ * they are; only genuinely unknown fields are classified as leaks, so a public
+ * key like `clientRootPublicKey33B64u` on the wrong branch is never mistaken
+ * for plaintext custody material.
+ */
+export declare function rejectUnknownFields(record: Record<string, unknown>, allowed: readonly string[], label: string, knownOnOtherBranches?: readonly string[]): void;
+export {};
+//# sourceMappingURL=primitives.d.ts.map

package/dist/types/shared-ts/src/signing-lanes/evmFamilySigningKeySlotId.d.ts

@@ -0,0 +1,27 @@
+import type { DomainIdParseResult } from '../utils/domainIds';
+export type EvmFamilySigningKeySlotId = string & {
+    readonly __evmFamilySigningKeySlotIdBrand: 'EvmFamilySigningKeySlotId';
+};
+export declare function parseEvmFamilySigningKeySlotId(raw: unknown): DomainIdParseResult<EvmFamilySigningKeySlotId>;
+export declare function parseEvmFamilySigningKeySlotIdOrNull(raw: unknown): EvmFamilySigningKeySlotId | null;
+export declare function requireEvmFamilySigningKeySlotId(value: unknown, label?: string): EvmFamilySigningKeySlotId;
+export declare function assertMatchingEvmFamilySigningKeySlotId(args: {
+    expected: unknown;
+    actual: unknown;
+    expectedLabel?: string;
+    actualLabel?: string;
+    message?: string;
+}): EvmFamilySigningKeySlotId;
+export declare function assertEvmFamilySigningKeySlotIdMatchesPlan(args: {
+    evmFamilySigningKeySlotId: unknown;
+    walletId: unknown;
+    signingRootId: unknown;
+    signingRootVersion: unknown;
+    message?: string;
+}): EvmFamilySigningKeySlotId;
+export declare function deriveEvmFamilySigningKeySlotId(input: {
+    walletId: unknown;
+    signingRootId: unknown;
+    signingRootVersion: unknown;
+}): EvmFamilySigningKeySlotId;
+//# sourceMappingURL=evmFamilySigningKeySlotId.d.ts.map

package/dist/types/shared-ts/src/signing-lanes/execution.d.ts

@@ -0,0 +1,91 @@
+import type { AuthorizedOperationId, CapabilityId } from '../authorization/capabilityKinds';
+import type { CapabilityOperationFingerprintDigest } from '../authorization/operationFingerprint';
+import type { DomainId, MpcMaterialActivationRef } from '../utils/domainIds';
+import type { LinkedDeviceEnrollmentId } from './ids';
+import type { LinkedDeviceId, LaneShareEpoch, SigningLaneId, WalletKeyId } from './ids';
+import type { ActiveSigningLaneReference, DelegatedSpendAuthorizationId } from './records';
+import { type RouterAbMpcMaterialActivationRefWire } from '../utils/routerAbNormalSigningIdentity';
+export type LinkedDeviceExecutionEnvelopeV1 = {
+    readonly kind: 'linked_device_execution_v1';
+    readonly enrollmentId: LinkedDeviceEnrollmentId;
+    readonly deviceId: LinkedDeviceId;
+    readonly walletKeyId: WalletKeyId;
+    readonly laneId: SigningLaneId;
+    readonly laneShareEpoch: LaneShareEpoch;
+    readonly materialActivation: RouterAbMpcMaterialActivationRefWire;
+};
+export declare function buildLinkedDeviceExecutionEnvelopeV1(input: {
+    readonly enrollmentId: LinkedDeviceEnrollmentId;
+    readonly deviceId: LinkedDeviceId;
+    readonly walletKeyId: WalletKeyId;
+    readonly laneId: SigningLaneId;
+    readonly laneShareEpoch: LaneShareEpoch;
+    readonly materialActivation: MpcMaterialActivationRef;
+}): LinkedDeviceExecutionEnvelopeV1;
+export type DelegatedBudgetClaimId = DomainId<'DelegatedBudgetClaimId'>;
+export type ClaimedWalletExecutionAuthorization = {
+    readonly kind: 'claimed_wallet_execution_authorization_v1';
+    readonly authorizedOperationId: AuthorizedOperationId;
+    readonly operationFingerprintDigest: CapabilityOperationFingerprintDigest;
+    readonly capabilityId: CapabilityId;
+};
+export type ReservedDelegatedBudgetClaim = {
+    readonly kind: 'reserved_delegated_budget_claim_v1';
+    readonly budgetClaimId: DelegatedBudgetClaimId;
+};
+type PreparedWalletExecutionBase = {
+    readonly authorization: ClaimedWalletExecutionAuthorization;
+    readonly materialActivation: MpcMaterialActivationRef;
+};
+export type PreparedOwnerWalletExecution = PreparedWalletExecutionBase & {
+    readonly kind: 'prepared_owner_wallet_execution';
+    readonly laneKind: 'owner_passkey' | 'owner_email_otp' | 'recovery' | 'break_glass';
+    readonly lane: ActiveSigningLaneReference & {
+        readonly laneKind: PreparedOwnerWalletExecution['laneKind'];
+    };
+    readonly linkedDeviceEnrollmentId?: never;
+    readonly delegatedAuthorizationId?: never;
+    readonly budgetClaim?: never;
+};
+export type PreparedLinkedDeviceWalletExecution = PreparedWalletExecutionBase & {
+    readonly kind: 'prepared_linked_device_wallet_execution';
+    readonly laneKind: 'linked_device';
+    readonly lane: ActiveSigningLaneReference & {
+        readonly laneKind: 'linked_device';
+    };
+    readonly linkedDeviceEnrollmentId: LinkedDeviceEnrollmentId;
+    readonly delegatedAuthorizationId?: never;
+    readonly budgetClaim?: never;
+};
+export type PreparedDelegatedWalletExecution = PreparedWalletExecutionBase & {
+    readonly kind: 'prepared_delegated_wallet_execution';
+    readonly laneKind: 'delegated_execution';
+    readonly lane: ActiveSigningLaneReference & {
+        readonly laneKind: 'delegated_execution';
+    };
+    readonly delegatedAuthorizationId: DelegatedSpendAuthorizationId;
+    readonly budgetClaim: ReservedDelegatedBudgetClaim;
+    readonly linkedDeviceEnrollmentId?: never;
+};
+export type PreparedWalletExecution = PreparedOwnerWalletExecution | PreparedLinkedDeviceWalletExecution | PreparedDelegatedWalletExecution;
+export declare function buildPreparedOwnerWalletExecution(input: {
+    readonly authorization: ClaimedWalletExecutionAuthorization;
+    readonly materialActivation: MpcMaterialActivationRef;
+    readonly lane: PreparedOwnerWalletExecution['lane'];
+}): PreparedOwnerWalletExecution;
+export declare function buildPreparedLinkedDeviceWalletExecution(input: {
+    readonly authorization: ClaimedWalletExecutionAuthorization;
+    readonly materialActivation: MpcMaterialActivationRef;
+    readonly lane: PreparedLinkedDeviceWalletExecution['lane'];
+    readonly linkedDeviceEnrollmentId: LinkedDeviceEnrollmentId;
+}): PreparedLinkedDeviceWalletExecution;
+export declare function buildPreparedDelegatedWalletExecution(input: {
+    readonly authorization: ClaimedWalletExecutionAuthorization;
+    readonly materialActivation: MpcMaterialActivationRef;
+    readonly lane: PreparedDelegatedWalletExecution['lane'];
+    readonly delegatedAuthorizationId: DelegatedSpendAuthorizationId;
+    readonly budgetClaim: ReservedDelegatedBudgetClaim;
+}): PreparedDelegatedWalletExecution;
+export declare function assertNeverPreparedWalletExecution(value: never): never;
+export {};
+//# sourceMappingURL=execution.d.ts.map

package/dist/types/shared-ts/src/signing-lanes/execution.typecheck.d.ts

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

package/dist/types/shared-ts/src/signing-lanes/ids.d.ts

@@ -0,0 +1,18 @@
+import type { EcdsaCapabilityManifestId, EcdsaCapabilityManifestRevision } from '../utils/ecdsaCapabilityActivation';
+export type { LaneShareEpoch, LaneEnrollmentId, LaneOperationId, LaneOperationIdempotencyKey, LinkedDeviceId, LinkedDeviceEnrollmentId, LinkDeviceSessionId, SigningLaneId, WalletKeyId, Ed25519YaoSuiteId, EcdsaRelayerKeyId, } from '../utils/domainIds';
+export type EcdsaManifestIdentity = {
+    manifestId: EcdsaCapabilityManifestId;
+    manifestRevision: EcdsaCapabilityManifestRevision;
+};
+export type ThresholdEcdsaChainTarget = {
+    kind: 'evm';
+    namespace: 'eip155';
+    chainId: number;
+    networkSlug: string;
+} | {
+    kind: 'tempo';
+    chainId: number;
+    networkSlug: string;
+};
+export { parseLaneShareEpoch, parseLaneEnrollmentId, parseLaneOperationId, parseLaneOperationIdempotencyKey, parseLinkedDeviceId, parseLinkedDeviceEnrollmentId, parseLinkDeviceSessionId, parseSigningLaneId, parseWalletKeyId, parseEd25519YaoSuiteId, parseEcdsaRelayerKeyId, } from '../utils/domainIds';
+//# sourceMappingURL=ids.d.ts.map

package/dist/types/shared-ts/src/signing-lanes/index.d.ts

@@ -0,0 +1,14 @@
+export * from './ids';
+export * from './validation';
+export * from './records';
+export * from './rotation';
+export * from './rotationParsers';
+export * from './rotationDigests';
+export * from './rotationLifecycle';
+export * from './evmFamilySigningKeySlotId';
+export * from './participants';
+export * from './participantDigest';
+export * from './execution';
+export * from './ownerContinuity';
+export * from './linkedEcdsaScope';
+//# sourceMappingURL=index.d.ts.map