@did-btcr2/aggregation 0.1.0

package/dist/types/runner/participant-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"participant-runner.d.ts","sourceRoot":"","sources":["../../../src/runner/participant-runner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAWzD,OAAO,KAAK,EACV,YAAY,EACZ,qBAAqB,EACrB,iBAAiB,EAAC,MAAM,mBAAmB,CAAC;AAC9C,OAAO,EACL,sBAAsB,EACvB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,KAAK,EAAE,4BAA4B,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACpF,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAEvD,yEAAyE;AACzE,MAAM,MAAM,UAAU,GAAG,CAAC,MAAM,EAAE,YAAY,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;AAEpE,wEAAwE;AACxE,MAAM,MAAM,eAAe,GAAG,CAAC,IAAI,EAAE;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;CACvB,KAAK,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAAC;AAExC,4DAA4D;AAC5D,MAAM,MAAM,cAAc,GAAG,CAAC,IAAI,EAAE,iBAAiB,KAAK,OAAO,CAAC;IAAE,QAAQ,EAAE,OAAO,CAAA;CAAE,CAAC,CAAC;AAEzF,oDAAoD;AACpD,MAAM,MAAM,gBAAgB,GAAG,CAAC,IAAI,EAAE,qBAAqB,KAAK,OAAO,CAAC;IAAE,QAAQ,EAAE,OAAO,CAAA;CAAE,CAAC,CAAC;AAE/F,MAAM,WAAW,mCAAmC;IAClD,4BAA4B;IAC5B,SAAS,EAAE,SAAS,CAAC;IAErB,4BAA4B;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,cAAc,CAAC;IAErB;;;OAGG;IACH,UAAU,CAAC,EAAE,UAAU,CAAC;IAExB;;;OAGG;IACH,eAAe,EAAE,eAAe,CAAC;IAEjC;;;OAGG;IACH,cAAc,CAAC,EAAE,cAAc,CAAC;IAEhC;;;OAGG;IACH,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;CACrC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,qBAAa,4BAA6B,SAAQ,iBAAiB,CAAC,4BAA4B,CAAC;;IAC/F,sEAAsE;IACtE,QAAQ,CAAC,OAAO,EAAE,sBAAsB,CAAC;gBAY7B,OAAO,EAAE,mCAAmC;IAexD;;;OAGG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B,8EAA8E;IAC9E,IAAI,IAAI,IAAI;IA6BZ;;;;OAIG;WACU,SAAS,CACpB,OAAO,EAAE,mCAAmC,GAC3C,OAAO,CAAC,kBAAkB,CAAC;IAY9B;;;;;;;;;;;;;;;OAeG;WACU,YAAY,CACvB,OAAO,EAAE,mCAAmC,EAC5C,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,kBAAkB,EAAE,CAAC;CAiRjC"}

package/dist/types/runner/service-runner.d.ts

