@did-btcr2/aggregation 0.1.0 → 0.3.0

package/dist/cjs/participant/index.js

@@ -0,0 +1,2425 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/participant/index.ts
+var participant_exports = {};
+__export(participant_exports, {
+  AggregationParticipant: () => AggregationParticipant,
+  AggregationParticipantRunner: () => AggregationParticipantRunner,
+  HttpClientTransport: () => HttpClientTransport,
+  defaultReconnectBackoff: () => defaultReconnectBackoff,
+  parseSseStream: () => parseSseStream
+});
+module.exports = __toCommonJS(participant_exports);
+
+// src/participant/participant.ts
+var import_common4 = require("@did-btcr2/common");
+var import_secp256k14 = require("@noble/curves/secp256k1.js");
+var import_utils3 = require("@noble/hashes/utils");
+var import_btc_signer5 = require("@scure/btc-signer");
+
+// src/core/beacon-strategy.ts
+var import_common = require("@did-btcr2/common");
+var import_smt = require("@did-btcr2/smt");
+var CAS_STRATEGY = {
+  type: "CASBeacon",
+  buildAggregatedData(cohort) {
+    cohort.buildCASAnnouncement();
+  },
+  getDistributePayload(cohort) {
+    return { casAnnouncement: cohort.casAnnouncement };
+  },
+  validateParticipantView({ participantDid, included, expectedHash, body }) {
+    const casAnnouncement = body.casAnnouncement;
+    if (!casAnnouncement) return { matches: false };
+    if (!included) {
+      return { matches: !(participantDid in casAnnouncement), casAnnouncement };
+    }
+    return {
+      matches: casAnnouncement[participantDid] === expectedHash,
+      casAnnouncement
+    };
+  }
+};
+var SMT_STRATEGY = {
+  type: "SMTBeacon",
+  buildAggregatedData(cohort) {
+    cohort.buildSMTTree();
+  },
+  getDistributePayload(cohort, participantDid) {
+    const proof = cohort.smtProofs?.get(participantDid);
+    return { smtProof: proof };
+  },
+  validateParticipantView({ participantDid, included, submittedUpdate, body }) {
+    const smtProof = body.smtProof;
+    const index = (0, import_smt.didToIndex)(participantDid);
+    if (!included) {
+      if (!smtProof?.nonce || smtProof?.updateId) return { matches: false, smtProof };
+      const candidateHash2 = (0, import_smt.blockHash)((0, import_smt.blockHash)((0, import_smt.base64UrlToHash)(smtProof.nonce)));
+      return { matches: (0, import_smt.verifySerializedProof)(smtProof, index, candidateHash2), smtProof };
+    }
+    if (!smtProof?.updateId || !smtProof?.nonce || !submittedUpdate) return { matches: false, smtProof };
+    const canonicalBytes = new TextEncoder().encode((0, import_common.canonicalize)(submittedUpdate));
+    const expectedUpdateId = (0, import_smt.hashToBase64Url)((0, import_smt.blockHash)(canonicalBytes));
+    if (smtProof.updateId !== expectedUpdateId) {
+      return { matches: false, smtProof };
+    }
+    const candidateHash = (0, import_smt.blockHash)((0, import_smt.blockHash)((0, import_smt.base64UrlToHash)(smtProof.nonce)), (0, import_smt.base64UrlToHash)(smtProof.updateId));
+    return {
+      matches: (0, import_smt.verifySerializedProof)(smtProof, index, candidateHash),
+      smtProof
+    };
+  }
+};
+var STRATEGIES = /* @__PURE__ */ new Map([
+  [CAS_STRATEGY.type, CAS_STRATEGY],
+  [SMT_STRATEGY.type, SMT_STRATEGY]
+]);
+function getBeaconStrategy(type) {
+  return STRATEGIES.get(type);
+}
+
+// src/core/cohort.ts
+var import_bitcoin = require("@did-btcr2/bitcoin");
+var import_common3 = require("@did-btcr2/common");
+var import_smt2 = require("@did-btcr2/smt");
+var import_secp256k12 = require("@noble/curves/secp256k1.js");
+var import_utils2 = require("@noble/hashes/utils");
+var import_btc_signer2 = require("@scure/btc-signer");
+var import_musig22 = require("@scure/btc-signer/musig2");
+
+// src/core/errors.ts
+var import_common2 = require("@did-btcr2/common");
+var AggregationParticipantError = class extends import_common2.MethodError {
+  constructor(message, type = "AggregationParticipantError", data) {
+    super(message, type, data);
+  }
+};
+var AggregationCohortError = class extends import_common2.MethodError {
+  constructor(message, type = "AggregationCohortError", data) {
+    super(message, type, data);
+  }
+};
+var SigningSessionError = class extends import_common2.MethodError {
+  constructor(message, type = "SigningSessionError", data) {
+    super(message, type, data);
+  }
+};
+
+// src/core/recovery-policy.ts
+var import_secp256k1 = require("@noble/curves/secp256k1.js");
+var import_utils = require("@noble/hashes/utils");
+var import_btc_signer = require("@scure/btc-signer");
+var import_musig2 = require("@scure/btc-signer/musig2");
+var DEFAULT_FUNDING_MODEL = "operator-funded";
+var MAX_RECOVERY_SEQUENCE = 65535;
+var TAPROOT_LEAF_VERSION = 192;
+function resolveFallbackThreshold(advertised, n) {
+  return advertised ?? Math.max(1, n - 1);
+}
+function assertFallbackParams({ cohortKeys, fallbackThreshold }) {
+  const n = cohortKeys.length;
+  if (n === 0) {
+    throw new AggregationCohortError(
+      "Cannot build fallback leaf: no cohort keys.",
+      "NO_COHORT_KEYS"
+    );
+  }
+  for (const key of cohortKeys) {
+    if (key.length !== 33) {
+      throw new AggregationCohortError(
+        `Cohort key must be a 33-byte compressed public key, got ${key.length} bytes.`,
+        "INVALID_COHORT_KEY",
+        { length: key.length }
+      );
+    }
+  }
+  if (!Number.isInteger(fallbackThreshold) || fallbackThreshold < 1 || fallbackThreshold > n) {
+    throw new AggregationCohortError(
+      `Fallback threshold must be an integer in [1, ${n}] (k-of-n), got ${fallbackThreshold}.`,
+      "INVALID_FALLBACK_THRESHOLD",
+      { fallbackThreshold, n }
+    );
+  }
+}
+function buildFallbackLeaf(params) {
+  assertFallbackParams(params);
+  const xOnlyKeys = (0, import_musig2.sortKeys)(params.cohortKeys).map((k) => k.slice(1));
+  return (0, import_btc_signer.p2tr_ms)(params.fallbackThreshold, xOnlyKeys).script;
+}
+function assertRecoveryParams({ recoveryKey, recoverySequence }) {
+  if (recoveryKey.length !== 32) {
+    throw new AggregationCohortError(
+      `Recovery key must be a 32-byte x-only public key, got ${recoveryKey.length} bytes.`,
+      "INVALID_RECOVERY_KEY"
+    );
+  }
+  if (!Number.isInteger(recoverySequence) || recoverySequence < 1 || recoverySequence > MAX_RECOVERY_SEQUENCE) {
+    throw new AggregationCohortError(
+      `Recovery sequence must be a block-based BIP-68 relative timelock in [1, ${MAX_RECOVERY_SEQUENCE}], got ${recoverySequence}.`,
+      "INVALID_RECOVERY_SEQUENCE"
+    );
+  }
+}
+function buildRecoveryScript(params) {
+  assertRecoveryParams(params);
+  return import_btc_signer.Script.encode([
+    params.recoverySequence,
+    "CHECKSEQUENCEVERIFY",
+    "DROP",
+    params.recoveryKey,
+    "CHECKSIG"
+  ]);
+}
+function buildRecoveryLeaves(fundingModel, params) {
+  switch (fundingModel) {
+    case "operator-funded":
+      return [
+        { script: buildFallbackLeaf(params) },
+        { script: buildRecoveryScript(params) }
+      ];
+    case "participant-funded":
+      throw new AggregationCohortError(
+        "Funding model 'participant-funded' is reserved and not yet implemented.",
+        "UNSUPPORTED_FUNDING_MODEL",
+        { fundingModel }
+      );
+    default:
+      throw new AggregationCohortError(
+        `Unknown funding model: ${fundingModel}.`,
+        "UNKNOWN_FUNDING_MODEL",
+        { fundingModel }
+      );
+  }
+}
+
+// src/core/cohort.ts
+var AggregationCohort = class {
+  /** Unique identifier for the cohort. */
+  id;
+  /** DID of the Aggregation Service managing this cohort. */
+  serviceDid;
+  /** Minimum number of participants required to finalize the cohort. */
+  minParticipants;
+  /** Network on which the cohort operates (mainnet, mutinynet, etc.). */
+  network;
+  /** Type of beacon used in the cohort: 'CASBeacon' or 'SMTBeacon'. */
+  beaconType;
+  /** List of participant DIDs that have been accepted into the cohort. */
+  participants = [];
+  /**
+   * Mapping from participant DID to their compressed secp256k1 public key.
+   * Distinct from {@link cohortKeys} (which is sorted per BIP-327): this lets
+   * callers look up a participant's key without knowing their position in the
+   * sorted array. Populated by the service at `acceptParticipant` time.
+   */
+  participantKeys = /* @__PURE__ */ new Map();
+  /** Sorted list of cohort participants' compressed public keys. */
+  #cohortKeys = [];
+  /**
+   * BIP-341 TapTweak scalar: `taggedHash("TapTweak", internalPubkey || tapMerkleRoot)`.
+   * The beacon output is an internal key (the MuSig2 aggregate) plus a script
+   * tree (the recovery leaves), so the tweak commits to the tree's Merkle root.
+   * The MuSig2 signing session applies this as an x-only tweak; a value that does
+   * not match the root the funded address was derived from silently yields an
+   * invalid key-path signature.
+   */
+  tapTweak = new Uint8Array();
+  /** The n-of-n MuSig2 aggregate internal key, x-only (32 bytes), set by computeBeaconAddress(). */
+  internalKey = new Uint8Array();
+  /** BIP-341 Taproot Merkle root of the recovery script tree, set by computeBeaconAddress(). */
+  tapMerkleRoot = new Uint8Array();
+  /** Operator recovery key, x-only (32 bytes). Used to build the CSV recovery leaf. */
+  recoveryKey;
+  /** Relative-timelock (BIP-68 nSequence) before the recovery leaf is spendable. */
+  recoverySequence;
+  /** Funding model governing the recovery leaves (default 'operator-funded'). */
+  fundingModel;
+  /**
+   * Advertised k of the k-of-n fallback leaf, or undefined to default to n-1 at
+   * address computation. Read the resolved value via {@link effectiveFallbackThreshold}.
+   */
+  fallbackThreshold;
+  /** The Taproot beacon address: key path is the MuSig2 aggregate, script path is fallback + recovery. */
+  beaconAddress = "";
+  /** Pending DID updates submitted by participants, keyed by DID. */
+  pendingUpdates = /* @__PURE__ */ new Map();
+  /**
+   * Participant DIDs that explicitly declined to submit an update this round
+   * (cooperative non-inclusion). A decliner is absent from the CAS Announcement
+   * Map and carries a non-inclusion leaf in the SMT, yet still signs. Kept
+   * disjoint from {@link pendingUpdates} so CAS correctness holds by construction.
+   */
+  nonIncluded = /* @__PURE__ */ new Set();
+  /** CAS Beacon Announcement Map (DID to updateHash), set by buildCASAnnouncement(). */
+  casAnnouncement;
+  /** Per-participant SMT proofs, set by buildSMTTree(). */
+  smtProofs;
+  /** Signal bytes (32 bytes) for OP_RETURN: SHA-256 of CAS announcement OR SMT root. */
+  signalBytes;
+  /** Set of participant DIDs that have approved the aggregated data. */
+  validationAcks = /* @__PURE__ */ new Set();
+  /** Set of participant DIDs that have rejected the aggregated data. */
+  validationRejections = /* @__PURE__ */ new Set();
+  constructor({ id, minParticipants, serviceDid, network, beaconType, recoveryKey, recoverySequence, fundingModel, fallbackThreshold }) {
+    this.id = id || crypto.randomUUID();
+    this.minParticipants = minParticipants ?? 2;
+    this.serviceDid = serviceDid || "";
+    this.network = network;
+    this.beaconType = beaconType || "CASBeacon";
+    this.recoveryKey = recoveryKey;
+    this.recoverySequence = recoverySequence;
+    this.fundingModel = fundingModel ?? DEFAULT_FUNDING_MODEL;
+    this.fallbackThreshold = fallbackThreshold;
+  }
+  /** Sorted cohort keys (sorted on assignment per BIP-327). */
+  get cohortKeys() {
+    return this.#cohortKeys;
+  }
+  set cohortKeys(keys) {
+    this.#cohortKeys = (0, import_musig22.sortKeys)(keys);
+  }
+  /**
+   * The resolved k of the k-of-n fallback leaf: the advertised
+   * {@link fallbackThreshold}, or n-1 (floored at 1) when unadvertised, where n is
+   * the current cohort size. This is the value the beacon address commits to and
+   * the spend builders must reproduce. Returns 0 before any cohort keys are set.
+   */
+  get effectiveFallbackThreshold() {
+    if (this.#cohortKeys.length === 0) return 0;
+    return resolveFallbackThreshold(this.fallbackThreshold, this.#cohortKeys.length);
+  }
+  /**
+   * Computes the Taproot beacon address from the cohort keys and recovery params.
+   *
+   * The output's key path is the n-of-n MuSig2 aggregate of the cohort keys; its
+   * script path is the recovery tree (a CSV recovery leaf so a missing signer
+   * cannot permanently lock the UTXO). Sets `internalKey`, `tapMerkleRoot`, and
+   * the `tapTweak` the MuSig2 session must apply for the key-path spend.
+   *
+   * The tweak is derived from the Merkle root the address was built with (read
+   * back from the payment), never recomputed by hand, so the MuSig2 key-path
+   * signature is guaranteed to validate against the funded address.
+   */
+  computeBeaconAddress() {
+    if (this.#cohortKeys.length === 0) {
+      throw new AggregationCohortError(
+        "Cannot compute beacon address: no cohort keys.",
+        "NO_COHORT_KEYS",
+        { cohortId: this.id }
+      );
+    }
+    if (!this.recoveryKey || this.recoveryKey.length === 0 || this.recoverySequence === void 0) {
+      throw new AggregationCohortError(
+        "Cannot compute beacon address: missing recovery key or sequence.",
+        "NO_RECOVERY_PARAMS",
+        { cohortId: this.id }
+      );
+    }
+    const keyAggContext = (0, import_musig22.keyAggregate)(this.#cohortKeys);
+    const aggPubkey = (0, import_musig22.keyAggExport)(keyAggContext);
+    const leaves = buildRecoveryLeaves(this.fundingModel, {
+      recoveryKey: this.recoveryKey,
+      recoverySequence: this.recoverySequence,
+      cohortKeys: this.#cohortKeys,
+      fallbackThreshold: resolveFallbackThreshold(this.fallbackThreshold, this.#cohortKeys.length)
+    });
+    const payment = (0, import_btc_signer2.p2tr)(aggPubkey, leaves, (0, import_bitcoin.getNetwork)(this.network), true);
+    this.internalKey = aggPubkey;
+    this.tapMerkleRoot = payment.tapMerkleRoot;
+    this.tapTweak = import_secp256k12.schnorr.utils.taggedHash("TapTweak", (0, import_utils2.concatBytes)(aggPubkey, payment.tapMerkleRoot));
+    if (!payment.address) {
+      throw new AggregationCohortError(
+        "Failed to compute Taproot address",
+        "BEACON_ADDRESS_ERROR",
+        { cohortId: this.id }
+      );
+    }
+    this.beaconAddress = payment.address;
+    return payment.address;
+  }
+  /**
+   * Validates that the participant's key is in the cohort and the beacon address
+   * matches the locally-computed one. Used by participants to verify cohort ready
+   * messages from the service.
+   */
+  validateMembership(participantPkHex, cohortKeysHex, expectedBeaconAddress) {
+    if (!cohortKeysHex.includes(participantPkHex)) {
+      throw new AggregationCohortError(
+        `Participant key not found in cohort ${this.id}.`,
+        "COHORT_VALIDATION_ERROR",
+        { cohortId: this.id, participantPkHex }
+      );
+    }
+    this.cohortKeys = cohortKeysHex.map((k) => (0, import_utils2.hexToBytes)(k));
+    const computed = this.computeBeaconAddress();
+    if (computed !== expectedBeaconAddress) {
+      throw new AggregationCohortError(
+        `Computed beacon address ${computed} does not match expected ${expectedBeaconAddress}.`,
+        "BEACON_ADDRESS_MISMATCH",
+        { cohortId: this.id, computed, expected: expectedBeaconAddress }
+      );
+    }
+  }
+  /**
+   * Returns the position of a participant's public key in the sorted
+   * {@link cohortKeys} array, or -1 if the participant is not in the cohort.
+   * Required by MuSig2 partial-sig verification which indexes by signer position.
+   */
+  indexOfParticipant(did) {
+    const pk = this.participantKeys.get(did);
+    if (!pk) return -1;
+    return this.#cohortKeys.findIndex(
+      (k) => k.length === pk.length && k.every((b, i) => b === pk[i])
+    );
+  }
+  addUpdate(participantDid, signedUpdate) {
+    if (!this.participants.includes(participantDid)) {
+      throw new AggregationCohortError(
+        `Participant ${participantDid} is not in cohort ${this.id}.`,
+        "UNKNOWN_PARTICIPANT",
+        { cohortId: this.id, participantDid }
+      );
+    }
+    this.pendingUpdates.set(participantDid, signedUpdate);
+  }
+  /**
+   * Record that a participant declined to submit an update this round
+   * (cooperative non-inclusion). The member stays in the cohort and still signs.
+   */
+  addNonInclusion(participantDid) {
+    if (!this.participants.includes(participantDid)) {
+      throw new AggregationCohortError(
+        `Participant ${participantDid} is not in cohort ${this.id}.`,
+        "UNKNOWN_PARTICIPANT",
+        { cohortId: this.id, participantDid }
+      );
+    }
+    if (this.pendingUpdates.has(participantDid)) {
+      throw new AggregationCohortError(
+        `Participant ${participantDid} already submitted an update; cannot also decline.`,
+        "CONFLICTING_RESPONSE",
+        { cohortId: this.id, participantDid }
+      );
+    }
+    this.nonIncluded.add(participantDid);
+  }
+  hasAllUpdates() {
+    return this.pendingUpdates.size === this.participants.length;
+  }
+  /**
+   * True when every participant has responded for this round, either with an
+   * update or with an explicit non-inclusion. This is the aggregation gate when
+   * non-inclusion is in play; it generalizes {@link hasAllUpdates} the same way
+   * {@link hasAllValidationResponses} generalizes a unanimous ack.
+   */
+  hasAllResponses() {
+    return this.pendingUpdates.size + this.nonIncluded.size === this.participants.length;
+  }
+  /**
+   * Builds a CAS Announcement Map from collected updates.
+   * Maps each participant DID to base64url canonical hash of their signed update.
+   * Computes signal bytes as SHA-256 of canonicalized announcement.
+   *
+   * Members who declined (cooperative non-inclusion) are naturally absent from
+   * the map: the body iterates {@link pendingUpdates}, which never holds a
+   * decliner. Absence from the map is exactly the CAS non-inclusion signal.
+   */
+  buildCASAnnouncement() {
+    if (!this.hasAllResponses()) {
+      throw new AggregationCohortError(
+        "Cannot build CAS Announcement: not all participants have responded.",
+        "INCOMPLETE_RESPONSES",
+        { cohortId: this.id, updates: this.pendingUpdates.size, declined: this.nonIncluded.size, total: this.participants.length }
+      );
+    }
+    const announcement = {};
+    for (const [did, signedUpdate] of this.pendingUpdates) {
+      announcement[did] = (0, import_common3.canonicalHash)(signedUpdate);
+    }
+    this.casAnnouncement = announcement;
+    this.signalBytes = (0, import_common3.hash)((0, import_common3.canonicalize)(announcement));
+    return announcement;
+  }
+  /**
+   * Builds an SMT tree with one leaf per participant.
+   *
+   * A member who submitted an update gets an inclusion leaf
+   * (SHA-256(SHA-256(nonce) || SHA-256(update))); a member who declined gets a
+   * non-inclusion leaf (SHA-256(SHA-256(nonce)), the `signedUpdate` entry field
+   * omitted). The cohort mints each member's nonce and returns it inside that
+   * member's serialized proof, so a decliner can self-validate its own
+   * non-inclusion slot and the resolver can recompute the leaf. Stores
+   * per-participant proofs and the SMT root as signalBytes.
+   */
+  buildSMTTree() {
+    if (!this.hasAllResponses()) {
+      throw new AggregationCohortError(
+        "Cannot build SMT tree: not all participants have responded.",
+        "INCOMPLETE_RESPONSES",
+        { cohortId: this.id, updates: this.pendingUpdates.size, declined: this.nonIncluded.size, total: this.participants.length }
+      );
+    }
+    const tree = new import_smt2.BTCR2MerkleTree();
+    const entries = [];
+    const encoder = new TextEncoder();
+    for (const did of this.participants) {
+      const nonce = (0, import_utils2.randomBytes)(32);
+      const signedUpdate = this.pendingUpdates.get(did);
+      if (signedUpdate) {
+        entries.push({ did, nonce, signedUpdate: encoder.encode((0, import_common3.canonicalize)(signedUpdate)) });
+      } else {
+        entries.push({ did, nonce });
+      }
+    }
+    tree.addEntries(entries);
+    tree.finalize();
+    this.signalBytes = tree.rootHash;
+    this.smtProofs = /* @__PURE__ */ new Map();
+    for (const did of this.participants) {
+      this.smtProofs.set(did, tree.proof(did));
+    }
+    return this.smtProofs;
+  }
+  addValidation(participantDid, approved) {
+    if (!this.participants.includes(participantDid)) {
+      throw new AggregationCohortError(
+        `Unknown participant ${participantDid} in cohort ${this.id}.`,
+        "UNKNOWN_PARTICIPANT",
+        { cohortId: this.id, participantDid }
+      );
+    }
+    if (approved) {
+      this.validationAcks.add(participantDid);
+    } else {
+      this.validationRejections.add(participantDid);
+    }
+  }
+  /**
+   * True when every participant has either approved or rejected the aggregated data.
+   */
+  hasAllValidationResponses() {
+    return this.validationAcks.size + this.validationRejections.size === this.participants.length;
+  }
+  /**
+   * True when all participants approved. Note: differs from {@link hasAllValidationResponses},
+   * this returns false if any participant rejected, even if all responses are in.
+   */
+  isFullyValidated() {
+    return this.validationRejections.size === 0 && this.validationAcks.size === this.participants.length;
+  }
+};
+
+// src/core/fallback-spend.ts
+var import_bitcoin2 = require("@did-btcr2/bitcoin");
+var import_secp256k13 = require("@noble/curves/secp256k1.js");
+var import_btc_signer3 = require("@scure/btc-signer");
+var import_musig23 = require("@scure/btc-signer/musig2");
+function fallbackSighash(tx, inputIndex, prevOutScript, prevOutValue, fallbackLeafScript) {
+  return tx.preimageWitnessV1(
+    inputIndex,
+    [prevOutScript],
+    import_btc_signer3.SigHash.DEFAULT,
+    [prevOutValue],
+    void 0,
+    fallbackLeafScript,
+    TAPROOT_LEAF_VERSION
+  );
+}
+
+// src/core/conditions.ts
+var KNOWN_FUNDING_MODELS = ["operator-funded", "participant-funded"];
+
+// src/core/messages/constants.ts
+var AGGREGATION_MESSAGE_PREFIX = "https://btcr2.dev/aggregation";
+var COHORT_ADVERT = `${AGGREGATION_MESSAGE_PREFIX}/keygen/cohort_advert`;
+var COHORT_OPT_IN = `${AGGREGATION_MESSAGE_PREFIX}/keygen/cohort_opt_in`;
+var COHORT_OPT_IN_ACCEPT = `${AGGREGATION_MESSAGE_PREFIX}/keygen/cohort_opt_in_accept`;
+var COHORT_READY = `${AGGREGATION_MESSAGE_PREFIX}/keygen/cohort_ready`;
+var SUBMIT_UPDATE = `${AGGREGATION_MESSAGE_PREFIX}/update/submit_update`;
+var SUBMIT_NONINCLUDED = `${AGGREGATION_MESSAGE_PREFIX}/update/submit_nonincluded`;
+var DISTRIBUTE_AGGREGATED_DATA = `${AGGREGATION_MESSAGE_PREFIX}/update/distribute_aggregated_data`;
+var VALIDATION_ACK = `${AGGREGATION_MESSAGE_PREFIX}/update/validation_ack`;
+var AUTHORIZATION_REQUEST = `${AGGREGATION_MESSAGE_PREFIX}/sign/authorization_request`;
+var NONCE_CONTRIBUTION = `${AGGREGATION_MESSAGE_PREFIX}/sign/nonce_contribution`;
+var AGGREGATED_NONCE = `${AGGREGATION_MESSAGE_PREFIX}/sign/aggregated_nonce`;
+var SIGNATURE_AUTHORIZATION = `${AGGREGATION_MESSAGE_PREFIX}/sign/signature_authorization`;
+var FALLBACK_AUTHORIZATION_REQUEST = `${AGGREGATION_MESSAGE_PREFIX}/sign/fallback_authorization_request`;
+var FALLBACK_SIGNATURE = `${AGGREGATION_MESSAGE_PREFIX}/sign/fallback_signature`;
+
+// src/core/messages/bodies.ts
+var hasStr = (b, k) => !!b && typeof b[k] === "string";
+var hasIntMin = (b, k, min) => {
+  const v = b ? b[k] : void 0;
+  return typeof v === "number" && Number.isInteger(v) && v >= min;
+};
+var optIntMin = (b, k, min) => {
+  const v = b ? b[k] : void 0;
+  return v === void 0 || typeof v === "number" && Number.isInteger(v) && v >= min;
+};
+var intInRange = (b, k, min, max) => {
+  const v = b ? b[k] : void 0;
+  return typeof v === "number" && Number.isInteger(v) && v >= min && v <= max;
+};
+var optStrOneOf = (b, k, allowed) => {
+  const v = b ? b[k] : void 0;
+  return v === void 0 || typeof v === "string" && allowed.includes(v);
+};
+var hasBytes = (b, k) => !!b && b[k] instanceof Uint8Array;
+function isCohortAdvertMessage(m) {
+  return m.type === COHORT_ADVERT && hasStr(m.body, "cohortId") && hasIntMin(m.body, "minParticipants", 1) && optIntMin(m.body, "maxParticipants", 1) && hasStr(m.body, "beaconType") && hasStr(m.body, "network") && hasStr(m.body, "recoveryKey") && intInRange(m.body, "recoverySequence", 1, MAX_RECOVERY_SEQUENCE) && optStrOneOf(m.body, "fundingModel", KNOWN_FUNDING_MODELS) && optIntMin(m.body, "fallbackThreshold", 1) && hasBytes(m.body, "communicationPk");
+}
+
+// src/core/messages/base.ts
+var AGGREGATION_WIRE_VERSION = 1;
+var BaseMessage = class {
+  type;
+  version;
+  to;
+  from;
+  body;
+  constructor({ type, version, to, from, body }) {
+    this.type = type;
+    this.version = version ?? AGGREGATION_WIRE_VERSION;
+    this.to = to;
+    this.from = from;
+    this.body = body;
+  }
+  /**
+   * Converts a BaseMessage to a JSON object.
+   * @returns {Base} The JSON representation of the BaseMessage.
+   */
+  toJSON() {
+    return {
+      type: this.type,
+      version: this.version,
+      to: this.to,
+      from: this.from,
+      body: this.body
+    };
+  }
+};
+
+// src/core/messages/factories.ts
+function createCohortOptInMessage(fields) {
+  const { from, to, ...body } = fields;
+  return new BaseMessage({ type: COHORT_OPT_IN, from, to, body });
+}
+function createSubmitUpdateMessage(fields) {
+  const { from, to, ...body } = fields;
+  return new BaseMessage({ type: SUBMIT_UPDATE, from, to, body });
+}
+function createSubmitNonIncludedMessage(fields) {
+  const { from, to, ...body } = fields;
+  return new BaseMessage({ type: SUBMIT_NONINCLUDED, from, to, body });
+}
+function createValidationAckMessage(fields) {
+  const { from, to, ...body } = fields;
+  return new BaseMessage({ type: VALIDATION_ACK, from, to, body });
+}
+function createNonceContributionMessage(fields) {
+  const { from, to, ...body } = fields;
+  return new BaseMessage({ type: NONCE_CONTRIBUTION, from, to, body });
+}
+function createSignatureAuthorizationMessage(fields) {
+  const { from, to, ...body } = fields;
+  return new BaseMessage({ type: SIGNATURE_AUTHORIZATION, from, to, body });
+}
+function createFallbackSignatureMessage(fields) {
+  const { from, to, ...body } = fields;
+  return new BaseMessage({ type: FALLBACK_SIGNATURE, from, to, body });
+}
+
+// src/core/signing-session.ts
+var import_keypair = require("@did-btcr2/keypair");
+var import_btc_signer4 = require("@scure/btc-signer");
+var musig2 = __toESM(require("@scure/btc-signer/musig2"), 1);
+var BeaconSigningSession = class {
+  /** Unique identifier for this signing session. */
+  id;
+  /** The cohort this session signs for. */
+  cohort;
+  /** The Bitcoin transaction being signed. */
+  pendingTx;
+  /** Previous output scripts for Taproot sighash computation (BIP-341). */
+  prevOutScripts;
+  /** Previous output values for Taproot sighash computation. */
+  prevOutValues;
+  /** Map of participant publicKey-hex to public nonce contribution. */
+  nonceContributions = /* @__PURE__ */ new Map();
+  /** Aggregated MuSig2 nonce (66 bytes). */
+  aggregatedNonce;
+  /** Map of participant DID to partial signature. */
+  partialSignatures = /* @__PURE__ */ new Map();
+  /** Final 64-byte Schnorr signature. */
+  signature;
+  /** Current signing session phase. */
+  phase;
+  /**
+   * Participant's MuSig2 secret nonce, held only on the participant side
+   * between {@link generateNonceContribution} and {@link generatePartialSignature}.
+   * Private and cleared on every terminal path (success, failure, or teardown
+   * via {@link clearSecrets}) so a spent or abandoned nonce cannot be reused or
+   * serialized.
+   */
+  #secretNonce;
+  constructor({ id, cohort, pendingTx, prevOutScripts, prevOutValues }) {
+    this.id = id || crypto.randomUUID();
+    this.cohort = cohort;
+    this.pendingTx = pendingTx;
+    this.prevOutScripts = prevOutScripts || [];
+    this.prevOutValues = prevOutValues || [];
+    this.phase = "AwaitingNonceContributions" /* AwaitingNonceContributions */;
+  }
+  /**
+   * Computes the Taproot sighash (BIP-341) for the first input.
+   */
+  get sigHash() {
+    if (!this.prevOutScripts.length || !this.prevOutValues.length) {
+      throw new SigningSessionError(
+        "Cannot compute sighash: missing prevOutScripts or prevOutValues.",
+        "SIGHASH_ERROR"
+      );
+    }
+    return this.pendingTx.preimageWitnessV1(
+      0,
+      this.prevOutScripts,
+      import_btc_signer4.SigHash.DEFAULT,
+      this.prevOutValues
+    );
+  }
+  addNonceContribution(participantDid, nonceContribution) {
+    if (this.phase !== "AwaitingNonceContributions" /* AwaitingNonceContributions */) {
+      throw new SigningSessionError(
+        `Nonce contributions not expected. Current phase: ${this.phase}`,
+        "INVALID_PHASE",
+        { phase: this.phase }
+      );
+    }
+    if (!this.cohort.participants.includes(participantDid)) {
+      throw new SigningSessionError(
+        `Participant ${participantDid} is not a member of cohort ${this.cohort.id}.`,
+        "UNKNOWN_PARTICIPANT",
+        { cohortId: this.cohort.id, participantDid }
+      );
+    }
+    if (nonceContribution.length !== 66) {
+      throw new SigningSessionError(
+        `Invalid nonce contribution: expected 66 bytes, got ${nonceContribution.length}.`,
+        "INVALID_NONCE_LENGTH"
+      );
+    }
+    if (this.nonceContributions.has(participantDid)) {
+      throw new SigningSessionError(
+        `Duplicate nonce contribution from ${participantDid}.`,
+        "DUPLICATE_NONCE"
+      );
+    }
+    this.nonceContributions.set(participantDid, nonceContribution);
+    if (this.nonceContributions.size === this.cohort.participants.length) {
+      this.phase = "NonceContributionsReceived" /* NonceContributionsReceived */;
+    }
+  }
+  generateAggregatedNonce() {
+    if (this.phase !== "NonceContributionsReceived" /* NonceContributionsReceived */) {
+      throw new SigningSessionError(
+        `Cannot aggregate nonces: phase is ${this.phase}, expected NonceContributionsReceived.`,
+        "INVALID_PHASE"
+      );
+    }
+    this.aggregatedNonce = musig2.nonceAggregate([...this.nonceContributions.values()]);
+    this.phase = "AwaitingPartialSignatures" /* AwaitingPartialSignatures */;
+    return this.aggregatedNonce;
+  }
+  addPartialSignature(participantDid, partialSig) {
+    if (this.phase !== "AwaitingPartialSignatures" /* AwaitingPartialSignatures */) {
+      throw new SigningSessionError(
+        `Partial signatures not expected. Current phase: ${this.phase}`,
+        "INVALID_PHASE"
+      );
+    }
+    if (!this.cohort.participants.includes(participantDid)) {
+      throw new SigningSessionError(
+        `Participant ${participantDid} is not a member of cohort ${this.cohort.id}.`,
+        "UNKNOWN_PARTICIPANT",
+        { cohortId: this.cohort.id, participantDid }
+      );
+    }
+    if (this.partialSignatures.has(participantDid)) {
+      throw new SigningSessionError(
+        `Duplicate partial signature from ${participantDid}.`,
+        "DUPLICATE_PARTIAL_SIG"
+      );
+    }
+    this.partialSignatures.set(participantDid, partialSig);
+    if (this.partialSignatures.size === this.cohort.participants.length) {
+      this.phase = "PartialSignaturesReceived" /* PartialSignaturesReceived */;
+    }
+  }
+  generateFinalSignature() {
+    if (this.phase !== "PartialSignaturesReceived" /* PartialSignaturesReceived */) {
+      throw new SigningSessionError(
+        `Cannot generate final signature: phase is ${this.phase}.`,
+        "INVALID_PHASE"
+      );
+    }
+    if (!this.aggregatedNonce) {
+      throw new SigningSessionError("Aggregated nonce missing.", "MISSING_AGGREGATED_NONCE");
+    }
+    const session = new musig2.Session(
+      this.aggregatedNonce,
+      this.cohort.cohortKeys,
+      this.sigHash,
+      [this.cohort.tapTweak],
+      [true]
+    );
+    const pubNoncesByIndex = new Array(this.cohort.cohortKeys.length);
+    for (const [did, nonce] of this.nonceContributions) {
+      const idx = this.cohort.indexOfParticipant(did);
+      if (idx < 0) {
+        throw new SigningSessionError(
+          `Cannot verify nonce from ${did}: participant key missing from cohort.`,
+          "UNKNOWN_PARTICIPANT_KEY",
+          { participantDid: did }
+        );
+      }
+      pubNoncesByIndex[idx] = nonce;
+    }
+    for (const [did, partialSig] of this.partialSignatures) {
+      const idx = this.cohort.indexOfParticipant(did);
+      if (idx < 0) {
+        throw new SigningSessionError(
+          `Cannot verify partial signature from ${did}: participant key missing from cohort.`,
+          "UNKNOWN_PARTICIPANT_KEY",
+          { participantDid: did }
+        );
+      }
+      const ok = session.partialSigVerify(partialSig, pubNoncesByIndex, idx);
+      if (!ok) {
+        throw new SigningSessionError(
+          `Bad partial signature from ${did}.`,
+          "BAD_PARTIAL_SIG",
+          { participantDid: did, index: idx }
+        );
+      }
+    }
+    this.signature = session.partialSigAgg([...this.partialSignatures.values()]);
+    this.phase = "Complete" /* Complete */;
+    return this.signature;
+  }
+  /**
+   * Generates a fresh MuSig2 nonce contribution for the participant.
+   * Stores the secret nonce internally for use in `generatePartialSignature()`.
+   */
+  generateNonceContribution(participantPublicKey, participantSecretKey) {
+    const aggPublicKey = musig2.keyAggExport(musig2.keyAggregate(this.cohort.cohortKeys));
+    const nonces = musig2.nonceGen(participantPublicKey, participantSecretKey, aggPublicKey);
+    this.#secretNonce = nonces.secret;
+    return nonces.public;
+  }
+  /**
+   * 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) {
+    if (!this.aggregatedNonce) {
+      throw new SigningSessionError("Aggregated nonce not available.", "MISSING_AGGREGATED_NONCE");
+    }
+    if (!this.#secretNonce) {
+      throw new SigningSessionError("Secret nonce not available - generateNonceContribution() must be called first.", "MISSING_SECRET_NONCE");
+    }
+    const session = new musig2.Session(
+      this.aggregatedNonce,
+      this.cohort.cohortKeys,
+      this.sigHash,
+      [this.cohort.tapTweak],
+      [true]
+    );
+    try {
+      return session.sign(this.#secretNonce, participantSecretKey);
+    } finally {
+      this.clearSecrets();
+    }
+  }
+  /**
+   * 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() {
+    if (this.#secretNonce) {
+      (0, import_keypair.wipe)(this.#secretNonce);
+      this.#secretNonce = void 0;
+    }
+  }
+  isComplete() {
+    return this.phase === "Complete" /* Complete */;
+  }
+  isFailed() {
+    return this.phase === "Failed" /* Failed */;
+  }
+};
+
+// src/participant/participant.ts
+function txEmbedsSignal(tx, signalHex) {
+  let expected;
+  try {
+    expected = (0, import_utils3.hexToBytes)(signalHex);
+  } catch {
+    return false;
+  }
+  if (expected.length === 0) return false;
+  for (let i = 0; i < tx.outputsLength; i++) {
+    const script = tx.getOutput(i)?.script;
+    if (!script) continue;
+    let decoded;
+    try {
+      decoded = import_btc_signer5.Script.decode(script);
+    } catch {
+      continue;
+    }
+    if (decoded.length === 2 && decoded[0] === "RETURN" && decoded[1] instanceof Uint8Array) {
+      const payload = decoded[1];
+      if (payload.length === expected.length && payload.every((b, j) => b === expected[j])) return true;
+    }
+  }
+  return false;
+}
+var AggregationParticipant = class {
+  did;
+  /** MuSig2 signing capability. The raw secret never lives as a field here. */
+  #signer;
+  /** Per-cohort state, keyed by cohortId. */
+  #cohortStates = /* @__PURE__ */ new Map();
+  constructor({ did, signer }) {
+    this.did = did;
+    this.#signer = signer;
+  }
+  /** The participant's compressed (33-byte) MuSig2 public key. Not secret. */
+  get publicKey() {
+    return this.#signer.publicKey;
+  }
+  /**
+   * Process an incoming message. Updates internal state but never produces
+   * outgoing messages: those come exclusively from action methods.
+   */
+  receive(message) {
+    if (message.version === void 0 || message.version !== AGGREGATION_WIRE_VERSION) {
+      return;
+    }
+    const type = message.type;
+    switch (type) {
+      case COHORT_ADVERT:
+        this.#handleCohortAdvert(message);
+        break;
+      case COHORT_OPT_IN_ACCEPT:
+        this.#handleOptInAccept(message);
+        break;
+      case COHORT_READY:
+        this.#handleCohortReady(message);
+        break;
+      case DISTRIBUTE_AGGREGATED_DATA:
+        this.#handleDistributeAggregatedData(message);
+        break;
+      case AUTHORIZATION_REQUEST:
+        this.#handleAuthorizationRequest(message);
+        break;
+      case AGGREGATED_NONCE:
+        this.#handleAggregatedNonce(message);
+        break;
+      case FALLBACK_AUTHORIZATION_REQUEST:
+        this.#handleFallbackAuthorizationRequest(message);
+        break;
+      default:
+        break;
+    }
+  }
+  /** Cohorts the participant has discovered but not yet joined. */
+  get discoveredCohorts() {
+    const map = /* @__PURE__ */ new Map();
+    for (const [id, state] of this.#cohortStates) {
+      if (state.phase === "Discovered" /* Discovered */ && state.advert) {
+        map.set(id, state.advert);
+      }
+    }
+    return map;
+  }
+  #handleCohortAdvert(message) {
+    if (!isCohortAdvertMessage(message)) return;
+    const { cohortId, network, communicationPk, ...conditions } = message.body;
+    if (this.#cohortStates.has(cohortId)) return;
+    const advert = {
+      cohortId,
+      serviceDid: message.from,
+      network,
+      serviceCommunicationPk: communicationPk,
+      ...conditions
+    };
+    this.#cohortStates.set(cohortId, {
+      phase: "Discovered" /* Discovered */,
+      cohortId,
+      serviceDid: message.from,
+      advert
+    });
+  }
+  /**
+   * User action: join a discovered cohort.
+   * Returns the opt-in message to send.
+   */
+  joinCohort(cohortId) {
+    const state = this.#cohortStates.get(cohortId);
+    if (!state || state.phase !== "Discovered" /* Discovered */) {
+      throw new AggregationParticipantError(
+        `Cannot join cohort ${cohortId}: not in Discovered phase.`,
+        "INVALID_PHASE",
+        { cohortId, phase: state?.phase }
+      );
+    }
+    const advert = state.advert;
+    const cohort = new AggregationCohort({
+      id: cohortId,
+      serviceDid: state.serviceDid,
+      minParticipants: advert.minParticipants,
+      network: advert.network,
+      beaconType: advert.beaconType,
+      recoveryKey: advert.recoveryKey ? (0, import_utils3.hexToBytes)(advert.recoveryKey) : void 0,
+      recoverySequence: advert.recoverySequence,
+      fundingModel: advert.fundingModel,
+      fallbackThreshold: advert.fallbackThreshold
+    });
+    state.cohort = cohort;
+    state.phase = "OptedIn" /* OptedIn */;
+    const optInMessage = createCohortOptInMessage({
+      from: this.did,
+      to: state.serviceDid,
+      cohortId,
+      participantPk: this.publicKey,
+      communicationPk: this.publicKey
+    });
+    return [optInMessage];
+  }
+  #handleOptInAccept(message) {
+    void message;
+  }
+  /** Cohorts that have been finalized: beacon address available. */
+  get joinedCohorts() {
+    const map = /* @__PURE__ */ new Map();
+    for (const [id, state] of this.#cohortStates) {
+      if (state.cohort && state.cohort.beaconAddress) {
+        map.set(id, {
+          cohortId: id,
+          serviceDid: state.serviceDid,
+          beaconAddress: state.cohort.beaconAddress,
+          cohortKeys: state.cohort.cohortKeys
+        });
+      }
+    }
+    return map;
+  }
+  #handleCohortReady(message) {
+    const cohortId = message.body?.cohortId;
+    if (!cohortId) return;
+    const state = this.#cohortStates.get(cohortId);
+    if (!state || !state.cohort) return;
+    if (state.phase !== "OptedIn" /* OptedIn */) return;
+    const beaconAddress = message.body?.beaconAddress;
+    const cohortKeys = message.body?.cohortKeys;
+    if (!beaconAddress || !cohortKeys) return;
+    const participantPkHex = (0, import_utils3.bytesToHex)(this.publicKey);
+    const cohortKeysHex = cohortKeys.map((k) => (0, import_utils3.bytesToHex)(new Uint8Array(k)));
+    state.cohort.validateMembership(participantPkHex, cohortKeysHex, beaconAddress);
+    state.phase = "CohortReady" /* CohortReady */;
+  }
+  /**
+   * User action: submit a signed BTCR2 update for inclusion in the cohort's
+   * aggregated signal.
+   */
+  submitUpdate(cohortId, signedUpdate) {
+    const state = this.#cohortStates.get(cohortId);
+    if (!state || state.phase !== "CohortReady" /* CohortReady */) {
+      throw new AggregationParticipantError(
+        `Cannot submit update to cohort ${cohortId}: not in CohortReady phase.`,
+        "INVALID_PHASE",
+        { cohortId, phase: state?.phase }
+      );
+    }
+    state.submittedUpdate = signedUpdate;
+    state.included = true;
+    state.phase = "UpdateSubmitted" /* UpdateSubmitted */;
+    const message = createSubmitUpdateMessage({
+      from: this.did,
+      to: state.serviceDid,
+      cohortId,
+      signedUpdate
+    });
+    return [message];
+  }
+  /**
+   * User action: decline to submit an update this round (cooperative
+   * non-inclusion). The member stays in the cohort and still signs; it will be
+   * absent from the CAS Announcement Map, or carry a non-inclusion leaf in the
+   * SMT. Returns the SUBMIT_NONINCLUDED message to send.
+   */
+  declineUpdate(cohortId) {
+    const state = this.#cohortStates.get(cohortId);
+    if (!state || state.phase !== "CohortReady" /* CohortReady */) {
+      throw new AggregationParticipantError(
+        `Cannot decline in cohort ${cohortId}: not in CohortReady phase.`,
+        "INVALID_PHASE",
+        { cohortId, phase: state?.phase }
+      );
+    }
+    state.included = false;
+    state.phase = "NonIncluded" /* NonIncluded */;
+    const message = createSubmitNonIncludedMessage({
+      from: this.did,
+      to: state.serviceDid,
+      cohortId
+    });
+    return [message];
+  }
+  /** Aggregated data awaiting user validation. */
+  get pendingValidations() {
+    const map = /* @__PURE__ */ new Map();
+    for (const [id, state] of this.#cohortStates) {
+      if (state.phase === "AwaitingValidation" /* AwaitingValidation */ && state.validation) {
+        map.set(id, state.validation);
+      }
+    }
+    return map;
+  }
+  /**
+   * The validated aggregated data retained for a cohort, regardless of phase.
+   * Unlike {@link pendingValidations} (which lists only cohorts still awaiting
+   * the validate decision), this returns the stored validation, including the
+   * participant's sidecar (the CAS Announcement map or its SMT inclusion proof),
+   * so it is still readable once the cohort reaches Complete. Returns
+   * undefined before aggregated data has been received.
+   */
+  getValidation(cohortId) {
+    return this.#cohortStates.get(cohortId)?.validation;
+  }
+  #handleDistributeAggregatedData(message) {
+    const cohortId = message.body?.cohortId;
+    if (!cohortId) return;
+    const state = this.#cohortStates.get(cohortId);
+    if (!state || state.phase !== "UpdateSubmitted" /* UpdateSubmitted */ && state.phase !== "NonIncluded" /* NonIncluded */) return;
+    const declined = state.included === false;
+    if (!declined && !state.submittedUpdate) return;
+    const beaconType = message.body?.beaconType;
+    if (!beaconType) return;
+    const strategy = getBeaconStrategy(beaconType);
+    if (!strategy) return;
+    const signalBytesHex = message.body?.signalBytesHex ?? "";
+    const expectedHash = declined ? "" : (0, import_common4.canonicalHash)(state.submittedUpdate);
+    const result = strategy.validateParticipantView({
+      participantDid: this.did,
+      included: !declined,
+      submittedUpdate: declined ? void 0 : state.submittedUpdate,
+      expectedHash: declined ? void 0 : expectedHash,
+      body: message.body
+    });
+    state.validation = {
+      cohortId,
+      beaconType,
+      signalBytesHex,
+      expectedHash,
+      matches: result.matches,
+      casAnnouncement: result.casAnnouncement,
+      smtProof: result.smtProof,
+      included: !declined
+    };
+    state.phase = "AwaitingValidation" /* AwaitingValidation */;
+  }
+  /**
+   * User action: approve aggregated data and send validation ack.
+   */
+  approveValidation(cohortId) {
+    const state = this.#cohortStates.get(cohortId);
+    if (!state || state.phase !== "AwaitingValidation" /* AwaitingValidation */) {
+      throw new AggregationParticipantError(
+        `Cannot approve validation for cohort ${cohortId}: not in AwaitingValidation phase.`,
+        "INVALID_PHASE",
+        { cohortId, phase: state?.phase }
+      );
+    }
+    state.phase = "ValidationSent" /* ValidationSent */;
+    return [createValidationAckMessage({
+      from: this.did,
+      to: state.serviceDid,
+      cohortId,
+      approved: true
+    })];
+  }
+  /**
+   * User action: reject aggregated data and send rejection ack.
+   */
+  rejectValidation(cohortId) {
+    const state = this.#cohortStates.get(cohortId);
+    if (!state || state.phase !== "AwaitingValidation" /* AwaitingValidation */) {
+      throw new AggregationParticipantError(
+        `Cannot reject validation for cohort ${cohortId}: not in AwaitingValidation phase.`,
+        "INVALID_PHASE",
+        { cohortId, phase: state?.phase }
+      );
+    }
+    state.phase = "Failed" /* Failed */;
+    return [createValidationAckMessage({
+      from: this.did,
+      to: state.serviceDid,
+      cohortId,
+      approved: false
+    })];
+  }
+  /** Signing requests awaiting user approval. */
+  get pendingSigningRequests() {
+    const map = /* @__PURE__ */ new Map();
+    for (const [id, state] of this.#cohortStates) {
+      if (state.phase === "AwaitingSigning" /* AwaitingSigning */ && state.signingRequest) {
+        map.set(id, state.signingRequest);
+      }
+    }
+    return map;
+  }
+  #handleAuthorizationRequest(message) {
+    const cohortId = message.body?.cohortId;
+    if (!cohortId) return;
+    const state = this.#cohortStates.get(cohortId);
+    if (!state || !state.cohort) return;
+    if (state.phase !== "ValidationSent" /* ValidationSent */) return;
+    const sessionId = message.body?.sessionId;
+    const pendingTxHex = message.body?.pendingTx;
+    const prevOutScriptHex = message.body?.prevOutScriptHex;
+    const prevOutValue = message.body?.prevOutValue;
+    if (!sessionId || !pendingTxHex || !prevOutScriptHex || !prevOutValue) return;
+    state.signingRequest = {
+      cohortId,
+      sessionId,
+      pendingTxHex,
+      prevOutScriptHex,
+      prevOutValue
+    };
+    state.phase = "AwaitingSigning" /* AwaitingSigning */;
+  }
+  /**
+   * Bind a signing approval to the announcement the member validated: a beacon
+   * transaction MUST carry an OP_RETURN with the exact 32-byte signal stored when
+   * the aggregated data was distributed. Both the optimistic nonce approval and
+   * the fallback approval sign with SIGHASH_DEFAULT (committing to every output)
+   * while the coordinator drives output selection, so without this check a
+   * coordinator could anchor a different signal under the member's signature.
+   */
+  #assertTxAnchorsValidatedSignal(cohortId, state, tx) {
+    const signalHex = state.validation?.signalBytesHex;
+    if (!signalHex) {
+      throw new AggregationParticipantError(
+        `Cohort ${cohortId} has no validated signal to bind the signature to.`,
+        "MISSING_STATE",
+        { cohortId }
+      );
+    }
+    if (!txEmbedsSignal(tx, signalHex)) {
+      throw new AggregationParticipantError(
+        `Transaction for cohort ${cohortId} does not anchor the validated signal.`,
+        "SIGNAL_MISMATCH",
+        { cohortId }
+      );
+    }
+  }
+  /**
+   * User action: approve signing and generate nonce contribution.
+   */
+  approveNonce(cohortId) {
+    const state = this.#cohortStates.get(cohortId);
+    if (!state || state.phase !== "AwaitingSigning" /* AwaitingSigning */) {
+      throw new AggregationParticipantError(
+        `Cannot approve nonce for cohort ${cohortId}: not in AwaitingSigning phase.`,
+        "INVALID_PHASE",
+        { cohortId, phase: state?.phase }
+      );
+    }
+    if (!state.signingRequest || !state.cohort) {
+      throw new AggregationParticipantError(
+        `Cohort ${cohortId} missing signing request or cohort state.`,
+        "MISSING_STATE",
+        { cohortId }
+      );
+    }
+    const tx = import_btc_signer5.Transaction.fromRaw((0, import_utils3.hexToBytes)(state.signingRequest.pendingTxHex), { allowUnknownOutputs: true });
+    this.#assertTxAnchorsValidatedSignal(cohortId, state, tx);
+    const prevOutScripts = [(0, import_utils3.hexToBytes)(state.signingRequest.prevOutScriptHex)];
+    const prevOutValues = [BigInt(state.signingRequest.prevOutValue)];
+    const session = new BeaconSigningSession({
+      id: state.signingRequest.sessionId,
+      cohort: state.cohort,
+      pendingTx: tx,
+      prevOutScripts,
+      prevOutValues
+    });
+    state.signingSession = session;
+    const nonceContribution = this.#signer.withSecret(
+      (secretKey) => session.generateNonceContribution(this.publicKey, secretKey)
+    );
+    state.phase = "NonceSent" /* NonceSent */;
+    return [createNonceContributionMessage({
+      from: this.did,
+      to: state.serviceDid,
+      cohortId,
+      sessionId: session.id,
+      nonceContribution
+    })];
+  }
+  #handleAggregatedNonce(message) {
+    const cohortId = message.body?.cohortId;
+    if (!cohortId) return;
+    const state = this.#cohortStates.get(cohortId);
+    if (!state || !state.signingSession) return;
+    if (state.phase !== "NonceSent" /* NonceSent */) return;
+    const aggregatedNonce = message.body?.aggregatedNonce;
+    if (!aggregatedNonce) return;
+    state.signingSession.aggregatedNonce = aggregatedNonce;
+    state.phase = "AwaitingPartialSig" /* AwaitingPartialSig */;
+  }
+  /**
+   * User action: generate and return the partial signature.
+   * In most UIs this is automatic after AwaitingPartialSig, but exposing it
+   * as an explicit action lets the client UI confirm before signing if desired.
+   */
+  generatePartialSignature(cohortId) {
+    const state = this.#cohortStates.get(cohortId);
+    if (!state || state.phase !== "AwaitingPartialSig" /* AwaitingPartialSig */) {
+      throw new AggregationParticipantError(
+        `Cannot generate partial signature for cohort ${cohortId}: not in AwaitingPartialSig phase.`,
+        "INVALID_PHASE",
+        { cohortId, phase: state?.phase }
+      );
+    }
+    if (!state.signingSession) {
+      throw new AggregationParticipantError(
+        `No signing session for cohort ${cohortId}.`,
+        "MISSING_STATE",
+        { cohortId }
+      );
+    }
+    const signingSession = state.signingSession;
+    const partialSig = this.#signer.withSecret(
+      (secretKey) => signingSession.generatePartialSignature(secretKey)
+    );
+    state.phase = "Complete" /* Complete */;
+    return [createSignatureAuthorizationMessage({
+      from: this.did,
+      to: state.serviceDid,
+      cohortId,
+      sessionId: state.signingSession.id,
+      partialSignature: partialSig
+    })];
+  }
+  /** Fallback signing requests awaiting user approval (UI: review the fallback spend). */
+  get pendingFallbackRequests() {
+    const map = /* @__PURE__ */ new Map();
+    for (const [id, state] of this.#cohortStates) {
+      if (state.phase === "AwaitingFallbackSig" /* AwaitingFallbackSig */ && state.fallbackRequest) {
+        map.set(id, state.fallbackRequest);
+      }
+    }
+    return map;
+  }
+  #handleFallbackAuthorizationRequest(message) {
+    const cohortId = message.body?.cohortId;
+    if (!cohortId) return;
+    const state = this.#cohortStates.get(cohortId);
+    if (!state || !state.cohort) return;
+    const acceptFrom = [
+      "ValidationSent" /* ValidationSent */,
+      "AwaitingSigning" /* AwaitingSigning */,
+      "NonceSent" /* NonceSent */,
+      "AwaitingPartialSig" /* AwaitingPartialSig */,
+      "Complete" /* Complete */
+    ];
+    if (!acceptFrom.includes(state.phase)) return;
+    const sessionId = message.body?.sessionId;
+    const pendingTxHex = message.body?.pendingTx;
+    const prevOutScriptHex = message.body?.prevOutScriptHex;
+    const prevOutValue = message.body?.prevOutValue;
+    const fallbackLeafScriptHex = message.body?.fallbackLeafScriptHex;
+    if (!sessionId || !pendingTxHex || !prevOutScriptHex || !prevOutValue || !fallbackLeafScriptHex) return;
+    state.fallbackRequest = { cohortId, sessionId, pendingTxHex, prevOutScriptHex, prevOutValue, fallbackLeafScriptHex };
+    state.signingSession?.clearSecrets();
+    state.phase = "AwaitingFallbackSig" /* AwaitingFallbackSig */;
+  }
+  /**
+   * User action: authorize the fallback spend. Recomputes the k-of-n fallback
+   * leaf from the member's OWN cohort state (not the service-provided script),
+   * computes the BIP-341 script-path sighash over the requested transaction, and
+   * returns a standalone BIP-340 signature (no nonce round). The member completes
+   * once it has contributed; the service needs only k of these.
+   */
+  approveFallback(cohortId) {
+    const state = this.#cohortStates.get(cohortId);
+    if (!state || state.phase !== "AwaitingFallbackSig" /* AwaitingFallbackSig */) {
+      throw new AggregationParticipantError(
+        `Cannot approve fallback for cohort ${cohortId}: not in AwaitingFallbackSig phase.`,
+        "INVALID_PHASE",
+        { cohortId, phase: state?.phase }
+      );
+    }
+    if (!state.fallbackRequest || !state.cohort) {
+      throw new AggregationParticipantError(
+        `Cohort ${cohortId} missing fallback request or cohort state.`,
+        "MISSING_STATE",
+        { cohortId }
+      );
+    }
+    const req = state.fallbackRequest;
+    const tx = import_btc_signer5.Transaction.fromRaw((0, import_utils3.hexToBytes)(req.pendingTxHex), { allowUnknownOutputs: true });
+    const prevOutScript = (0, import_utils3.hexToBytes)(req.prevOutScriptHex);
+    const prevOutValue = BigInt(req.prevOutValue);
+    this.#assertTxAnchorsValidatedSignal(cohortId, state, tx);
+    const fallbackLeaf = buildFallbackLeaf({
+      cohortKeys: state.cohort.cohortKeys,
+      fallbackThreshold: state.cohort.effectiveFallbackThreshold
+    });
+    const sighash = fallbackSighash(tx, 0, prevOutScript, prevOutValue, fallbackLeaf);
+    const signature = this.#signer.withSecret((secretKey) => import_secp256k14.schnorr.sign(sighash, secretKey));
+    state.phase = "Complete" /* Complete */;
+    return [createFallbackSignatureMessage({
+      from: this.did,
+      to: state.serviceDid,
+      cohortId,
+      sessionId: req.sessionId,
+      signerPk: this.publicKey.slice(1),
+      fallbackSignature: signature
+    })];
+  }
+  getCohortPhase(cohortId) {
+    return this.#cohortStates.get(cohortId)?.phase;
+  }
+  /**
+   * Zeroize any retained MuSig2 secret nonces across all cohorts. The raw
+   * signing key is never held here (it lives behind the {@link AggregationSigner}
+   * and is wiped per-operation), but an abandoned signing session can still hold
+   * a secret nonce; call this on teardown to clear it deterministically.
+   */
+  clearSecrets() {
+    for (const state of this.#cohortStates.values()) {
+      state.signingSession?.clearSecrets();
+    }
+  }
+};
+
+// src/core/signer.ts
+var import_keypair2 = require("@did-btcr2/keypair");
+var KeyPairAggregationSigner = class {
+  publicKey;
+  #keys;
+  /** @param {SchnorrKeyPair} keys The keypair whose secret backs this signer. */
+  constructor(keys) {
+    this.#keys = keys;
+    this.publicKey = keys.publicKey.compressed;
+  }
+  withSecret(fn) {
+    const secretKey = this.#keys.secretKey.bytes;
+    try {
+      return fn(secretKey);
+    } finally {
+      (0, import_keypair2.wipe)(secretKey);
+    }
+  }
+};
+
+// src/core/typed-emitter.ts
+var TypedEventEmitter = class {
+  #listeners = /* @__PURE__ */ new Map();
+  /** Subscribe to an event. */
+  on(event, listener) {
+    let set = this.#listeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.#listeners.set(event, set);
+    }
+    set.add(listener);
+    return this;
+  }
+  /** Subscribe to an event, automatically unsubscribing after the first call. */
+  once(event, listener) {
+    const wrapped = ((...args) => {
+      this.off(event, wrapped);
+      listener(...args);
+    });
+    return this.on(event, wrapped);
+  }
+  /** Unsubscribe a specific listener. */
+  off(event, listener) {
+    this.#listeners.get(event)?.delete(listener);
+    return this;
+  }
+  /** Emit an event to all subscribed listeners. */
+  emit(event, ...args) {
+    const set = this.#listeners.get(event);
+    if (!set || set.size === 0) return false;
+    for (const listener of set) {
+      try {
+        listener(...args);
+      } catch (err) {
+        console.error(`Listener for event "${String(event)}" threw:`, err);
+      }
+    }
+    return true;
+  }
+  /** Remove all listeners (optionally for a specific event). */
+  removeAllListeners(event) {
+    if (event === void 0) {
+      this.#listeners.clear();
+    } else {
+      this.#listeners.delete(event);
+    }
+    return this;
+  }
+  /** Number of listeners for an event. */
+  listenerCount(event) {
+    return this.#listeners.get(event)?.size ?? 0;
+  }
+};
+
+// src/participant/participant-runner.ts
+var AggregationParticipantRunner = class _AggregationParticipantRunner extends TypedEventEmitter {
+  /** Direct access to the underlying state machine for advanced use. */
+  session;
+  #transport;
+  #did;
+  #shouldJoin;
+  #onProvideUpdate;
+  #onValidateData;
+  #onApproveSigning;
+  #handlersRegistered = false;
+  #stopped = false;
+  constructor(options) {
+    super();
+    this.#transport = options.transport;
+    this.#did = options.did;
+    this.#shouldJoin = options.shouldJoin ?? (async () => false);
+    this.#onProvideUpdate = options.onProvideUpdate;
+    this.#onValidateData = options.onValidateData ?? (async (info) => ({ approved: info.matches }));
+    this.#onApproveSigning = options.onApproveSigning ?? (async () => ({ approved: true }));
+    this.session = new AggregationParticipant({
+      did: options.did,
+      signer: new KeyPairAggregationSigner(options.keys)
+    });
+  }
+  /**
+   * Start listening for cohorts. The runner stays active until {@link stop}
+   * is called or the underlying transport disconnects.
+   */
+  async start() {
+    this.#registerHandlers();
+  }
+  /** Stop the runner and detach transport handlers. Safe to call repeatedly. */
+  stop() {
+    this.#stopped = true;
+    this.#unregisterHandlers();
+    this.session.clearSecrets();
+  }
+  /** Message types this runner listens for on the transport. */
+  static #HANDLED_MESSAGE_TYPES = [
+    COHORT_ADVERT,
+    COHORT_OPT_IN_ACCEPT,
+    COHORT_READY,
+    DISTRIBUTE_AGGREGATED_DATA,
+    AUTHORIZATION_REQUEST,
+    AGGREGATED_NONCE,
+    FALLBACK_AUTHORIZATION_REQUEST
+  ];
+  /** Internal: detach from the transport. Safe to call repeatedly. */
+  #unregisterHandlers() {
+    if (!this.#handlersRegistered) return;
+    this.#handlersRegistered = false;
+    for (const type of _AggregationParticipantRunner.#HANDLED_MESSAGE_TYPES) {
+      this.#transport.unregisterMessageHandler(this.#did, type);
+    }
+  }
+  /**
+   * Single-shot helper: start, join the first cohort that passes `shouldJoin`,
+   * drive it to completion, and resolve. Convenient for tests and demos. The
+   * single-cohort special case of {@link joinMatching} (count = 1).
+   */
+  static async joinFirst(options) {
+    return new Promise((resolve, reject) => {
+      const runner = new _AggregationParticipantRunner(options);
+      runner.once("cohort-complete", (info) => {
+        runner.stop();
+        resolve(info);
+      });
+      runner.on("error", reject);
+      runner.start().catch(reject);
+    });
+  }
+  /**
+   * Multi-cohort helper: start, join EVERY cohort whose advert passes
+   * `shouldJoin`, drive each to completion in parallel, and resolve once
+   * `count` cohorts have completed (the runner stops at that point). The
+   * N-cohort generalization of {@link joinFirst}, for a participant that joins
+   * several cohorts advertised by one service.
+   *
+   * For an open-ended, long-lived subscriber (no fixed count), construct an
+   * {@link AggregationParticipantRunner} directly, set `shouldJoin`, call
+   * `start()`, and listen for `cohort-complete` - the runner already drives
+   * any number of cohorts concurrently.
+   *
+   * @param options Participant runner options (set `shouldJoin` to select cohorts).
+   * @param count Number of completed cohorts to collect before resolving.
+   * @returns The {@link CohortCompleteInfo} for each completed cohort, in completion order.
+   */
+  static async joinMatching(options, count) {
+    return new Promise((resolve, reject) => {
+      const runner = new _AggregationParticipantRunner(options);
+      const completed = [];
+      runner.on("cohort-complete", (info) => {
+        completed.push(info);
+        if (completed.length >= count) {
+          runner.stop();
+          resolve(completed);
+        }
+      });
+      runner.on("error", reject);
+      runner.start().catch(reject);
+    });
+  }
+  /**
+   * Internal: handler registration with the transport. Idempotent and safe to call multiple times,
+   * but only registers handlers once.
+   */
+  #registerHandlers() {
+    if (this.#handlersRegistered) return;
+    this.#handlersRegistered = true;
+    this.#transport.registerMessageHandler(this.#did, COHORT_ADVERT, this.#handleAdvert.bind(this));
+    this.#transport.registerMessageHandler(this.#did, COHORT_OPT_IN_ACCEPT, this.#handleOptInAccept.bind(this));
+    this.#transport.registerMessageHandler(this.#did, COHORT_READY, this.#handleCohortReady.bind(this));
+    this.#transport.registerMessageHandler(this.#did, DISTRIBUTE_AGGREGATED_DATA, this.#handleDistributeData.bind(this));
+    this.#transport.registerMessageHandler(this.#did, AUTHORIZATION_REQUEST, this.#handleAuthorizationRequest.bind(this));
+    this.#transport.registerMessageHandler(this.#did, AGGREGATED_NONCE, this.#handleAggregatedNonce.bind(this));
+    this.#transport.registerMessageHandler(this.#did, FALLBACK_AUTHORIZATION_REQUEST, this.#handleFallbackAuthorizationRequest.bind(this));
+  }
+  /**
+   * Internal: handler for cohort adverts. Applies the `shouldJoin` filter and joins if approved.
+   * @param {BaseMessage} msg - The received cohort advert message.
+   * @returns {Promise<void>} Resolves when processing is complete.
+   */
+  async #handleAdvert(msg) {
+    if (this.#stopped) return;
+    try {
+      this.session.receive(msg);
+      const advert = this.session.discoveredCohorts.get(msg.body?.cohortId ?? "");
+      if (!advert) return;
+      this.emit("cohort-discovered", advert);
+      if (advert.serviceCommunicationPk) {
+        this.#transport.registerPeer(advert.serviceDid, advert.serviceCommunicationPk);
+      }
+      const join = await this.#shouldJoin(advert);
+      if (!join) return;
+      await this.#sendAll(this.session.joinCohort(advert.cohortId));
+      this.emit("cohort-joined", { cohortId: advert.cohortId });
+    } catch (err) {
+      this.emit("error", err);
+    }
+  }
+  /**
+   * Internal: handler for opt-in accept messages. Updates the session state accordingly.
+   * @param {BaseMessage} msg - The received opt-in accept message.
+   */
+  #handleOptInAccept(msg) {
+    if (this.#stopped) return;
+    try {
+      this.session.receive(msg);
+    } catch (err) {
+      this.emit("error", err);
+    }
+  }
+  /**
+   * Internal: handler for cohort ready messages. Updates the session state, emits a 'cohort-ready'
+   * event, and triggers the update submission flow via the `onProvideUpdate` callback.
+   * @param {BaseMessage} msg - The received cohort ready message.
+   * @returns {Promise<void>} Resolves when processing is complete.
+    */
+  async #handleCohortReady(msg) {
+    if (this.#stopped) return;
+    try {
+      this.session.receive(msg);
+      const cohortId = msg.body?.cohortId;
+      if (!cohortId) return;
+      const info = this.session.joinedCohorts.get(cohortId);
+      if (!info) return;
+      this.emit("cohort-ready", { cohortId, beaconAddress: info.beaconAddress });
+      const signedUpdate = await this.#onProvideUpdate({
+        cohortId,
+        beaconAddress: info.beaconAddress
+      });
+      if (signedUpdate === null) {
+        await this.#sendAll(this.session.declineUpdate(cohortId));
+        this.emit("update-declined", { cohortId });
+      } else {
+        await this.#sendAll(this.session.submitUpdate(cohortId, signedUpdate));
+        this.emit("update-submitted", { cohortId });
+      }
+    } catch (err) {
+      this.emit("error", err);
+    }
+  }
+  /**
+   * Internal: handler for distribute aggregated data messages. Updates the session state, emits a
+   * 'validation-requested' event, and triggers the validation decision flow via the `onValidateData`
+   * callback. Depending on the decision, sends an approval or rejection message.
+   * @param {BaseMessage} msg - The received distribute aggregated data message.
+   * @returns {Promise<void>} Resolves when processing is complete.
+   * @throws {Error} If an error occurs during message processing or callback execution.
+   */
+  async #handleDistributeData(msg) {
+    if (this.#stopped) return;
+    try {
+      this.session.receive(msg);
+      const cohortId = msg.body?.cohortId;
+      if (!cohortId) return;
+      const validation = this.session.pendingValidations.get(cohortId);
+      if (!validation) return;
+      this.emit("validation-requested", validation);
+      const decision = await this.#onValidateData(validation);
+      if (decision.approved) {
+        await this.#sendAll(this.session.approveValidation(cohortId));
+      } else {
+        await this.#sendAll(this.session.rejectValidation(cohortId));
+        this.emit("cohort-failed", { cohortId, reason: "Validation rejected by participant" });
+      }
+    } catch (err) {
+      this.emit("error", err);
+    }
+  }
+  /**
+   * Internal: handler for authorization request messages. Updates the session state, emits a
+   * 'signing-requested' event, and triggers the signing approval flow via the `onApproveSigning`
+   * callback. Depending on the decision, sends a nonce approval message or emits a 'cohort-failed'
+   * event.
+   * @param {BaseMessage} msg - The received authorization request message.
+   * @returns {Promise<void>} Resolves when processing is complete.
+   * @throws {Error} If an error occurs during message processing or callback execution.
+   */
+  async #handleAuthorizationRequest(msg) {
+    if (this.#stopped) return;
+    try {
+      this.session.receive(msg);
+      const cohortId = msg.body?.cohortId;
+      if (!cohortId) return;
+      const req = this.session.pendingSigningRequests.get(cohortId);
+      if (!req) return;
+      this.emit("signing-requested", req);
+      const decision = await this.#onApproveSigning(req);
+      if (!decision.approved) {
+        this.emit("cohort-failed", { cohortId, reason: "Signing rejected by participant" });
+        return;
+      }
+      await this.#sendAll(this.session.approveNonce(cohortId));
+    } catch (err) {
+      this.emit("error", err);
+    }
+  }
+  /**
+   * Internal: handler for aggregated nonce messages. Updates the session state, triggers partial
+   * signature generation, and sends the partial signature to the aggregator. If the cohort reaches
+   * completion after processing the nonce, emits a 'cohort-complete' event.
+   * @param {BaseMessage} msg - The received aggregated nonce message.
+   * @returns {Promise<void>} Resolves when processing is complete.
+   * @throws {Error} If an error occurs during message processing or partial signature generation.
+   */
+  async #handleAggregatedNonce(msg) {
+    if (this.#stopped) return;
+    try {
+      this.session.receive(msg);
+      const cohortId = msg.body?.cohortId;
+      if (!cohortId) return;
+      await this.#sendAll(this.session.generatePartialSignature(cohortId));
+      this.#emitCohortCompleteIfDone(cohortId);
+    } catch (err) {
+      this.emit("error", err);
+    }
+  }
+  /**
+   * Internal: handler for fallback authorization requests. The service abandoned
+   * the optimistic key path; the member authorizes the k-of-n script-path spend
+   * of the same beacon transaction (ADR 042). Reuses `onApproveSigning` to gate
+   * the decision, signs the fallback, and completes once it has contributed (the
+   * service needs only k members).
+   * @param {BaseMessage} msg - The received fallback authorization request message.
+   * @returns {Promise<void>} Resolves when processing is complete.
+   */
+  async #handleFallbackAuthorizationRequest(msg) {
+    if (this.#stopped) return;
+    try {
+      this.session.receive(msg);
+      const cohortId = msg.body?.cohortId;
+      if (!cohortId) return;
+      const req = this.session.pendingFallbackRequests.get(cohortId);
+      if (!req) return;
+      this.emit("fallback-requested", req);
+      const decision = await this.#onApproveSigning(req);
+      if (!decision.approved) {
+        this.emit("cohort-failed", { cohortId, reason: "Fallback signing rejected by participant" });
+        return;
+      }
+      await this.#sendAll(this.session.approveFallback(cohortId));
+      this.#emitCohortCompleteIfDone(cohortId);
+    } catch (err) {
+      this.emit("error", err);
+    }
+  }
+  /**
+   * Internal: emit `cohort-complete` with the participant's retained sidecar once
+   * the cohort has reached the Complete phase. Surfaces the CAS Announcement map
+   * (CAS beacons) or the SMT proof (SMT beacons) the participant keeps for future
+   * DID resolution. Read via getValidation (not pendingValidations, which lists
+   * only the AwaitingValidation phase) so the sidecar is still available at
+   * Complete. Shared by the optimistic and fallback completion paths.
+   */
+  #emitCohortCompleteIfDone(cohortId) {
+    if (this.session.getCohortPhase(cohortId) !== "Complete" /* Complete */) return;
+    const info = this.session.joinedCohorts.get(cohortId);
+    if (!info) return;
+    const validation = this.session.getValidation(cohortId);
+    this.emit("cohort-complete", {
+      cohortId,
+      beaconAddress: info.beaconAddress,
+      beaconType: validation?.beaconType ?? "",
+      included: validation?.included ?? true,
+      casAnnouncement: validation?.casAnnouncement,
+      smtProof: validation?.smtProof
+    });
+  }
+  /**
+   * Internal: send helper to ensure messages are sent sequentially. This is important for protocol
+   * correctness, as some transports may not guarantee message order if sent in parallel.
+   * @param {BaseMessage[]} msgs - The messages to send.
+   * @returns {Promise<void>} Resolves when all messages have been sent.
+   * @throws {Error} If an error occurs during message sending.
+   */
+  async #sendAll(msgs) {
+    for (const m of msgs) {
+      await this.#transport.sendMessage(m, this.#did, m.to);
+    }
+  }
+};
+
+// src/participant/http-client.ts
+var import_keypair3 = require("@did-btcr2/keypair");
+
+// src/core/logger.ts
+var CONSOLE_LOGGER = {
+  debug: (msg, ...args) => console.debug(msg, ...args),
+  info: (msg, ...args) => console.info(msg, ...args),
+  warn: (msg, ...args) => console.warn(msg, ...args),
+  error: (msg, ...args) => console.error(msg, ...args)
+};
+
+// src/core/transport/http/envelope.ts
+var import_common6 = require("@did-btcr2/common");
+var import_utils4 = require("@noble/hashes/utils");
+
+// src/core/transport/error.ts
+var import_common5 = require("@did-btcr2/common");
+var TransportAdapterError = class extends import_common5.MethodError {
+  constructor(message, type = "TransportAdapterError", data) {
+    super(message, type, data);
+  }
+};
+
+// src/core/transport/http/errors.ts
+var HttpTransportError = class extends TransportAdapterError {
+  constructor(message, type = "HttpTransportError", data) {
+    super(message, type, { adapter: "http", ...data ?? {} });
+  }
+};
+
+// src/core/transport/http/protocol.ts
+var HTTP_ENVELOPE_VERSION = 1;
+var HTTP_ROUTE = {
+  ADVERTS: "/v1/adverts",
+  MESSAGES: "/v1/messages",
+  ACTOR_INBOX: "/v1/actors/{did}/inbox",
+  WELL_KNOWN: "/v1/.well-known/aggregation"
+};
+var SSE_EVENT = {
+  ADVERT: "advert",
+  MESSAGE: "message",
+  HEARTBEAT: "heartbeat"
+};
+var DEFAULT_CLOCK_SKEW_SEC = 60;
+var DEFAULT_NONCE_LEN_BYTES = 16;
+
+// src/core/transport/http/envelope.ts
+function signEnvelope(message, sender, opts = {}) {
+  const timestamp = opts.timestamp ?? Math.floor(Date.now() / 1e3);
+  const nonce = opts.nonce ?? (0, import_utils4.bytesToHex)((0, import_utils4.randomBytes)(DEFAULT_NONCE_LEN_BYTES));
+  const messageJson = normalizeForWire(normalizeMessage(message));
+  const unsigned = {
+    v: HTTP_ENVELOPE_VERSION,
+    from: sender.did,
+    ...opts.to !== void 0 ? { to: opts.to } : {},
+    timestamp,
+    nonce,
+    message: messageJson
+  };
+  const digest = (0, import_common6.canonicalHashBytes)(unsigned);
+  const sig = sender.keys.secretKey.sign(digest, { scheme: "schnorr" });
+  return { ...unsigned, sig: (0, import_utils4.bytesToHex)(sig) };
+}
+function verifyEnvelope(envelope, senderPk, opts = {}) {
+  if (envelope.v !== HTTP_ENVELOPE_VERSION) {
+    throw new HttpTransportError(
+      `Unsupported envelope version: ${envelope.v}`,
+      "ENVELOPE_VERSION_MISMATCH",
+      { version: envelope.v, expected: HTTP_ENVELOPE_VERSION }
+    );
+  }
+  if (opts.expectedFrom !== void 0 && envelope.from !== opts.expectedFrom) {
+    throw new HttpTransportError(
+      `Envelope from mismatch: expected ${opts.expectedFrom}, got ${envelope.from}`,
+      "ENVELOPE_FROM_MISMATCH",
+      { expected: opts.expectedFrom, got: envelope.from }
+    );
+  }
+  if ("expectedTo" in opts && envelope.to !== opts.expectedTo) {
+    throw new HttpTransportError(
+      `Envelope to mismatch: expected ${opts.expectedTo ?? "<broadcast>"}, got ${envelope.to ?? "<broadcast>"}`,
+      "ENVELOPE_TO_MISMATCH",
+      { expected: opts.expectedTo, got: envelope.to }
+    );
+  }
+  const skewSec = opts.clockSkewSec ?? DEFAULT_CLOCK_SKEW_SEC;
+  const nowMs = opts.now ? opts.now() : Date.now();
+  const nowSec = Math.floor(nowMs / 1e3);
+  const diff = Math.abs(nowSec - envelope.timestamp);
+  if (diff > skewSec) {
+    throw new HttpTransportError(
+      `Envelope timestamp out of skew: ${diff}s > ${skewSec}s`,
+      "ENVELOPE_TIMESTAMP_SKEW",
+      { diff, skewSec, timestamp: envelope.timestamp, now: nowSec }
+    );
+  }
+  let sigBytes;
+  try {
+    sigBytes = (0, import_utils4.hexToBytes)(envelope.sig);
+  } catch {
+    throw new HttpTransportError(
+      "Envelope signature is not valid hex",
+      "ENVELOPE_SIG_HEX"
+    );
+  }
+  if (sigBytes.length !== 64) {
+    throw new HttpTransportError(
+      `Invalid signature length: ${sigBytes.length} (expected 64)`,
+      "ENVELOPE_SIG_LENGTH",
+      { length: sigBytes.length }
+    );
+  }
+  const { sig: _sig, ...unsigned } = envelope;
+  const digest = (0, import_common6.canonicalHashBytes)(unsigned);
+  const ok = senderPk.verify(sigBytes, digest, { scheme: "schnorr" });
+  if (!ok) {
+    throw new HttpTransportError(
+      "Envelope signature verification failed",
+      "ENVELOPE_SIG_INVALID"
+    );
+  }
+}
+function normalizeMessage(message) {
+  const maybeToJSON = message.toJSON;
+  if (typeof maybeToJSON === "function") {
+    return maybeToJSON.call(message);
+  }
+  return message;
+}
+function normalizeForWire(value) {
+  if (value instanceof Uint8Array) {
+    return { __bytes: (0, import_utils4.bytesToHex)(value) };
+  }
+  if (Array.isArray(value)) {
+    return value.map((v) => normalizeForWire(v));
+  }
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = normalizeForWire(v);
+    }
+    return out;
+  }
+  return value;
+}
+function reviveFromWire(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    const rec = value;
+    const keys = Object.keys(rec);
+    if (keys.length === 1 && keys[0] === "__bytes" && typeof rec.__bytes === "string") {
+      return (0, import_utils4.hexToBytes)(rec.__bytes);
+    }
+    const out = {};
+    for (const [k, v] of Object.entries(rec)) out[k] = reviveFromWire(v);
+    return out;
+  }
+  if (Array.isArray(value)) {
+    return value.map((v) => reviveFromWire(v));
+  }
+  return value;
+}
+
+// src/core/transport/http/request-auth.ts
+var import_common7 = require("@did-btcr2/common");
+var import_utils5 = require("@noble/hashes/utils");
+var REQUEST_AUTH_SCHEME = "BTCR2-Sig";
+function buildRequestAuth(did, keys, path, opts = {}) {
+  const ts = opts.timestamp ?? Math.floor(Date.now() / 1e3);
+  const nonce = opts.nonce ?? (0, import_utils5.bytesToHex)((0, import_utils5.randomBytes)(DEFAULT_NONCE_LEN_BYTES));
+  const digest = (0, import_common7.canonicalHashBytes)({
+    v: HTTP_ENVELOPE_VERSION,
+    did,
+    ts,
+    nonce,
+    path
+  });
+  const sig = keys.secretKey.sign(digest, { scheme: "schnorr" });
+  return `${REQUEST_AUTH_SCHEME} v=${HTTP_ENVELOPE_VERSION},did=${did},ts=${ts},nonce=${nonce},sig=${(0, import_utils5.bytesToHex)(sig)}`;
+}
+
+// src/participant/sse-stream.ts
+async function* parseSseStream(readable) {
+  const decoder = new TextDecoder("utf-8");
+  const reader = readable.getReader();
+  let buffer = "";
+  let pending = {};
+  const dispatchPending = () => {
+    if (pending.data === void 0) {
+      pending = {};
+      return null;
+    }
+    const ev = { data: pending.data };
+    if (pending.event !== void 0) ev.event = pending.event;
+    if (pending.id !== void 0) ev.id = pending.id;
+    if (pending.retry !== void 0) ev.retry = pending.retry;
+    pending = {};
+    return ev;
+  };
+  const processLine = (line) => {
+    if (line.startsWith(":")) return;
+    const colon = line.indexOf(":");
+    const field = colon === -1 ? line : line.slice(0, colon);
+    let value = colon === -1 ? "" : line.slice(colon + 1);
+    if (value.startsWith(" ")) value = value.slice(1);
+    switch (field) {
+      case "data":
+        pending.data = pending.data === void 0 ? value : `${pending.data}
+${value}`;
+        break;
+      case "event":
+        pending.event = value;
+        break;
+      case "id":
+        if (!value.includes("\0")) pending.id = value;
+        break;
+      case "retry": {
+        const n = Number(value);
+        if (Number.isInteger(n) && n >= 0) pending.retry = n;
+        break;
+      }
+    }
+  };
+  try {
+    for (; ; ) {
+      const { value, done } = await reader.read();
+      if (done) {
+        buffer += decoder.decode();
+        if (buffer.length > 0) {
+          const line = buffer.endsWith("\r") ? buffer.slice(0, -1) : buffer;
+          if (line.length > 0) processLine(line);
+          buffer = "";
+        }
+        const tail = dispatchPending();
+        if (tail) yield tail;
+        return;
+      }
+      buffer += decoder.decode(value, { stream: true });
+      let lineEnd = buffer.indexOf("\n");
+      while (lineEnd !== -1) {
+        let line = buffer.slice(0, lineEnd);
+        if (line.endsWith("\r")) line = line.slice(0, -1);
+        buffer = buffer.slice(lineEnd + 1);
+        if (line.length === 0) {
+          const ev = dispatchPending();
+          if (ev) yield ev;
+        } else {
+          processLine(line);
+        }
+        lineEnd = buffer.indexOf("\n");
+      }
+    }
+  } finally {
+    try {
+      reader.releaseLock();
+    } catch {
+    }
+  }
+}
+
+// src/participant/http-client.ts
+function defaultReconnectBackoff(attempt) {
+  const base = Math.min(1e3 * 2 ** attempt, 3e4);
+  const jitter = base * 0.2 * Math.random();
+  return Math.floor(base + jitter);
+}
+var HttpClientTransport = class {
+  name = "http";
+  #baseUrl;
+  #fetch;
+  #logger;
+  #backoff;
+  #clockSkewSec;
+  #resolveSenderPkFn;
+  #actors = /* @__PURE__ */ new Map();
+  #peers = /* @__PURE__ */ new Map();
+  #started = false;
+  #broadcastAbort;
+  constructor(config) {
+    const base = typeof config.baseUrl === "string" ? new URL(config.baseUrl) : new URL(config.baseUrl.href);
+    if (!base.pathname.endsWith("/")) base.pathname += "/";
+    this.#baseUrl = base;
+    this.#logger = config.logger ?? CONSOLE_LOGGER;
+    this.#backoff = config.reconnectBackoff ?? defaultReconnectBackoff;
+    this.#clockSkewSec = config.clockSkewSec ?? DEFAULT_CLOCK_SKEW_SEC;
+    this.#resolveSenderPkFn = config.resolveSenderPk;
+    const fetchImpl = config.fetchImpl ?? globalThis.fetch;
+    if (typeof fetchImpl !== "function") {
+      throw new HttpTransportError(
+        "No fetch implementation available. Pass config.fetchImpl explicitly.",
+        "NO_FETCH_IMPL"
+      );
+    }
+    this.#fetch = fetchImpl;
+  }
+  start() {
+    if (this.#started) return;
+    this.#started = true;
+    this.#broadcastAbort = new AbortController();
+    this.#runBroadcastLoop(this.#broadcastAbort.signal);
+    for (const [did, entry] of this.#actors) {
+      this.#openInbox(did, entry);
+    }
+  }
+  /**
+   * Tear down all SSE subscriptions and stop reconnect loops. Not part of the
+   * {@link Transport} interface, but needed in tests and whenever a client
+   * wants to cleanly disconnect without unregistering every actor.
+   *
+   * Idempotent. Actors remain registered (re-call {@link start} to resume).
+   */
+  stop() {
+    this.#broadcastAbort?.abort();
+    this.#broadcastAbort = void 0;
+    for (const entry of this.#actors.values()) {
+      entry.inboxAbort?.abort();
+      entry.inboxAbort = void 0;
+    }
+    this.#started = false;
+  }
+  registerActor(did, keys) {
+    const existing = this.#actors.get(did);
+    if (existing?.inboxAbort) existing.inboxAbort.abort();
+    const entry = { keys, handlers: /* @__PURE__ */ new Map() };
+    this.#actors.set(did, entry);
+    if (this.#started) this.#openInbox(did, entry);
+  }
+  unregisterActor(did) {
+    const entry = this.#actors.get(did);
+    if (!entry) return;
+    entry.inboxAbort?.abort();
+    this.#actors.delete(did);
+    this.#peers.delete(did);
+  }
+  getActorPk(did) {
+    return this.#actors.get(did)?.keys.publicKey.compressed;
+  }
+  registerPeer(did, communicationPk) {
+    try {
+      new import_keypair3.CompressedSecp256k1PublicKey(communicationPk);
+    } catch {
+      throw new HttpTransportError(
+        `Invalid communication public key for peer ${did}: expected a 33-byte compressed secp256k1 key.`,
+        "INVALID_PEER_KEY",
+        { did, keyLength: communicationPk.length }
+      );
+    }
+    this.#peers.set(did, communicationPk);
+  }
+  getPeerPk(did) {
+    return this.#peers.get(did);
+  }
+  registerMessageHandler(actorDid, messageType, handler) {
+    const actor = this.#actors.get(actorDid);
+    if (!actor) {
+      throw new HttpTransportError(
+        `Cannot register handler: actor ${actorDid} not registered. Call registerActor() first.`,
+        "UNKNOWN_ACTOR",
+        { did: actorDid }
+      );
+    }
+    actor.handlers.set(messageType, handler);
+  }
+  unregisterMessageHandler(actorDid, messageType) {
+    this.#actors.get(actorDid)?.handlers.delete(messageType);
+  }
+  async sendMessage(message, sender, recipient) {
+    const actor = this.#actors.get(sender);
+    if (!actor) {
+      throw new HttpTransportError(
+        `Unknown sender: ${sender}. Call registerActor() before sending messages.`,
+        "UNKNOWN_SENDER",
+        { did: sender }
+      );
+    }
+    const envelope = signEnvelope(
+      message,
+      { did: sender, keys: actor.keys },
+      { to: recipient }
+    );
+    const url = this.#route(HTTP_ROUTE.MESSAGES);
+    const res = await this.#fetch(url, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(envelope)
+    });
+    if (!res.ok) {
+      const body = await safeText(res);
+      throw new HttpTransportError(
+        `sendMessage failed: HTTP ${res.status}`,
+        "SEND_MESSAGE_HTTP",
+        { status: res.status, body: body.slice(0, 256), messageType: message.type }
+      );
+    }
+  }
+  publishRepeating(message, sender, intervalMs, recipient) {
+    let stopped = false;
+    const attempt = () => {
+      if (stopped) return;
+      this.sendMessage(message, sender, recipient).catch((err) => {
+        this.#logger.debug("publishRepeating send failed:", err);
+      });
+    };
+    attempt();
+    const timer = setInterval(attempt, intervalMs);
+    return () => {
+      if (stopped) return;
+      stopped = true;
+      clearInterval(timer);
+    };
+  }
+  #route(template) {
+    return new URL(template.replace(/^\//, ""), this.#baseUrl);
+  }
+  #openInbox(did, entry) {
+    const abort = new AbortController();
+    entry.inboxAbort = abort;
+    this.#runInboxLoop(did, entry, abort.signal);
+  }
+  async #runBroadcastLoop(signal) {
+    const url = this.#route(HTTP_ROUTE.ADVERTS);
+    let attempt = 0;
+    while (!signal.aborted) {
+      try {
+        const res = await this.#fetch(url, {
+          method: "GET",
+          headers: { accept: "text/event-stream" },
+          signal
+        });
+        if (!res.ok || !res.body) {
+          this.#logger.warn(`Broadcast subscribe failed: HTTP ${res.status}`);
+          await sleep(this.#backoff(attempt++), signal);
+          continue;
+        }
+        attempt = 0;
+        for await (const ev of parseSseStream(res.body)) {
+          if (signal.aborted) return;
+          if (ev.event !== SSE_EVENT.ADVERT) continue;
+          this.#dispatchBroadcast(ev.data);
+        }
+      } catch (err) {
+        if (signal.aborted) return;
+        this.#logger.debug("Broadcast loop error:", err);
+        try {
+          await sleep(this.#backoff(attempt++), signal);
+        } catch {
+          return;
+        }
+      }
+    }
+  }
+  async #runInboxLoop(did, entry, signal) {
+    const url = this.#route(HTTP_ROUTE.ACTOR_INBOX.replace("{did}", encodeURIComponent(did)));
+    let attempt = 0;
+    while (!signal.aborted) {
+      try {
+        const auth = buildRequestAuth(did, entry.keys, url.pathname);
+        const res = await this.#fetch(url, {
+          method: "GET",
+          headers: { accept: "text/event-stream", authorization: auth },
+          signal
+        });
+        if (!res.ok || !res.body) {
+          this.#logger.warn(`Inbox subscribe failed for ${did}: HTTP ${res.status}`);
+          await sleep(this.#backoff(attempt++), signal);
+          continue;
+        }
+        attempt = 0;
+        for await (const ev of parseSseStream(res.body)) {
+          if (signal.aborted) return;
+          if (ev.event !== SSE_EVENT.MESSAGE) continue;
+          await this.#dispatchInbox(ev.data, did, entry);
+        }
+      } catch (err) {
+        if (signal.aborted) return;
+        this.#logger.debug(`Inbox loop error for ${did}:`, err);
+        try {
+          await sleep(this.#backoff(attempt++), signal);
+        } catch {
+          return;
+        }
+      }
+    }
+  }
+  #dispatchBroadcast(dataJson) {
+    const envelope = parseEnvelope(dataJson, this.#logger);
+    if (!envelope) return;
+    const senderPk = this.#resolveSenderPk(envelope.from);
+    if (!senderPk) {
+      this.#logger.debug(`Broadcast from unresolvable DID: ${envelope.from}`);
+      return;
+    }
+    try {
+      verifyEnvelope(envelope, senderPk, { clockSkewSec: this.#clockSkewSec });
+    } catch (err) {
+      this.#logger.debug("Broadcast envelope verification failed:", err);
+      return;
+    }
+    const revived = reviveFromWire(envelope.message);
+    const flat = flattenMessage(revived);
+    const messageType = typeof flat.type === "string" ? flat.type : void 0;
+    if (!messageType) return;
+    for (const actor of this.#actors.values()) {
+      const handler = actor.handlers.get(messageType);
+      if (handler) void Promise.resolve(handler(flat));
+    }
+  }
+  async #dispatchInbox(dataJson, actorDid, entry) {
+    const envelope = parseEnvelope(dataJson, this.#logger);
+    if (!envelope) return;
+    const senderPk = this.#resolveSenderPk(envelope.from);
+    if (!senderPk) {
+      this.#logger.debug(`Inbox message from unresolvable DID: ${envelope.from}`);
+      return;
+    }
+    try {
+      verifyEnvelope(envelope, senderPk, {
+        clockSkewSec: this.#clockSkewSec,
+        expectedTo: actorDid
+      });
+    } catch (err) {
+      this.#logger.debug(`Inbox envelope verification failed for ${actorDid}:`, err);
+      return;
+    }
+    const revived = reviveFromWire(envelope.message);
+    const flat = flattenMessage(revived);
+    const messageType = typeof flat.type === "string" ? flat.type : void 0;
+    if (!messageType) return;
+    const handler = entry.handlers.get(messageType);
+    if (handler) await handler(flat);
+  }
+  #resolveSenderPk(did) {
+    const peerBytes = this.#peers.get(did);
+    if (peerBytes) {
+      try {
+        return new import_keypair3.CompressedSecp256k1PublicKey(peerBytes);
+      } catch {
+      }
+    }
+    return this.#resolveSenderPkFn?.(did);
+  }
+};
+function sleep(ms, signal) {
+  if (ms <= 0) return Promise.resolve();
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(new Error("aborted"));
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    if (signal.aborted) onAbort();
+    else signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function safeText(res) {
+  try {
+    return await res.text();
+  } catch {
+    return "";
+  }
+}
+function parseEnvelope(dataJson, logger) {
+  try {
+    return JSON.parse(dataJson);
+  } catch (err) {
+    logger.debug("SSE event: failed to parse envelope JSON:", err);
+    return void 0;
+  }
+}
+function flattenMessage(msg) {
+  if (msg.body && typeof msg.body === "object") {
+    return { ...msg, ...msg.body };
+  }
+  return msg;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AggregationParticipant,
+  AggregationParticipantRunner,
+  HttpClientTransport,
+  defaultReconnectBackoff,
+  parseSseStream
+});