@@ -0,0 +1,228 @@
+import type { SchnorrKeyPair } from '@did-btcr2/keypair';
+import type { AggregationResult, CohortConfig, PendingOptIn, SigningTxData } from '../service.js';
+import { AggregationService } from '../service.js';
+import type { Transport } from '../transport/transport.js';
+import type { FeeEstimator } from '@did-btcr2/bitcoin';
+import type { AggregationServiceEvents } from './events.js';
+import { TypedEventEmitter } from './typed-emitter.js';
+/** Decision callback: accept or reject a participant's opt-in. */
+export type OnOptInReceived = (optIn: PendingOptIn) => Promise<{
+    accepted: boolean;
+}>;
+/** Decision callback: finalize keygen now, or wait for more participants. */
+export type OnReadyToFinalize = (info: {
+    acceptedCount: number;
+    minRequired: number;
+}) => Promise<{
+    finalize: boolean;
+}>;
+/** Data callback: provide the Bitcoin transaction data to sign. */
+export type OnProvideTxData = (info: {
+    cohortId: string;
+    beaconAddress: string;
+    signalBytes: Uint8Array;
+    /**
+     * Fee estimator the runner is configured with (the runner's `feeEstimator`
+     * option, or a static 5 sat/vB default). Forward it to the beacon transaction
+     * builder so a dynamic rate injected at the runner is honored, rather than
+     * hard-coding a rate inside this callback (ADR 045).
+     */
+    feeEstimator: FeeEstimator;
+}) => Promise<SigningTxData>;
+export interface AggregationServiceRunnerOptions {
+    /** Underlying transport (NostrTransport, MockTransport, etc.). */
+    transport: Transport;
+    /** This service's identity. */
+    did: string;
+    keys: SchnorrKeyPair;
+    /**
+     * Default cohort configuration for the {@link AggregationServiceRunner.run}
+     * convenience path. Optional: omit it when driving the runner with
+     * {@link AggregationServiceRunner.advertiseCohort}, which takes a per-cohort
+     * config and can be called many times on one runner.
+     */
+    config?: CohortConfig;
+    /**
+     * Decide whether to accept a participant's opt-in.
+     * Default: auto-accept all opt-ins.
+     */
+    onOptInReceived?: OnOptInReceived;
+    /**
+     * Decide whether to finalize keygen now or wait for more participants.
+     * Called after each accepted opt-in once minParticipants is reached.
+     * Default: finalize as soon as minParticipants is reached.
+     */
+    onReadyToFinalize?: OnReadyToFinalize;
+    /**
+     * Provide the Bitcoin transaction data to sign.
+     * REQUIRED - no sensible default.
+     */
+    onProvideTxData: OnProvideTxData;
+    /**
+     * Fee estimator passed to {@link OnProvideTxData} so the beacon transaction the
+     * callback builds is sized at a chosen rate. Inject a dynamic estimator (a mempool
+     * API or Bitcoin Core `estimatesmartfee`) here as the single standard point for
+     * fee-rate selection, instead of hard-coding a rate inside the callback (ADR 045).
+     * Defaults to a static 5 sat/vB estimator.
+     */
+    feeEstimator?: FeeEstimator;
+    /**
+     * Maximum canonicalized byte-length of a signed update body. Submissions
+     * above this cap are rejected and surfaced via the `message-rejected` event.
+     * Defaults to {@link DEFAULT_MAX_UPDATE_SIZE_BYTES} (256 KiB).
+     */
+    maxUpdateSizeBytes?: number;
+    /**
+     * Overall wall-clock budget for each cohort, from advertise to
+     * signing-complete. On expiry the cohort is dropped, `cohort-failed` is
+     * emitted, and that cohort's completion rejects with a timeout error. Other
+     * cohorts on the same runner are unaffected. Leave undefined to disable.
+     */
+    cohortTtlMs?: number;
+    /**
+     * Maximum time allowed between phase transitions for a cohort. Protects
+     * against stalled cohorts (e.g. a participant vanishing mid-protocol). Reset
+     * automatically on every observed phase change. Applied per cohort. Leave
+     * undefined to disable.
+     */
+    phaseTimeoutMs?: number;
+    /**
+     * Re-publish COHORT_ADVERT on this interval until a cohort's keygen is
+     * finalized. Works around relays that don't backfill historical events to
+     * late subscribers - a republish gives late joiners a window to discover the
+     * advert without protocol changes. The first publish is immediate;
+     * subsequent publishes fire every `advertRepeatIntervalMs` until that
+     * cohort's keygen completes, fails, or is stopped. Defaults to
+     * {@link DEFAULT_ADVERT_REPEAT_INTERVAL_MS} (60 s). Set to 0 to publish
+     * once and never retry.
+     */
+    advertRepeatIntervalMs?: number;
+    /**
+     * When a cohort stalls (phase timeout) while the optimistic n-of-n signing
+     * round is in flight, fall back to the k-of-n script path instead of failing
+     * the cohort (graceful liveness, ADR 042). Off by default: enabling it trades a
+     * cheaper/private key-path spend for a larger script-path spend whenever the
+     * optimistic round does not complete in time. A stall outside the signing
+     * phases still fails the cohort. Operators can also drive the fallback
+     * explicitly via {@link AggregationServiceRunner.triggerFallback}.
+     */
+    autoFallbackOnStall?: boolean;
+}
+/** Default cadence for re-publishing COHORT_ADVERT until keygen completes: 60 seconds. */
+export declare const DEFAULT_ADVERT_REPEAT_INTERVAL_MS = 60000;
+/**
+ * High-level facade for running an Aggregation Service over a Transport.
+ *
+ * Wires the {@link AggregationService} state machine to a {@link Transport},
+ * encapsulating message handler registration, outgoing message dispatch,
+ * and decision callback orchestration.
+ *
+ * A single runner is a long-lived multiplexer: it advertises and drives many
+ * cohorts concurrently over one transport. Each advertised cohort owns an
+ * independent completion promise and fails in isolation - a stalled or failed
+ * cohort never settles its siblings (see ADR 040). Use
+ * {@link AggregationServiceRunner.advertiseCohort} for the multi-cohort path;
+ * {@link AggregationServiceRunner.run} is a thin single-cohort convenience over
+ * it.
+ *
+ * @example
+ * ```typescript
+ * const transport = new NostrTransport({ relays: [RELAY] });
+ * transport.registerActor(serviceDid, serviceKeys);
+ *
+ * const runner = new AggregationServiceRunner({
+ *   transport,
+ *   did: serviceDid,
+ *   keys: serviceKeys,
+ *   onProvideTxData: async ({ beaconAddress, signalBytes, feeEstimator }) => {
+ *     // Forward feeEstimator so a dynamic rate injected at the runner is honored.
+ *     return await buildBeaconTransaction(beaconAddress, signalBytes, bitcoin, feeEstimator);
+ *   },
+ * });
+ *
+ * runner.on('keygen-complete', ({ cohortId, beaconAddress }) => console.log(beaconAddress));
+ * runner.on('signing-complete', ({ cohortId, signature }) => console.log('done', cohortId));
+ *
+ * // Multi-cohort: advertise several cohorts; each completion resolves independently.
+ * const a = runner.advertiseCohort({ minParticipants: 2, network: 'mutinynet', beaconType: 'CASBeacon' });
+ * const b = runner.advertiseCohort({ minParticipants: 3, network: 'mutinynet', beaconType: 'SMTBeacon' });
+ * const [ra, rb] = await Promise.all([a.completion, b.completion]);
+ *
+ * // Single-cohort convenience (requires `config` in the options):
+ * // const result = await runner.run();
+ * ```
+ *
+ * For full manual control, drop down to the underlying state machine via
+ * `runner.session`. The state machine has no transport coupling and exposes
+ * every protocol decision as an explicit method.
+ *
+ * @class AggregationServiceRunner
+ */
+export declare class AggregationServiceRunner extends TypedEventEmitter<AggregationServiceEvents> {
+    #private;
+    /** Direct access to the underlying state machine for advanced use. */
+    readonly session: AggregationService;
+    constructor(options: AggregationServiceRunnerOptions);
+    /**
+     * Advertise a new cohort and begin driving it to completion. Callable many
+     * times on one runner; each cohort runs concurrently and independently.
+     *
+     * @param config Per-cohort conditions + network (see {@link CohortConfig}).
+     * @returns The new cohort's id and a `completion` promise that resolves with
+     *   that cohort's {@link AggregationResult} (or rejects if it fails/stalls).
+     * @throws If the runner has been stopped, or the config is invalid
+     *   (fail-fast via `createCohort`).
+     */
+    advertiseCohort(config: CohortConfig): {
+        cohortId: string;
+        completion: Promise<AggregationResult>;
+    };
+    /**
+     * Run a single cohort to completion using the `config` supplied in the
+     * runner options. Thin convenience over {@link advertiseCohort} for the
+     * single-cohort case (and the path {@link AggregationRunner.solo} rides).
+     *
+     * @returns {Promise<AggregationResult>} The final result with signature and signed tx.
+     */
+    run(): Promise<AggregationResult>;
+    /**
+     * Wait for every currently-outstanding cohort to settle and return the
+     * successful results. Dynamic drain: cohorts advertised while this is pending
+     * are included, and it resolves only once no cohorts remain. Failed cohorts
+     * are surfaced via `error` / `cohort-failed` events and their rejected
+     * `completion` promises; they are omitted from the returned array (this
+     * method does not throw). Bound long-running cohorts with `cohortTtlMs` /
+     * `phaseTimeoutMs` or this may never resolve.
+     *
+     * @returns {Promise<AggregationResult[]>} Results of the cohorts that completed.
+     */
+    runAll(): Promise<AggregationResult[]>;
+    /**
+     * Abandon the optimistic n-of-n key path for a cohort and collect k-of-n
+     * fallback (script-path) signatures instead (ADR 042). Idempotent and safe
+     * against the optimistic completion: it commits the cohort to the fallback
+     * path synchronously (the `committedPath` latch) before sending anything, so a
+     * late optimistic signature can no longer complete-and-broadcast a competing
+     * spend of the same UTXO. No-op if the cohort is unknown, already settled, or
+     * already committed to a path.
+     *
+     * Wired automatically to the phase-stall timer when `autoFallbackOnStall` is
+     * set; otherwise call it from an operator decision (a UI "fall back now"
+     * action). Throws only if the underlying state machine rejects the transition
+     * (e.g. signing has not started).
+     */
+    triggerFallback(cohortId: string): Promise<void>;
+    /**
+     * Stop a single cohort early without affecting the rest of the runner. Drops
+     * the cohort's state machine state; its `completion` promise rejects with a
+     * stopped error.
+     */
+    stopCohort(cohortId: string): void;
+    /**
+     * Stop the whole runner. Fails every outstanding cohort, then detaches the
+     * shared transport handlers so a restart or a new runner doesn't inherit
+     * stale dispatch. Safe to call repeatedly.
+     */
+    stop(): void;
+}
+//# sourceMappingURL=service-runner.d.ts.map

package/dist/types/runner/service-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-runner.d.ts","sourceRoot":"","sources":["../../../src/runner/service-runner.ts"],"names":[],"mappings":"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"}

package/dist/types/runner/typed-emitter.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Tiny strongly-typed event emitter.
+ *
+ * Browser-compatible (no Node.js `events` module). Uses a generic event map
+ * to give compile-time safety on event names and listener signatures.
+ *
+ * @example
+ * type MyEvents = {
+ *   'connected': [{ host: string }];
+ *   'data': [Uint8Array];
+ *   'error': [Error];
+ * };
+ *
+ * class MyClient extends TypedEventEmitter<MyEvents> {
+ *   doStuff() {
+ *     this.emit('connected', { host: 'example.com' });  // ✓ typed
+ *     this.emit('data', new Uint8Array([1, 2]));        // ✓ typed
+ *   }
+ * }
+ *
+ * const client = new MyClient();
+ * client.on('connected', ({ host }) => console.log(host));  // ✓ typed
+ */
+export type EventMap = Record<string, ReadonlyArray<unknown>>;
+export type Listener<Args extends ReadonlyArray<unknown>> = (...args: Args) => void;
+export declare class TypedEventEmitter<Events extends EventMap> {
+    #private;
+    /** Subscribe to an event. */
+    on<K extends keyof Events>(event: K, listener: Listener<Events[K]>): this;
+    /** Subscribe to an event, automatically unsubscribing after the first call. */
+    once<K extends keyof Events>(event: K, listener: Listener<Events[K]>): this;
+    /** Unsubscribe a specific listener. */
+    off<K extends keyof Events>(event: K, listener: Listener<Events[K]>): this;
+    /** Emit an event to all subscribed listeners. */
+    emit<K extends keyof Events>(event: K, ...args: Events[K]): boolean;
+    /** Remove all listeners (optionally for a specific event). */
+    removeAllListeners<K extends keyof Events>(event?: K): this;
+    /** Number of listeners for an event. */
+    listenerCount<K extends keyof Events>(event: K): number;
+}
+//# sourceMappingURL=typed-emitter.d.ts.map

package/dist/types/runner/typed-emitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed-emitter.d.ts","sourceRoot":"","sources":["../../../src/runner/typed-emitter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC;AAE9D,MAAM,MAAM,QAAQ,CAAC,IAAI,SAAS,aAAa,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,IAAI,CAAC;AAEpF,qBAAa,iBAAiB,CAAC,MAAM,SAAS,QAAQ;;IAGpD,6BAA6B;IAC7B,EAAE,CAAC,CAAC,SAAS,MAAM,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;IAUzE,+EAA+E;IAC/E,IAAI,CAAC,CAAC,SAAS,MAAM,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;IAQ3E,uCAAuC;IACvC,GAAG,CAAC,CAAC,SAAS,MAAM,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;IAK1E,iDAAiD;IACjD,IAAI,CAAC,CAAC,SAAS,MAAM,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,OAAO;IAcnE,8DAA8D;IAC9D,kBAAkB,CAAC,CAAC,SAAS,MAAM,MAAM,EAAE,KAAK,CAAC,EAAE,CAAC,GAAG,IAAI;IAS3D,wCAAwC;IACxC,aAAa,CAAC,CAAC,SAAS,MAAM,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,MAAM;CAGxD"}

package/dist/types/service.d.ts

@@ -0,0 +1,177 @@
+import type { SignedBTCR2Update } from '@did-btcr2/cryptosuite';
+import type { CompressedSecp256k1PublicKey } from '@did-btcr2/keypair';
+import type { Transaction } from '@scure/btc-signer';
+import { AggregationCohort } from './cohort.js';
+import { type CohortConditions } from './conditions.js';
+import type { BaseMessage } from './messages/base.js';
+import type { ServiceCohortPhaseType } from './phases.js';
+/**
+ * Cohort configuration set by the service operator: the advertised cohort
+ * {@link CohortConditions} plus the Bitcoin network. `beaconType` and
+ * `minParticipants` are required; the other conditions are optional (absent =
+ * unconstrained). See ADR 039.
+ */
+export interface CohortConfig extends CohortConditions {
+    network: string;
+}
+/** Pending opt-in awaiting service operator approval. */
+export interface PendingOptIn {
+    cohortId: string;
+    participantDid: string;
+    participantPk: Uint8Array;
+    communicationPk: Uint8Array;
+}
+/** Validation tracking progress. */
+export interface ValidationProgress {
+    approved: ReadonlySet<string>;
+    rejected: ReadonlySet<string>;
+    pending: ReadonlySet<string>;
+    total: number;
+}
+/** Final aggregation result for a cohort. */
+export interface AggregationResult {
+    cohortId: string;
+    /**
+     * The 64-byte aggregated MuSig2 signature for the optimistic key path. Empty
+     * for a `script-path` result: the k-of-n fallback embeds k separate signatures
+     * directly in the witness of {@link signedTx}, with no single aggregate sig.
+     */
+    signature: Uint8Array;
+    signedTx: Transaction;
+    /**
+     * Which Taproot spend path produced {@link signedTx}: `key-path` is the
+     * optimistic n-of-n MuSig2 spend, `script-path` is the k-of-n fallback (ADR
+     * 042). Absent is treated as `key-path` for backward compatibility.
+     */
+    path?: 'key-path' | 'script-path';
+}
+/** Transaction data needed to start a signing session. */
+export interface SigningTxData {
+    tx: Transaction;
+    prevOutScripts: Uint8Array[];
+    prevOutValues: bigint[];
+}
+/** Reason an incoming message was silently dropped by the state machine. */
+export type RejectionReason = 'WRONG_VERSION' | 'UPDATE_TOO_LARGE' | 'UPDATE_VERIFICATION_FAILED' | 'UPDATE_MALFORMED';
+/** Record of a silently-dropped inbound message. Drained by the runner to emit events. */
+export interface Rejection {
+    /** DID of the sender whose message was rejected. */
+    from: string;
+    /** Machine-readable code. */
+    code: RejectionReason;
+    /** Human-readable reason. */
+    reason: string;
+}
+/** Default maximum canonicalized byte-length of a submitted BTCR2 update. */
+export declare const DEFAULT_MAX_UPDATE_SIZE_BYTES: number;
+export interface AggregationServiceParams {
+    did: string;
+    /**
+     * The service's compressed communication public key (placed in cohort adverts).
+     * The coordinator never signs - it aggregates public nonces and partial
+     * signatures - so it is given a public key only, never a secret-bearing
+     * keypair (see ADR 038).
+     */
+    publicKey: CompressedSecp256k1PublicKey;
+    /**
+     * Maximum canonicalized byte-length of a signed update body accepted by the
+     * service. Submissions above this cap are silently dropped and surfaced as
+     * `UPDATE_TOO_LARGE` rejections. Defaults to {@link DEFAULT_MAX_UPDATE_SIZE_BYTES}.
+     */
+    maxUpdateSizeBytes?: number;
+}
+/**
+ * Sans-I/O state machine for an Aggregation Service.
+ *
+ * Manages multiple cohorts simultaneously. The service operator drives the
+ * state machine via `receive()` (for incoming messages) and explicit action
+ * methods (advertising, accepting opt-ins, finalizing keygen, building
+ * aggregated data, starting signing). All outgoing messages are returned for
+ * the caller to send via whatever transport.
+ *
+ * @class AggregationService
+ */
+export declare class AggregationService {
+    #private;
+    readonly did: string;
+    readonly publicKey: CompressedSecp256k1PublicKey;
+    readonly maxUpdateSizeBytes: number;
+    constructor({ did, publicKey, maxUpdateSizeBytes }: AggregationServiceParams);
+    receive(message: BaseMessage): void;
+    /**
+     * Drain the rejection log for a cohort. Used by runners to surface silent
+     * drops (bad proof, oversized update, wrong version, etc.) as structured
+     * events without breaking the sans-I/O state machine contract.
+     */
+    drainRejections(cohortId: string): Array<Rejection>;
+    /**
+     * Create a new cohort with the given config. Returns the cohort ID.
+     * Cohort starts in `Created` phase - call `advertise()` to broadcast.
+     */
+    createCohort(config: CohortConfig): string;
+    /**
+     * Advertise a cohort to discover participants.
+     * Returns the advert message to broadcast.
+     */
+    advertise(cohortId: string): BaseMessage[];
+    /** Pending opt-ins awaiting operator approval. */
+    pendingOptIns(cohortId: string): ReadonlyMap<string, PendingOptIn>;
+    /**
+     * Service operator accepts a participant's opt-in.
+     * Returns the accept message to send.
+     */
+    acceptParticipant(cohortId: string, participantDid: string): BaseMessage[];
+    /**
+     * Finalize cohort keygen: compute MuSig2 Taproot beacon address and send
+     * COHORT_READY messages to all accepted participants.
+     */
+    finalizeKeygen(cohortId: string): BaseMessage[];
+    /** Updates collected so far for a cohort. */
+    collectedUpdates(cohortId: string): ReadonlyMap<string, SignedBTCR2Update>;
+    /**
+     * Build the aggregated data structure (CAS Announcement or SMT tree) and
+     * return distribute messages to send to all participants for validation.
+     */
+    buildAndDistribute(cohortId: string): BaseMessage[];
+    validationProgress(cohortId: string): ValidationProgress;
+    /**
+     * Start a signing session by creating auth requests for all participants.
+     * The caller provides the transaction data - typically built via
+     * `buildBeaconTransaction()` against a Bitcoin connection.
+     */
+    startSigning(cohortId: string, txData: SigningTxData): BaseMessage[];
+    /**
+     * Generate the aggregated nonce and return messages to send to participants.
+     * Call after `validationProgress(cohortId).approved.size === total`.
+     */
+    sendAggregatedNonce(cohortId: string): BaseMessage[];
+    /**
+     * Abandon the optimistic n-of-n key path and ask members to authorize the
+     * k-of-n fallback (script-path) spend of the SAME beacon transaction (graceful
+     * liveness, ADR 042). Reuses the in-flight signing session's transaction and
+     * spent output, so the announcement and its outputs are unchanged: only the
+     * witness path differs. Returns one FALLBACK_AUTHORIZATION_REQUEST per
+     * participant.
+     *
+     * Callable once optimistic signing has started (the session and its tx exist)
+     * and before it completes. A cohort can take exactly one of the two paths: the
+     * caller (runner) must commit to fallback and stop driving the optimistic path.
+     */
+    startFallbackSigning(cohortId: string): BaseMessage[];
+    getResult(cohortId: string): AggregationResult | undefined;
+    getCohortPhase(cohortId: string): ServiceCohortPhaseType | undefined;
+    getCohort(cohortId: string): AggregationCohort | undefined;
+    /**
+     * Get the signing session ID for a cohort, if a signing session has been started.
+     * @param {string} cohortId - The cohort ID.
+     * @returns {string | undefined} The session ID, or undefined if no session is active.
+     */
+    getSigningSessionId(cohortId: string): string | undefined;
+    get cohorts(): ReadonlyArray<AggregationCohort>;
+    /**
+     * Remove a cohort from the state map. Used by runners to GC state on cohort
+     * completion, failure, or expiry. No-op if the cohort doesn't exist.
+     */
+    removeCohort(cohortId: string): void;
+}
+//# sourceMappingURL=service.d.ts.map

package/dist/types/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/service.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,oBAAoB,CAAC;AAGvE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAA4B,KAAK,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAKlF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAoBtD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAI1D;;;;;GAKG;AACH,MAAM,WAAW,YAAa,SAAQ,gBAAgB;IACpD,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,yDAAyD;AACzD,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,UAAU,CAAC;IAC1B,eAAe,EAAE,UAAU,CAAC;CAC7B;AAED,oCAAoC;AACpC,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC9B,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC9B,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC7B,KAAK,EAAE,MAAM,CAAC;CACf;AAED,6CAA6C;AAC7C,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,SAAS,EAAE,UAAU,CAAC;IACtB,QAAQ,EAAE,WAAW,CAAC;IACtB;;;;OAIG;IACH,IAAI,CAAC,EAAE,UAAU,GAAG,aAAa,CAAC;CACnC;AAED,0DAA0D;AAC1D,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,WAAW,CAAC;IAChB,cAAc,EAAE,UAAU,EAAE,CAAC;IAC7B,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB;AAED,4EAA4E;AAC5E,MAAM,MAAM,eAAe,GACvB,eAAe,GACf,kBAAkB,GAClB,4BAA4B,GAC5B,kBAAkB,CAAC;AAEvB,0FAA0F;AAC1F,MAAM,WAAW,SAAS;IACxB,oDAAoD;IACpD,IAAI,EAAE,MAAM,CAAC;IACb,6BAA6B;IAC7B,IAAI,EAAE,eAAe,CAAC;IACtB,6BAA6B;IAC7B,MAAM,EAAE,MAAM,CAAC;CAChB;AAqBD,6EAA6E;AAC7E,eAAO,MAAM,6BAA6B,QAAa,CAAC;AAExD,MAAM,WAAW,wBAAwB;IACvC,GAAG,EAAE,MAAM,CAAC;IACZ;;;;;OAKG;IACH,SAAS,EAAE,4BAA4B,CAAC;IACxC;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;;;;;GAUG;AACH,qBAAa,kBAAkB;;IAC7B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,SAAS,EAAE,4BAA4B,CAAC;IACjD,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;gBAKxB,EAAE,GAAG,EAAE,SAAS,EAAE,kBAAkB,EAAE,EAAE,wBAAwB;IAO5E,OAAO,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI;IA+CnC;;;;OAIG;IACH,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,KAAK,CAAC,SAAS,CAAC;IASnD;;;OAGG;IACH,YAAY,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM;IA8B1C;;;OAGG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,EAAE;IA2B1C,kDAAkD;IAClD,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,CAAC,MAAM,EAAE,YAAY,CAAC;IAwClE;;;OAGG;IACH,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,WAAW,EAAE;IAwC1E;;;OAGG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,EAAE;IA4C/C,6CAA6C;IAC7C,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,CAAC,MAAM,EAAE,iBAAiB,CAAC;IAgL1E;;;OAGG;IACH,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,EAAE;IAwCnD,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,kBAAkB;IAwCxD;;;;OAIG;IACH,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,GAAG,WAAW,EAAE;IAgEpE;;;OAGG;IACH,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,EAAE;IA6DpD;;;;;;;;;;;OAWG;IACH,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,EAAE;IAkIrD,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS;IAI1D,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,sBAAsB,GAAG,SAAS;IAIpE,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS;IAI1D;;;;OAIG;IACH,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAIzD,IAAI,OAAO,IAAI,aAAa,CAAC,iBAAiB,CAAC,CAE9C;IAED;;;OAGG;IACH,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;CAGrC"}

package/dist/types/signer.d.ts

@@ -0,0 +1,50 @@
+import type { SchnorrKeyPair } from '@did-btcr2/keypair';
+/**
+ * A signing capability for MuSig2 aggregation.
+ *
+ * MuSig2 (BIP-327) cannot be driven through a generic `sign(message)` primitive:
+ * both nonce generation and partial signing need the raw 32-byte secret scalar
+ * (see ADR 038). Rather than hand that scalar around as a long-lived field, the
+ * participant holds an `AggregationSigner` and materializes the secret only for
+ * the duration of a single operation via {@link AggregationSigner.withSecret},
+ * which is responsible for wiping its working copy afterward.
+ *
+ * This is the seam a non-extractable / KMS-backed signer (or a session-scoped
+ * signer that destroys its key after the cohort completes) plugs into without
+ * changing the participant state machine.
+ *
+ * @interface AggregationSigner
+ */
+export interface AggregationSigner {
+    /** Compressed 33-byte public key. Not secret; always available. */
+    readonly publicKey: Uint8Array;
+    /**
+     * Materialize the raw 32-byte secret key, pass it to `fn`, and zeroize the
+     * working copy before returning - even if `fn` throws. The secret must not
+     * escape the callback.
+     *
+     * @typeParam T The callback's return type (e.g. a nonce contribution or partial signature).
+     * @param {(secretKey: Uint8Array) => T} fn Operation that needs the raw secret for its duration.
+     * @returns {T} Whatever `fn` returns.
+     */
+    withSecret<T>(fn: (secretKey: Uint8Array) => T): T;
+}
+/**
+ * {@link AggregationSigner} backed by an in-memory {@link SchnorrKeyPair}.
+ *
+ * The keypair is held privately (never exposed as a public field) and each
+ * `withSecret` call pulls a fresh copy of the secret bytes, hands it to the
+ * callback, and wipes that copy on return. The underlying keypair is the
+ * caller's to own and destroy; this signer never mutates or destroys it.
+ *
+ * @class KeyPairAggregationSigner
+ * @implements {AggregationSigner}
+ */
+export declare class KeyPairAggregationSigner implements AggregationSigner {
+    #private;
+    readonly publicKey: Uint8Array;
+    /** @param {SchnorrKeyPair} keys The keypair whose secret backs this signer. */
+    constructor(keys: SchnorrKeyPair);
+    withSecret<T>(fn: (secretKey: Uint8Array) => T): T;
+}
+//# sourceMappingURL=signer.d.ts.map

package/dist/types/signer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signer.d.ts","sourceRoot":"","sources":["../../src/signer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAGzD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,iBAAiB;IAChC,mEAAmE;IACnE,QAAQ,CAAC,SAAS,EAAE,UAAU,CAAC;IAE/B;;;;;;;;OAQG;IACH,UAAU,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,SAAS,EAAE,UAAU,KAAK,CAAC,GAAG,CAAC,CAAC;CACpD;AAED;;;;;;;;;;GAUG;AACH,qBAAa,wBAAyB,YAAW,iBAAiB;;IAChE,QAAQ,CAAC,SAAS,EAAE,UAAU,CAAC;IAG/B,+EAA+E;gBACnE,IAAI,EAAE,cAAc;IAKhC,UAAU,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,SAAS,EAAE,UAAU,KAAK,CAAC,GAAG,CAAC;CAUnD"}

package/dist/types/signing-session.d.ts

@@ -0,0 +1,81 @@
+import type { Transaction } from '@scure/btc-signer';
+import type { AggregationCohort } from './cohort.js';
+import type { SigningSessionPhaseType } from './phases.js';
+type PublicKeyHex = string;
+type Nonce = Uint8Array;
+export interface SigningSessionParams {
+    id?: string;
+    cohort: AggregationCohort;
+    pendingTx: Transaction;
+    prevOutScripts?: Uint8Array[];
+    prevOutValues?: bigint[];
+}
+/**
+ * MuSig2 signing session for a beacon transaction.
+ *
+ * Implements the BIP-327 signing protocol over a Taproot key-path-only
+ * transaction. The session is used by both AggregationService (collecting
+ * nonces and partial signatures, computing the final signature) and
+ * AggregationParticipant (generating their nonce and partial signature).
+ *
+ * @class BeaconSigningSession
+ */
+export declare class BeaconSigningSession {
+    #private;
+    /** Unique identifier for this signing session. */
+    id: string;
+    /** The cohort this session signs for. */
+    cohort: AggregationCohort;
+    /** The Bitcoin transaction being signed. */
+    pendingTx: Transaction;
+    /** Previous output scripts for Taproot sighash computation (BIP-341). */
+    prevOutScripts: Uint8Array[];
+    /** Previous output values for Taproot sighash computation. */
+    prevOutValues: bigint[];
+    /** Map of participant publicKey-hex to public nonce contribution. */
+    nonceContributions: Map<PublicKeyHex, Nonce>;
+    /** Aggregated MuSig2 nonce (66 bytes). */
+    aggregatedNonce?: Uint8Array;
+    /** Map of participant DID to partial signature. */
+    partialSignatures: Map<string, Uint8Array>;
+    /** Final 64-byte Schnorr signature. */
+    signature?: Uint8Array;
+    /** Current signing session phase. */
+    phase: SigningSessionPhaseType;
+    constructor({ id, cohort, pendingTx, prevOutScripts, prevOutValues }: SigningSessionParams);
+    /**
+     * Computes the Taproot sighash (BIP-341) for the first input.
+     */
+    get sigHash(): Uint8Array;
+    addNonceContribution(participantDid: string, nonceContribution: Uint8Array): void;
+    generateAggregatedNonce(): Uint8Array;
+    addPartialSignature(participantDid: string, partialSig: Uint8Array): void;
+    generateFinalSignature(): Uint8Array;
+    /**
+     * Generates a fresh MuSig2 nonce contribution for the participant.
+     * Stores the secret nonce internally for use in `generatePartialSignature()`.
+     */
+    generateNonceContribution(participantPublicKey: Uint8Array, participantSecretKey: Uint8Array): Uint8Array;
+    /**
+     * Generates a partial signature using the participant's secret key + secret nonce.
+     * Requires the aggregated nonce to have been set first (via the service).
+     *
+     * Clears the stored secret nonce after use on every path (success or throw)
+     * via {@link clearSecrets}. JS cannot truly erase memory (GC may relocate
+     * buffers), but overwriting the bytes shortens the exposure window and
+     * prevents accidental reuse or serialization of a spent nonce - reuse of a
+     * MuSig2 nonce leaks the secret key.
+     */
+    generatePartialSignature(participantSecretKey: Uint8Array): Uint8Array;
+    /**
+     * Zeroize any retained secret nonce. Safe to call repeatedly and on any path
+     * (completion, failure, or teardown of an abandoned session). Callers that
+     * drop a session before it reaches a partial signature should invoke this so
+     * the secret nonce does not linger on the live object.
+     */
+    clearSecrets(): void;
+    isComplete(): boolean;
+    isFailed(): boolean;
+}
+export {};
+//# sourceMappingURL=signing-session.d.ts.map

package/dist/types/signing-session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signing-session.d.ts","sourceRoot":"","sources":["../../src/signing-session.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGrD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAG3D,KAAK,YAAY,GAAG,MAAM,CAAC;AAC3B,KAAK,KAAK,GAAG,UAAU,CAAC;AAExB,MAAM,WAAW,oBAAoB;IACnC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,iBAAiB,CAAC;IAC1B,SAAS,EAAE,WAAW,CAAC;IACvB,cAAc,CAAC,EAAE,UAAU,EAAE,CAAC;IAC9B,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;CAC1B;AAED;;;;;;;;;GASG;AACH,qBAAa,oBAAoB;;IAC/B,kDAAkD;IAC3C,EAAE,EAAE,MAAM,CAAC;IAElB,yCAAyC;IAClC,MAAM,EAAE,iBAAiB,CAAC;IAEjC,4CAA4C;IACrC,SAAS,EAAE,WAAW,CAAC;IAE9B,yEAAyE;IAClE,cAAc,EAAE,UAAU,EAAE,CAAC;IAEpC,8DAA8D;IACvD,aAAa,EAAE,MAAM,EAAE,CAAC;IAE/B,qEAAqE;IAC9D,kBAAkB,EAAE,GAAG,CAAC,YAAY,EAAE,KAAK,CAAC,CAAa;IAEhE,0CAA0C;IACnC,eAAe,CAAC,EAAE,UAAU,CAAC;IAEpC,mDAAmD;IAC5C,iBAAiB,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAa;IAE9D,uCAAuC;IAChC,SAAS,CAAC,EAAE,UAAU,CAAC;IAE9B,qCAAqC;IAC9B,KAAK,EAAE,uBAAuB,CAAC;gBAW1B,EAAE,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,cAAc,EAAE,aAAa,EAAE,EAAE,oBAAoB;IAS1F;;OAEG;IACH,IAAI,OAAO,IAAI,UAAU,CAaxB;IAEM,oBAAoB,CAAC,cAAc,EAAE,MAAM,EAAE,iBAAiB,EAAE,UAAU,GAAG,IAAI;IAgCjF,uBAAuB,IAAI,UAAU;IAYrC,mBAAmB,CAAC,cAAc,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,GAAG,IAAI;IA0BzE,sBAAsB,IAAI,UAAU;IA4D3C;;;OAGG;IACI,yBAAyB,CAAC,oBAAoB,EAAE,UAAU,EAAE,oBAAoB,EAAE,UAAU,GAAG,UAAU;IAOhH;;;;;;;;;OASG;IACI,wBAAwB,CAAC,oBAAoB,EAAE,UAAU,GAAG,UAAU;IAqB7E;;;;;OAKG;IACI,YAAY,IAAI,IAAI;IAOpB,UAAU,IAAI,OAAO;IAIrB,QAAQ,IAAI,OAAO;CAG3B"}

package/dist/types/transport/didcomm.d.ts

@@ -0,0 +1,23 @@
+import type { SchnorrKeyPair } from '@did-btcr2/keypair';
+import type { BaseMessage } from '../messages/base.js';
+import type { MessageHandler, Transport } from './transport.js';
+/**
+ * DIDComm Transport (stub).
+ *
+ * @class DidCommTransport
+ * @implements {Transport}
+ */
+export declare class DidCommTransport implements Transport {
+    name: string;
+    start(): void;
+    registerActor(_did: string, _keys: SchnorrKeyPair): void;
+    getActorPk(_did: string): Uint8Array | undefined;
+    registerPeer(_did: string, _communicationPk: Uint8Array): void;
+    getPeerPk(_did: string): Uint8Array | undefined;
+    registerMessageHandler(_actorDid: string, _messageType: string, _handler: MessageHandler): void;
+    unregisterMessageHandler(_actorDid: string, _messageType: string): void;
+    unregisterActor(_did: string): void;
+    sendMessage(_message: BaseMessage, _sender: string, _recipient?: string): Promise<void>;
+    publishRepeating(_message: BaseMessage, _sender: string, _intervalMs: number, _recipient?: string): () => void;
+}
+//# sourceMappingURL=didcomm.d.ts.map

package/dist/types/transport/didcomm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"didcomm.d.ts","sourceRoot":"","sources":["../../../src/transport/didcomm.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,KAAK,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhE;;;;;GAKG;AACH,qBAAa,gBAAiB,YAAW,SAAS;IACzC,IAAI,EAAE,MAAM,CAAa;IAEzB,KAAK,IAAI,IAAI;IAIb,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,cAAc,GAAG,IAAI;IAIxD,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS;IAIhD,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,gBAAgB,EAAE,UAAU,GAAG,IAAI;IAI9D,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS;IAI/C,sBAAsB,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,GAAG,IAAI;IAI/F,wBAAwB,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI;IAIvE,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAI7B,WAAW,CAAC,QAAQ,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAI7F,gBAAgB,CACrB,QAAQ,EAAE,WAAW,EACrB,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EACnB,UAAU,CAAC,EAAE,MAAM,GAClB,MAAM,IAAI;CAGd"}

package/dist/types/transport/error.d.ts

@@ -0,0 +1,8 @@
+import { MethodError } from '@did-btcr2/common';
+export declare class TransportError extends MethodError {
+    constructor(message: string, type?: string, data?: Record<string, any>);
+}
+export declare class TransportAdapterError extends MethodError {
+    constructor(message: string, type?: string, data?: Record<string, any>);
+}
+//# sourceMappingURL=error.d.ts.map

package/dist/types/transport/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../../src/transport/error.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,qBAAa,cAAe,SAAQ,WAAW;gBACjC,OAAO,EAAE,MAAM,EAAE,IAAI,GAAE,MAAyB,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;CAGzF;AAED,qBAAa,qBAAsB,SAAQ,WAAW;gBACxC,OAAO,EAAE,MAAM,EAAE,IAAI,GAAE,MAAgC,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;CAGhG"}