@highway1/core 0.1.48 → 0.1.53

package/dist/index.js

@@ -1,58 +1,21 @@
-import 'path';
-import 'url';
 import * as ed25519 from '@noble/ed25519';
 import { base58btc } from 'multiformats/bases/base58';
-import { createLibp2p } from 'libp2p';
-import { tcp } from '@libp2p/tcp';
-import { setMaxListeners as setMaxListeners$1 } from 'events';
-import { CODE_IP6, CODE_IP4, CODE_P2P, CODE_QUIC_V1, CODE_QUIC, CODE_UDP, CODE_TCP, CODE_DNS4, CODE_DNS6, CODE_DNSADDR, CODE_DNS, CODE_IPCIDR, CODE_IP6ZONE, CODE_WS, CODE_SNI, CODE_TLS, CODE_WSS, CODE_CERTHASH, CODE_WEBRTC_DIRECT, CODE_WEBTRANSPORT, CODE_P2P_CIRCUIT, CODE_WEBRTC, CODE_HTTP, CODE_HTTPS, CODE_MEMORY, CODE_UNIX, multiaddr } from '@multiformats/multiaddr';
-import http from 'http';
-import https from 'https';
-import net, { isIPv4, isIPv6 } from 'net';
-import { allocUnsafe, alloc } from 'uint8arrays/alloc';
-import { concat } from 'uint8arrays/concat';
-import { equals } from 'uint8arrays/equals';
-import os from 'os';
-import * as ws from 'ws';
-import { fromString } from 'uint8arrays/from-string';
-import { noise } from '@chainsafe/libp2p-noise';
-import { mplex } from '@libp2p/mplex';
-import { kadDHT, passthroughMapper } from '@libp2p/kad-dht';
-import { bootstrap } from '@libp2p/bootstrap';
-import { identify } from '@libp2p/identify';
-import { ping } from '@libp2p/ping';
-import { circuitRelayTransport, circuitRelayServer } from '@libp2p/circuit-relay-v2';
-import Ajv from 'ajv';
+import { WebSocket } from 'ws';
 import { encode, decode } from 'cbor-x';
-import { toString } from 'uint8arrays/to-string';
+import Ajv from 'ajv';
 import lunr from 'lunr';
 import Fuse from 'fuse.js';
-import { peerIdFromString } from '@libp2p/peer-id';
 import { Level } from 'level';
 import { sha256 } from '@noble/hashes/sha256';
 import { bytesToHex } from '@noble/hashes/utils';
 
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var init_esm_shims = __esm({
-  "../../node_modules/.pnpm/tsup@8.5.1_postcss@8.5.6_tsx@4.21.0_typescript@5.9.3/node_modules/tsup/assets/esm_shims.js"() {
-  }
-});
-
-// src/index.ts
-init_esm_shims();
-
 // src/identity/keys.ts
-init_esm_shims();
 
 // src/utils/errors.ts
-init_esm_shims();
 var ClawiverseError = class extends Error {
-  constructor(message, code2, details) {
+  constructor(message, code, details) {
     super(message);
-    this.code = code2;
+    this.code = code;
     this.details = details;
     this.name = "ClawiverseError";
   }
@@ -121,9 +84,6 @@ function importKeyPair(exported) {
     privateKey: new Uint8Array(Buffer.from(exported.privateKey, "hex"))
   };
 }
-
-// src/identity/did.ts
-init_esm_shims();
 function deriveDID(publicKey) {
   try {
     const encoded = base58btc.encode(publicKey);
@@ -157,7 +117,6 @@ function validateDID(did) {
 }
 
 // src/identity/signer.ts
-init_esm_shims();
 async function signMessage(payload, privateKey, publicKey) {
   try {
     const signature = await sign(payload, privateKey);
@@ -187,2827 +146,360 @@ async function verifyMessage(signedMessage, expectedPublicKey) {
   }
 }
 
-// src/transport/node.ts
-init_esm_shims();
-
-// ../../node_modules/.pnpm/@libp2p+websockets@10.1.5/node_modules/@libp2p/websockets/dist/src/index.js
-init_esm_shims();
-
-// ../../node_modules/.pnpm/@libp2p+interface@3.1.0/node_modules/@libp2p/interface/dist/src/index.js
-init_esm_shims();
-
-// ../../node_modules/.pnpm/@libp2p+interface@3.1.0/node_modules/@libp2p/interface/dist/src/errors.js
-init_esm_shims();
-var InvalidParametersError = class extends Error {
-  static name = "InvalidParametersError";
-  constructor(message = "Invalid parameters") {
-    super(message);
-    this.name = "InvalidParametersError";
-  }
-};
-var ConnectionFailedError = class extends Error {
-  static name = "ConnectionFailedError";
-  constructor(message = "Connection failed") {
-    super(message);
-    this.name = "ConnectionFailedError";
-  }
-};
-var StreamResetError = class extends Error {
-  static name = "StreamResetError";
-  constructor(message = "The stream has been reset") {
-    super(message);
-    this.name = "StreamResetError";
-  }
-};
-var StreamStateError = class extends Error {
-  static name = "StreamStateError";
-  constructor(message = "The stream is in an invalid state") {
-    super(message);
-    this.name = "StreamStateError";
-  }
-};
-var StreamBufferError = class extends Error {
-  static name = "StreamBufferError";
-  constructor(message = "The stream buffer was full") {
-    super(message);
-    this.name = "StreamBufferError";
-  }
-};
-
-// ../../node_modules/.pnpm/@libp2p+interface@3.1.0/node_modules/@libp2p/interface/dist/src/events.js
-init_esm_shims();
-var StreamMessageEvent = class extends Event {
-  data;
-  constructor(data, eventInitDict) {
-    super("message", eventInitDict);
-    this.data = data;
-  }
-};
-var StreamCloseEvent = class extends Event {
-  error;
-  local;
-  constructor(local, error, eventInitDict) {
-    super("close", eventInitDict);
-    this.error = error;
-    this.local = local;
-  }
-};
-var StreamAbortEvent = class extends StreamCloseEvent {
-  constructor(error, eventInitDict) {
-    super(true, error, eventInitDict);
-  }
-};
-var StreamResetEvent = class extends StreamCloseEvent {
-  constructor(error, eventInitDict) {
-    super(false, error, eventInitDict);
-  }
-};
-
-// ../../node_modules/.pnpm/@libp2p+interface@3.1.0/node_modules/@libp2p/interface/dist/src/transport.js
-init_esm_shims();
-var transportSymbol = /* @__PURE__ */ Symbol.for("@libp2p/transport");
-var FaultTolerance;
-(function(FaultTolerance2) {
-  FaultTolerance2[FaultTolerance2["FATAL_ALL"] = 0] = "FATAL_ALL";
-  FaultTolerance2[FaultTolerance2["NO_FATAL"] = 1] = "NO_FATAL";
-})(FaultTolerance || (FaultTolerance = {}));
-
-// ../../node_modules/.pnpm/main-event@1.0.1/node_modules/main-event/dist/src/index.js
-init_esm_shims();
-
-// ../../node_modules/.pnpm/main-event@1.0.1/node_modules/main-event/dist/src/events.js
-init_esm_shims();
-var setMaxListeners = (n, ...eventTargets) => {
-  try {
-    setMaxListeners$1(n, ...eventTargets);
-  } catch {
+// src/utils/logger.ts
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
+  LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
+  return LogLevel2;
+})(LogLevel || {});
+var Logger = class {
+  level;
+  prefix;
+  constructor(prefix, level = 1 /* INFO */) {
+    this.prefix = prefix;
+    this.level = level;
   }
-};
-
-// ../../node_modules/.pnpm/main-event@1.0.1/node_modules/main-event/dist/src/index.js
-var TypedEventEmitter = class extends EventTarget {
-  #listeners = /* @__PURE__ */ new Map();
-  constructor() {
-    super();
-    setMaxListeners(Infinity, this);
-  }
-  listenerCount(type) {
-    const listeners = this.#listeners.get(type);
-    if (listeners == null) {
-      return 0;
-    }
-    return listeners.length;
-  }
-  addEventListener(type, listener, options) {
-    super.addEventListener(type, listener, options);
-    let list = this.#listeners.get(type);
-    if (list == null) {
-      list = [];
-      this.#listeners.set(type, list);
-    }
-    list.push({
-      callback: listener,
-      once: (options !== true && options !== false && options?.once) ?? false
-    });
+  setLevel(level) {
+    this.level = level;
   }
-  removeEventListener(type, listener, options) {
-    super.removeEventListener(type.toString(), listener ?? null, options);
-    let list = this.#listeners.get(type);
-    if (list == null) {
-      return;
-    }
-    list = list.filter(({ callback }) => callback !== listener);
-    this.#listeners.set(type, list);
-  }
-  dispatchEvent(event) {
-    const result = super.dispatchEvent(event);
-    let list = this.#listeners.get(event.type);
-    if (list == null) {
-      return result;
+  debug(message, ...args) {
+    if (this.level <= 0 /* DEBUG */) {
+      console.debug(`[${this.prefix}] DEBUG:`, message, ...args);
     }
-    list = list.filter(({ once }) => !once);
-    this.#listeners.set(event.type, list);
-    return result;
-  }
-  safeDispatchEvent(type, detail = {}) {
-    return this.dispatchEvent(new CustomEvent(type, detail));
   }
-};
-
-// ../../node_modules/.pnpm/@libp2p+interface@3.1.0/node_modules/@libp2p/interface/dist/src/index.js
-var serviceCapabilities = /* @__PURE__ */ Symbol.for("@libp2p/service-capabilities");
-
-// ../../node_modules/.pnpm/@multiformats+multiaddr-matcher@3.0.1/node_modules/@multiformats/multiaddr-matcher/dist/src/index.js
-init_esm_shims();
-
-// ../../node_modules/.pnpm/@multiformats+multiaddr-matcher@3.0.1/node_modules/@multiformats/multiaddr-matcher/dist/src/utils.js
-init_esm_shims();
-var code = (code2) => {
-  return {
-    match: (vals) => {
-      const component = vals[0];
-      if (component == null) {
-        return false;
-      }
-      if (component.code !== code2) {
-        return false;
-      }
-      if (component.value != null) {
-        return false;
-      }
-      return vals.slice(1);
-    }
-  };
-};
-var value = (code2, value2) => {
-  return {
-    match: (vals) => {
-      const component = vals[0];
-      if (component?.code !== code2) {
-        return false;
-      }
-      if (component.value == null) {
-        return false;
-      }
-      if (value2 != null && component.value !== value2) {
-        return false;
-      }
-      return vals.slice(1);
-    }
-  };
-};
-var not = (matcher) => {
-  return {
-    match: (vals) => {
-      const result = matcher.match(vals);
-      if (result === false) {
-        return vals;
-      }
-      return false;
-    }
-  };
-};
-var optional = (matcher) => {
-  return {
-    match: (vals) => {
-      const result = matcher.match(vals);
-      if (result === false) {
-        return vals;
-      }
-      return result;
-    }
-  };
-};
-var or = (...matchers) => {
-  return {
-    match: (vals) => {
-      let matches;
-      for (const matcher of matchers) {
-        const result = matcher.match(vals);
-        if (result === false) {
-          continue;
-        }
-        if (matches == null || result.length < matches.length) {
-          matches = result;
-        }
-      }
-      if (matches == null) {
-        return false;
-      }
-      return matches;
-    }
-  };
-};
-var and = (...matchers) => {
-  return {
-    match: (vals) => {
-      for (const matcher of matchers) {
-        const result = matcher.match(vals);
-        if (result === false) {
-          return false;
-        }
-        vals = result;
-      }
-      return vals;
-    }
-  };
-};
-function fmt(...matchers) {
-  function match(ma) {
-    if (ma == null) {
-      return false;
-    }
-    let parts = ma.getComponents();
-    for (const matcher of matchers) {
-      const result = matcher.match(parts);
-      if (result === false) {
-        return false;
-      }
-      parts = result;
+  info(message, ...args) {
+    if (this.level <= 1 /* INFO */) {
+      console.info(`[${this.prefix}] INFO:`, message, ...args);
     }
-    return parts;
   }
-  function matches(ma) {
-    const result = match(ma);
-    return result !== false;
-  }
-  function exactMatch(ma) {
-    const result = match(ma);
-    if (result === false) {
-      return false;
+  warn(message, ...args) {
+    if (this.level <= 2 /* WARN */) {
+      console.warn(`[${this.prefix}] WARN:`, message, ...args);
     }
-    return result.length === 0;
-  }
-  return {
-    matchers,
-    matches,
-    exactMatch
-  };
-}
-
-// ../../node_modules/.pnpm/@multiformats+multiaddr-matcher@3.0.1/node_modules/@multiformats/multiaddr-matcher/dist/src/index.js
-var _PEER_ID = value(CODE_P2P);
-fmt(_PEER_ID);
-var _DNS4 = value(CODE_DNS4);
-var _DNS6 = value(CODE_DNS6);
-var _DNSADDR = value(CODE_DNSADDR);
-var _DNS = value(CODE_DNS);
-fmt(_DNS4, optional(value(CODE_P2P)));
-fmt(_DNS6, optional(value(CODE_P2P)));
-fmt(_DNSADDR, optional(value(CODE_P2P)));
-fmt(or(_DNS, _DNSADDR, _DNS4, _DNS6), optional(value(CODE_P2P)));
-var _IP4 = and(value(CODE_IP4), optional(value(CODE_IPCIDR)));
-var _IP6 = and(optional(value(CODE_IP6ZONE)), value(CODE_IP6), optional(value(CODE_IPCIDR)));
-var _IP = or(_IP4, _IP6);
-var _IP_OR_DOMAIN = or(_IP, _DNS, _DNS4, _DNS6, _DNSADDR);
-fmt(or(_IP, and(or(_DNS, _DNSADDR, _DNS4, _DNS6), optional(value(CODE_P2P)))));
-fmt(_IP4);
-fmt(_IP6);
-fmt(_IP);
-var _TCP = and(_IP_OR_DOMAIN, value(CODE_TCP));
-var _UDP = and(_IP_OR_DOMAIN, value(CODE_UDP));
-fmt(and(_TCP, optional(value(CODE_P2P))));
-fmt(_UDP);
-var _QUIC = and(_UDP, code(CODE_QUIC), optional(value(CODE_P2P)));
-var _QUIC_V1 = and(_UDP, code(CODE_QUIC_V1), optional(value(CODE_P2P)));
-var QUIC_V0_OR_V1 = or(_QUIC, _QUIC_V1);
-fmt(_QUIC);
-fmt(_QUIC_V1);
-var _WEB = or(_IP_OR_DOMAIN, _TCP, _UDP, _QUIC, _QUIC_V1);
-var _WebSockets = or(and(_WEB, code(CODE_WS), optional(value(CODE_P2P))));
-var WebSockets = fmt(_WebSockets);
-var _WebSocketsSecure = or(and(_WEB, code(CODE_WSS), optional(value(CODE_P2P))), and(_WEB, code(CODE_TLS), optional(value(CODE_SNI)), code(CODE_WS), optional(value(CODE_P2P))));
-var WebSocketsSecure = fmt(_WebSocketsSecure);
-var _WebRTCDirect = and(_UDP, code(CODE_WEBRTC_DIRECT), optional(value(CODE_CERTHASH)), optional(value(CODE_CERTHASH)), optional(value(CODE_P2P)));
-fmt(_WebRTCDirect);
-var _WebTransport = and(_QUIC_V1, code(CODE_WEBTRANSPORT), optional(value(CODE_CERTHASH)), optional(value(CODE_CERTHASH)), optional(value(CODE_P2P)));
-fmt(_WebTransport);
-var _P2P = or(_WebSockets, _WebSocketsSecure, and(_TCP, optional(value(CODE_P2P))), and(QUIC_V0_OR_V1, optional(value(CODE_P2P))), and(_IP_OR_DOMAIN, optional(value(CODE_P2P))), _WebRTCDirect, _WebTransport, value(CODE_P2P));
-fmt(_P2P);
-var _Circuit = and(optional(_P2P), code(CODE_P2P_CIRCUIT), not(code(CODE_WEBRTC)), optional(value(CODE_P2P)));
-fmt(_Circuit);
-var _WebRTC = or(and(_P2P, code(CODE_P2P_CIRCUIT), code(CODE_WEBRTC), optional(value(CODE_P2P))), and(_P2P, code(CODE_WEBRTC), optional(value(CODE_P2P))), and(code(CODE_WEBRTC), optional(value(CODE_P2P))));
-fmt(_WebRTC);
-var _HTTP = or(and(_IP_OR_DOMAIN, value(CODE_TCP), code(CODE_HTTP), optional(value(CODE_P2P))), and(_IP_OR_DOMAIN, code(CODE_HTTP), optional(value(CODE_P2P))));
-fmt(_HTTP);
-var _HTTPS = and(_IP_OR_DOMAIN, or(and(value(CODE_TCP, "443"), code(CODE_HTTP)), and(value(CODE_TCP), code(CODE_HTTPS)), and(value(CODE_TCP), code(CODE_TLS), code(CODE_HTTP)), and(code(CODE_TLS), code(CODE_HTTP)), code(CODE_TLS), code(CODE_HTTPS)), optional(value(CODE_P2P)));
-fmt(_HTTPS);
-var _Memory = or(and(value(CODE_MEMORY), optional(value(CODE_P2P))));
-fmt(_Memory);
-var _Unix = or(and(value(CODE_UNIX), optional(value(CODE_P2P))));
-fmt(_Unix);
-
-// ../../node_modules/.pnpm/@multiformats+multiaddr-to-uri@12.0.0/node_modules/@multiformats/multiaddr-to-uri/dist/src/index.js
-init_esm_shims();
-var ASSUME_HTTP_CODES = [
-  CODE_TCP,
-  CODE_DNS,
-  CODE_DNSADDR,
-  CODE_DNS4,
-  CODE_DNS6
-];
-function extractSNI(ma) {
-  return extractTuple("sni", ma)?.value;
-}
-function extractPort(ma) {
-  const port = extractTuple("tcp", ma)?.value;
-  if (port == null) {
-    return "";
   }
-  return `:${port}`;
-}
-function extractTuple(name, ma) {
-  return ma.find((component) => component.name === name);
-}
-function hasTLS(ma) {
-  return ma.some(({ code: code2 }) => code2 === CODE_TLS);
-}
-function interpretNext(head, rest) {
-  const interpreter = interpreters[head.name];
-  if (interpreter == null) {
-    throw new Error(`Can't interpret protocol ${head.name}`);
-  }
-  const restVal = interpreter(head, rest);
-  if (head.code === CODE_IP6) {
-    return `[${restVal}]`;
-  }
-  return restVal;
-}
-var interpreters = {
-  ip4: (head, rest) => head.value,
-  ip6: (head, rest) => {
-    if (rest.length === 0) {
-      return head.value;
-    }
-    return `[${head.value}]`;
-  },
-  tcp: (head, rest) => {
-    const tail = rest.pop();
-    if (tail == null) {
-      throw new Error("Unexpected end of multiaddr");
-    }
-    return `tcp://${interpretNext(tail, rest)}:${head.value}`;
-  },
-  udp: (head, rest) => {
-    const tail = rest.pop();
-    if (tail == null) {
-      throw new Error("Unexpected end of multiaddr");
-    }
-    return `udp://${interpretNext(tail, rest)}:${head.value}`;
-  },
-  dnsaddr: (head, rest) => head.value,
-  dns4: (head, rest) => head.value,
-  dns6: (head, rest) => head.value,
-  dns: (head, rest) => head.value,
-  ipfs: (head, rest) => {
-    const tail = rest.pop();
-    if (tail == null) {
-      throw new Error("Unexpected end of multiaddr");
-    }
-    return `${interpretNext(tail, rest)}`;
-  },
-  p2p: (head, rest) => {
-    const tail = rest.pop();
-    if (tail == null) {
-      throw new Error("Unexpected end of multiaddr");
-    }
-    return `${interpretNext(tail, rest)}`;
-  },
-  http: (head, rest) => {
-    const maHasTLS = hasTLS(rest);
-    const sni = extractSNI(rest);
-    const port = extractPort(rest);
-    if (maHasTLS && sni != null) {
-      return `https://${sni}${port}`;
-    }
-    const protocol = maHasTLS ? "https://" : "http://";
-    const tail = rest.pop();
-    if (tail == null) {
-      throw new Error("Unexpected end of multiaddr");
-    }
-    let baseVal = interpretNext(tail, rest);
-    baseVal = baseVal?.replace("tcp://", "");
-    return `${protocol}${baseVal}`;
-  },
-  "http-path": (head, rest) => {
-    const tail = rest.pop();
-    if (tail == null) {
-      throw new Error("Unexpected end of multiaddr");
-    }
-    const baseVal = interpretNext(tail, rest);
-    const decodedValue = decodeURIComponent(head.value ?? "");
-    return `${baseVal}${decodedValue}`;
-  },
-  tls: (head, rest) => {
-    const tail = rest.pop();
-    if (tail == null) {
-      throw new Error("Unexpected end of multiaddr");
-    }
-    return interpretNext(tail, rest);
-  },
-  sni: (head, rest) => {
-    const tail = rest.pop();
-    if (tail == null) {
-      throw new Error("Unexpected end of multiaddr");
-    }
-    return interpretNext(tail, rest);
-  },
-  https: (head, rest) => {
-    const tail = rest.pop();
-    if (tail == null) {
-      throw new Error("Unexpected end of multiaddr");
-    }
-    let baseVal = interpretNext(tail, rest);
-    baseVal = baseVal?.replace("tcp://", "");
-    return `https://${baseVal}`;
-  },
-  ws: (head, rest) => {
-    const maHasTLS = hasTLS(rest);
-    const sni = extractSNI(rest);
-    const port = extractPort(rest);
-    if (maHasTLS && sni != null) {
-      return `wss://${sni}${port}`;
-    }
-    const protocol = maHasTLS ? "wss://" : "ws://";
-    const tail = rest.pop();
-    if (tail == null) {
-      throw new Error("Unexpected end of multiaddr");
-    }
-    let baseVal = interpretNext(tail, rest);
-    baseVal = baseVal?.replace("tcp://", "");
-    return `${protocol}${baseVal}`;
-  },
-  wss: (head, rest) => {
-    const tail = rest.pop();
-    if (tail == null) {
-      throw new Error("Unexpected end of multiaddr");
+  error(message, ...args) {
+    if (this.level <= 3 /* ERROR */) {
+      console.error(`[${this.prefix}] ERROR:`, message, ...args);
     }
-    let baseVal = interpretNext(tail, rest);
-    baseVal = baseVal?.replace("tcp://", "");
-    return `wss://${baseVal}`;
   }
 };
-function multiaddrToUri(input, opts) {
-  const ma = multiaddr(input);
-  const components = ma.getComponents();
-  const head = components.pop();
-  if (head == null) {
-    throw new Error("Unexpected end of multiaddr");
-  }
-  const interpreter = interpreters[head.name];
-  if (interpreter == null) {
-    throw new Error(`No interpreter found for ${head.name}`);
-  }
-  let uri = interpreter(head, components) ?? "";
-  if (ASSUME_HTTP_CODES.includes(head.code)) {
-    uri = uri.replace(/^.*:\/\//, "");
-    if (head.value === "443") {
-      uri = `https://${uri}`;
-    } else {
-      uri = `http://${uri}`;
-    }
-  }
-  if (uri.startsWith("http://") || uri.startsWith("https://") || uri.startsWith("ws://") || uri.startsWith("wss://")) {
-    uri = new URL(uri).toString();
-    if (uri.endsWith("/")) {
-      uri = uri.substring(0, uri.length - 1);
-    }
-  }
-  return uri;
-}
-
-// ../../node_modules/.pnpm/p-event@7.1.0/node_modules/p-event/index.js
-init_esm_shims();
+var createLogger = (prefix, level) => {
+  return new Logger(prefix, level);
+};
 
-// ../../node_modules/.pnpm/p-timeout@7.0.1/node_modules/p-timeout/index.js
-init_esm_shims();
-var TimeoutError = class _TimeoutError extends Error {
-  name = "TimeoutError";
-  constructor(message, options) {
-    super(message, options);
-    Error.captureStackTrace?.(this, _TimeoutError);
-  }
+// src/transport/relay-client.ts
+var logger = createLogger("relay-client");
+var DEFAULT_RECONNECT = {
+  baseMs: 1e3,
+  jitterMs: 2e3,
+  maxDelayMs: 3e4,
+  stableAfterMs: 6e4
 };
-var getAbortedReason = (signal) => signal.reason ?? new DOMException("This operation was aborted.", "AbortError");
-function pTimeout(promise, options) {
-  const {
-    milliseconds,
-    fallback,
-    message,
-    customTimers = { setTimeout, clearTimeout },
-    signal
-  } = options;
-  let timer;
-  let abortHandler;
-  const wrappedPromise = new Promise((resolve, reject) => {
-    if (typeof milliseconds !== "number" || Math.sign(milliseconds) !== 1) {
-      throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
-    }
-    if (signal?.aborted) {
-      reject(getAbortedReason(signal));
-      return;
-    }
-    if (signal) {
-      abortHandler = () => {
-        reject(getAbortedReason(signal));
-      };
-      signal.addEventListener("abort", abortHandler, { once: true });
-    }
-    promise.then(resolve, reject);
-    if (milliseconds === Number.POSITIVE_INFINITY) {
-      return;
-    }
-    const timeoutError = new TimeoutError();
-    timer = customTimers.setTimeout.call(void 0, () => {
-      if (fallback) {
+function createRelayClient(config) {
+  const { relayUrls, did, keyPair, card } = config;
+  const reconnectConfig = { ...DEFAULT_RECONNECT, ...config.reconnect };
+  const connections = relayUrls.map((url) => ({
+    url,
+    ws: null,
+    connected: false,
+    reconnectAttempt: 0,
+    reconnectTimer: null,
+    stableTimer: null,
+    pingTimer: null,
+    peerCount: 0
+  }));
+  let deliveryHandler = null;
+  let deliveryReportHandler = null;
+  let stopped = false;
+  async function connectToRelay(conn) {
+    if (stopped) return;
+    try {
+      logger.info("Connecting to relay", { url: conn.url });
+      const ws = new WebSocket(conn.url);
+      conn.ws = ws;
+      await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          reject(new Error("Connection timeout"));
+        }, 1e4);
+        ws.on("open", async () => {
+          clearTimeout(timeout);
+          logger.info("WebSocket connected", { url: conn.url });
+          try {
+            const timestamp = Date.now();
+            const helloData = encode({ did, card, timestamp });
+            const signature = await sign(helloData, keyPair.privateKey);
+            const hello = {
+              type: "HELLO",
+              protocolVersion: 1,
+              did,
+              card,
+              timestamp,
+              signature
+            };
+            ws.send(encode(hello));
+            resolve();
+          } catch (err) {
+            reject(err);
+          }
+        });
+        ws.on("error", (err) => {
+          clearTimeout(timeout);
+          reject(err);
+        });
+      });
+      ws.on("message", async (data) => {
         try {
-          resolve(fallback());
-        } catch (error) {
-          reject(error);
+          const msg = decode(data);
+          await handleRelayMessage(conn, msg);
+        } catch (err) {
+          logger.warn("Failed to parse relay message", { error: err.message });
         }
-        return;
-      }
-      if (typeof promise.cancel === "function") {
-        promise.cancel();
-      }
-      if (message === false) {
-        resolve();
-      } else if (message instanceof Error) {
-        reject(message);
-      } else {
-        timeoutError.message = message ?? `Promise timed out after ${milliseconds} milliseconds`;
-        reject(timeoutError);
+      });
+      ws.on("close", () => {
+        logger.info("WebSocket closed", { url: conn.url });
+        conn.connected = false;
+        conn.ws = null;
+        if (conn.stableTimer) {
+          clearTimeout(conn.stableTimer);
+          conn.stableTimer = null;
+        }
+        if (conn.pingTimer) {
+          clearInterval(conn.pingTimer);
+          conn.pingTimer = null;
+        }
+        if (!stopped) {
+          scheduleReconnect(conn);
+        }
+      });
+      ws.on("error", (err) => {
+        logger.warn("WebSocket error", { url: conn.url, error: err.message });
+      });
+    } catch (err) {
+      logger.warn("Failed to connect to relay", { url: conn.url, error: err.message });
+      conn.ws = null;
+      conn.connected = false;
+      if (!stopped) {
+        scheduleReconnect(conn);
       }
-    }, milliseconds);
-  });
-  const cancelablePromise = wrappedPromise.finally(() => {
-    cancelablePromise.clear();
-    if (abortHandler && signal) {
-      signal.removeEventListener("abort", abortHandler);
     }
-  });
-  cancelablePromise.clear = () => {
-    customTimers.clearTimeout.call(void 0, timer);
-    timer = void 0;
-  };
-  return cancelablePromise;
-}
-
-// ../../node_modules/.pnpm/p-event@7.1.0/node_modules/p-event/index.js
-var normalizeEmitter = (emitter) => {
-  const addListener = emitter.addEventListener || emitter.on || emitter.addListener;
-  const removeListener = emitter.removeEventListener || emitter.off || emitter.removeListener;
-  if (!addListener || !removeListener) {
-    throw new TypeError("Emitter is not compatible");
   }
-  return {
-    addListener: addListener.bind(emitter),
-    removeListener: removeListener.bind(emitter)
-  };
-};
-function pEventMultiple(emitter, event, options) {
-  let cancel;
-  const returnValue = new Promise((resolve, reject) => {
-    options = {
-      rejectionEvents: ["error"],
-      multiArgs: false,
-      rejectionMultiArgs: false,
-      resolveImmediately: false,
-      ...options
-    };
-    if (!(options.count >= 0 && (options.count === Number.POSITIVE_INFINITY || Number.isInteger(options.count)))) {
-      throw new TypeError("The `count` option should be at least 0 or more");
-    }
-    options.signal?.throwIfAborted();
-    const events = [event].flat();
-    const items = [];
-    const { addListener, removeListener } = normalizeEmitter(emitter);
-    const onItem = async (...arguments_) => {
-      const value2 = options.multiArgs ? arguments_ : arguments_[0];
-      if (options.filter) {
-        try {
-          if (!await options.filter(value2)) {
-            return;
+  function scheduleReconnect(conn) {
+    if (conn.reconnectTimer) return;
+    const delay = Math.min(
+      reconnectConfig.baseMs * Math.pow(2, conn.reconnectAttempt) + Math.random() * reconnectConfig.jitterMs,
+      reconnectConfig.maxDelayMs
+    );
+    conn.reconnectAttempt++;
+    logger.debug("Scheduling reconnect", { url: conn.url, attempt: conn.reconnectAttempt, delayMs: delay });
+    conn.reconnectTimer = setTimeout(() => {
+      conn.reconnectTimer = null;
+      connectToRelay(conn);
+    }, delay);
+  }
+  async function handleRelayMessage(conn, msg) {
+    switch (msg.type) {
+      case "WELCOME": {
+        const welcome = msg;
+        logger.info("Received WELCOME", { relayId: welcome.relayId, peers: welcome.peers });
+        conn.connected = true;
+        conn.peerCount = welcome.peers;
+        conn.reconnectAttempt = 0;
+        if (conn.stableTimer) clearTimeout(conn.stableTimer);
+        conn.stableTimer = setTimeout(() => {
+          conn.reconnectAttempt = 0;
+          logger.debug("Connection stable", { url: conn.url });
+        }, reconnectConfig.stableAfterMs);
+        if (conn.pingTimer) clearInterval(conn.pingTimer);
+        conn.pingTimer = setInterval(() => {
+          if (conn.ws && conn.connected) {
+            conn.ws.send(encode({ type: "PING" }));
+            logger.debug("Sent PING", { url: conn.url });
           }
-        } catch (error) {
-          cancel();
-          reject(error);
-          return;
-        }
-      }
-      items.push(value2);
-      if (options.count === items.length) {
-        cancel();
-        resolve(items);
-      }
-    };
-    const rejectHandler = (...arguments_) => {
-      cancel();
-      reject(options.rejectionMultiArgs ? arguments_ : arguments_[0]);
-    };
-    cancel = () => {
-      for (const event2 of events) {
-        removeListener(event2, onItem);
+        }, 3e4);
+        break;
       }
-      for (const rejectionEvent of options.rejectionEvents) {
-        if (!events.includes(rejectionEvent)) {
-          removeListener(rejectionEvent, rejectHandler);
+      case "DELIVER": {
+        const deliver = msg;
+        logger.info("Received DELIVER", { messageId: deliver.messageId, from: deliver.from });
+        if (deliveryHandler) {
+          await deliveryHandler(deliver);
         }
+        if (conn.ws && conn.connected) {
+          conn.ws.send(encode({ type: "ACK", messageId: deliver.messageId }));
+          logger.debug("Sent ACK", { messageId: deliver.messageId });
+        }
+        break;
       }
-    };
-    for (const event2 of events) {
-      addListener(event2, onItem);
-    }
-    for (const rejectionEvent of options.rejectionEvents) {
-      if (!events.includes(rejectionEvent)) {
-        addListener(rejectionEvent, rejectHandler);
-      }
-    }
-    if (options.signal) {
-      options.signal.addEventListener("abort", () => {
-        rejectHandler(options.signal.reason);
-      }, { once: true });
-    }
-    if (options.resolveImmediately) {
-      resolve(items);
-    }
-  });
-  returnValue.cancel = cancel;
-  if (typeof options.timeout === "number") {
-    const timeout = pTimeout(returnValue, { milliseconds: options.timeout });
-    timeout.cancel = () => {
-      cancel();
-      timeout.clear();
-    };
-    return timeout;
-  }
-  return returnValue;
-}
-function pEvent(emitter, event, options) {
-  if (typeof options === "function") {
-    options = { filter: options };
-  }
-  options = {
-    ...options,
-    count: 1,
-    resolveImmediately: false
-  };
-  const arrayPromise = pEventMultiple(emitter, event, options);
-  const promise = arrayPromise.then((array) => array[0]);
-  promise.cancel = arrayPromise.cancel;
-  return promise;
-}
-
-// ../../node_modules/.pnpm/progress-events@1.0.1/node_modules/progress-events/dist/src/index.js
-init_esm_shims();
-var CustomProgressEvent = class extends Event {
-  type;
-  detail;
-  constructor(type, detail) {
-    super(type);
-    this.type = type;
-    this.detail = detail;
-  }
-};
-
-// ../../node_modules/.pnpm/@libp2p+websockets@10.1.5/node_modules/@libp2p/websockets/dist/src/listener.js
-init_esm_shims();
-
-// ../../node_modules/.pnpm/uint8arraylist@2.4.8/node_modules/uint8arraylist/dist/src/index.js
-init_esm_shims();
-var symbol = /* @__PURE__ */ Symbol.for("@achingbrain/uint8arraylist");
-function findBufAndOffset(bufs, index) {
-  if (index == null || index < 0) {
-    throw new RangeError("index is out of bounds");
-  }
-  let offset = 0;
-  for (const buf of bufs) {
-    const bufEnd = offset + buf.byteLength;
-    if (index < bufEnd) {
-      return {
-        buf,
-        index: index - offset
-      };
-    }
-    offset = bufEnd;
-  }
-  throw new RangeError("index is out of bounds");
-}
-function isUint8ArrayList(value2) {
-  return Boolean(value2?.[symbol]);
-}
-var Uint8ArrayList = class _Uint8ArrayList {
-  bufs;
-  length;
-  [symbol] = true;
-  constructor(...data) {
-    this.bufs = [];
-    this.length = 0;
-    if (data.length > 0) {
-      this.appendAll(data);
-    }
-  }
-  *[Symbol.iterator]() {
-    yield* this.bufs;
-  }
-  get byteLength() {
-    return this.length;
-  }
-  /**
-   * Add one or more `bufs` to the end of this Uint8ArrayList
-   */
-  append(...bufs) {
-    this.appendAll(bufs);
-  }
-  /**
-   * Add all `bufs` to the end of this Uint8ArrayList
-   */
-  appendAll(bufs) {
-    let length = 0;
-    for (const buf of bufs) {
-      if (buf instanceof Uint8Array) {
-        length += buf.byteLength;
-        this.bufs.push(buf);
-      } else if (isUint8ArrayList(buf)) {
-        length += buf.byteLength;
-        this.bufs.push(...buf.bufs);
-      } else {
-        throw new Error("Could not append value, must be an Uint8Array or a Uint8ArrayList");
-      }
-    }
-    this.length += length;
-  }
-  /**
-   * Add one or more `bufs` to the start of this Uint8ArrayList
-   */
-  prepend(...bufs) {
-    this.prependAll(bufs);
-  }
-  /**
-   * Add all `bufs` to the start of this Uint8ArrayList
-   */
-  prependAll(bufs) {
-    let length = 0;
-    for (const buf of bufs.reverse()) {
-      if (buf instanceof Uint8Array) {
-        length += buf.byteLength;
-        this.bufs.unshift(buf);
-      } else if (isUint8ArrayList(buf)) {
-        length += buf.byteLength;
-        this.bufs.unshift(...buf.bufs);
-      } else {
-        throw new Error("Could not prepend value, must be an Uint8Array or a Uint8ArrayList");
-      }
-    }
-    this.length += length;
-  }
-  /**
-   * Read the value at `index`
-   */
-  get(index) {
-    const res = findBufAndOffset(this.bufs, index);
-    return res.buf[res.index];
-  }
-  /**
-   * Set the value at `index` to `value`
-   */
-  set(index, value2) {
-    const res = findBufAndOffset(this.bufs, index);
-    res.buf[res.index] = value2;
-  }
-  /**
-   * Copy bytes from `buf` to the index specified by `offset`
-   */
-  write(buf, offset = 0) {
-    if (buf instanceof Uint8Array) {
-      for (let i = 0; i < buf.length; i++) {
-        this.set(offset + i, buf[i]);
-      }
-    } else if (isUint8ArrayList(buf)) {
-      for (let i = 0; i < buf.length; i++) {
-        this.set(offset + i, buf.get(i));
-      }
-    } else {
-      throw new Error("Could not write value, must be an Uint8Array or a Uint8ArrayList");
-    }
-  }
-  /**
-   * Remove bytes from the front of the pool
-   */
-  consume(bytes) {
-    bytes = Math.trunc(bytes);
-    if (Number.isNaN(bytes) || bytes <= 0) {
-      return;
-    }
-    if (bytes === this.byteLength) {
-      this.bufs = [];
-      this.length = 0;
-      return;
-    }
-    while (this.bufs.length > 0) {
-      if (bytes >= this.bufs[0].byteLength) {
-        bytes -= this.bufs[0].byteLength;
-        this.length -= this.bufs[0].byteLength;
-        this.bufs.shift();
-      } else {
-        this.bufs[0] = this.bufs[0].subarray(bytes);
-        this.length -= bytes;
-        break;
-      }
-    }
-  }
-  /**
-   * Extracts a section of an array and returns a new array.
-   *
-   * This is a copy operation as it is with Uint8Arrays and Arrays
-   * - note this is different to the behaviour of Node Buffers.
-   */
-  slice(beginInclusive, endExclusive) {
-    const { bufs, length } = this._subList(beginInclusive, endExclusive);
-    return concat(bufs, length);
-  }
-  /**
-   * Returns a alloc from the given start and end element index.
-   *
-   * In the best case where the data extracted comes from a single Uint8Array
-   * internally this is a no-copy operation otherwise it is a copy operation.
-   */
-  subarray(beginInclusive, endExclusive) {
-    const { bufs, length } = this._subList(beginInclusive, endExclusive);
-    if (bufs.length === 1) {
-      return bufs[0];
-    }
-    return concat(bufs, length);
-  }
-  /**
-   * Returns a allocList from the given start and end element index.
-   *
-   * This is a no-copy operation.
-   */
-  sublist(beginInclusive, endExclusive) {
-    const { bufs, length } = this._subList(beginInclusive, endExclusive);
-    const list = new _Uint8ArrayList();
-    list.length = length;
-    list.bufs = [...bufs];
-    return list;
-  }
-  _subList(beginInclusive, endExclusive) {
-    beginInclusive = beginInclusive ?? 0;
-    endExclusive = endExclusive ?? this.length;
-    if (beginInclusive < 0) {
-      beginInclusive = this.length + beginInclusive;
-    }
-    if (endExclusive < 0) {
-      endExclusive = this.length + endExclusive;
-    }
-    if (beginInclusive < 0 || endExclusive > this.length) {
-      throw new RangeError("index is out of bounds");
-    }
-    if (beginInclusive === endExclusive) {
-      return { bufs: [], length: 0 };
-    }
-    if (beginInclusive === 0 && endExclusive === this.length) {
-      return { bufs: this.bufs, length: this.length };
-    }
-    const bufs = [];
-    let offset = 0;
-    for (let i = 0; i < this.bufs.length; i++) {
-      const buf = this.bufs[i];
-      const bufStart = offset;
-      const bufEnd = bufStart + buf.byteLength;
-      offset = bufEnd;
-      if (beginInclusive >= bufEnd) {
-        continue;
-      }
-      const sliceStartInBuf = beginInclusive >= bufStart && beginInclusive < bufEnd;
-      const sliceEndsInBuf = endExclusive > bufStart && endExclusive <= bufEnd;
-      if (sliceStartInBuf && sliceEndsInBuf) {
-        if (beginInclusive === bufStart && endExclusive === bufEnd) {
-          bufs.push(buf);
-          break;
-        }
-        const start = beginInclusive - bufStart;
-        bufs.push(buf.subarray(start, start + (endExclusive - beginInclusive)));
-        break;
-      }
-      if (sliceStartInBuf) {
-        if (beginInclusive === 0) {
-          bufs.push(buf);
-          continue;
-        }
-        bufs.push(buf.subarray(beginInclusive - bufStart));
-        continue;
-      }
-      if (sliceEndsInBuf) {
-        if (endExclusive === bufEnd) {
-          bufs.push(buf);
-          break;
+      case "DELIVERY_REPORT": {
+        const report = msg;
+        logger.info("Received DELIVERY_REPORT", { messageId: report.messageId, status: report.status });
+        if (deliveryReportHandler) {
+          deliveryReportHandler(report);
         }
-        bufs.push(buf.subarray(0, endExclusive - bufStart));
         break;
-      }
-      bufs.push(buf);
-    }
-    return { bufs, length: endExclusive - beginInclusive };
-  }
-  indexOf(search, offset = 0) {
-    if (!isUint8ArrayList(search) && !(search instanceof Uint8Array)) {
-      throw new TypeError('The "value" argument must be a Uint8ArrayList or Uint8Array');
-    }
-    const needle = search instanceof Uint8Array ? search : search.subarray();
-    offset = Number(offset ?? 0);
-    if (isNaN(offset)) {
-      offset = 0;
-    }
-    if (offset < 0) {
-      offset = this.length + offset;
-    }
-    if (offset < 0) {
-      offset = 0;
-    }
-    if (search.length === 0) {
-      return offset > this.length ? this.length : offset;
-    }
-    const M = needle.byteLength;
-    if (M === 0) {
-      throw new TypeError("search must be at least 1 byte long");
-    }
-    const radix = 256;
-    const rightmostPositions = new Int32Array(radix);
-    for (let c = 0; c < radix; c++) {
-      rightmostPositions[c] = -1;
-    }
-    for (let j = 0; j < M; j++) {
-      rightmostPositions[needle[j]] = j;
-    }
-    const right = rightmostPositions;
-    const lastIndex = this.byteLength - needle.byteLength;
-    const lastPatIndex = needle.byteLength - 1;
-    let skip;
-    for (let i = offset; i <= lastIndex; i += skip) {
-      skip = 0;
-      for (let j = lastPatIndex; j >= 0; j--) {
-        const char = this.get(i + j);
-        if (needle[j] !== char) {
-          skip = Math.max(1, j - right[char]);
-          break;
-        }
-      }
-      if (skip === 0) {
-        return i;
-      }
-    }
-    return -1;
-  }
-  getInt8(byteOffset) {
-    const buf = this.subarray(byteOffset, byteOffset + 1);
-    const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-    return view.getInt8(0);
-  }
-  setInt8(byteOffset, value2) {
-    const buf = allocUnsafe(1);
-    const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-    view.setInt8(0, value2);
-    this.write(buf, byteOffset);
-  }
-  getInt16(byteOffset, littleEndian) {
-    const buf = this.subarray(byteOffset, byteOffset + 2);
-    const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-    return view.getInt16(0, littleEndian);
-  }
-  setInt16(byteOffset, value2, littleEndian) {
-    const buf = alloc(2);
-    const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-    view.setInt16(0, value2, littleEndian);
-    this.write(buf, byteOffset);
-  }
-  getInt32(byteOffset, littleEndian) {
-    const buf = this.subarray(byteOffset, byteOffset + 4);
-    const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-    return view.getInt32(0, littleEndian);
-  }
-  setInt32(byteOffset, value2, littleEndian) {
-    const buf = alloc(4);
-    const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-    view.setInt32(0, value2, littleEndian);
-    this.write(buf, byteOffset);
-  }
-  getBigInt64(byteOffset, littleEndian) {
-    const buf = this.subarray(byteOffset, byteOffset + 8);
-    const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-    return view.getBigInt64(0, littleEndian);
-  }
-  setBigInt64(byteOffset, value2, littleEndian) {
-    const buf = alloc(8);
-    const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-    view.setBigInt64(0, value2, littleEndian);
-    this.write(buf, byteOffset);
-  }
-  getUint8(byteOffset) {
-    const buf = this.subarray(byteOffset, byteOffset + 1);
-    const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-    return view.getUint8(0);
-  }
-  setUint8(byteOffset, value2) {
-    const buf = allocUnsafe(1);
-    const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-    view.setUint8(0, value2);
-    this.write(buf, byteOffset);
-  }
-  getUint16(byteOffset, littleEndian) {
-    const buf = this.subarray(byteOffset, byteOffset + 2);
-    const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-    return view.getUint16(0, littleEndian);
-  }
-  setUint16(byteOffset, value2, littleEndian) {
-    const buf = alloc(2);
-    const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-    view.setUint16(0, value2, littleEndian);
-    this.write(buf, byteOffset);
-  }
-  getUint32(byteOffset, littleEndian) {
-    const buf = this.subarray(byteOffset, byteOffset + 4);
-    const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-    return view.getUint32(0, littleEndian);
-  }
-  setUint32(byteOffset, value2, littleEndian) {
-    const buf = alloc(4);
-    const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-    view.setUint32(0, value2, littleEndian);
-    this.write(buf, byteOffset);
-  }
-  getBigUint64(byteOffset, littleEndian) {
-    const buf = this.subarray(byteOffset, byteOffset + 8);
-    const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-    return view.getBigUint64(0, littleEndian);
-  }
-  setBigUint64(byteOffset, value2, littleEndian) {
-    const buf = alloc(8);
-    const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-    view.setBigUint64(0, value2, littleEndian);
-    this.write(buf, byteOffset);
-  }
-  getFloat32(byteOffset, littleEndian) {
-    const buf = this.subarray(byteOffset, byteOffset + 4);
-    const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-    return view.getFloat32(0, littleEndian);
-  }
-  setFloat32(byteOffset, value2, littleEndian) {
-    const buf = alloc(4);
-    const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-    view.setFloat32(0, value2, littleEndian);
-    this.write(buf, byteOffset);
-  }
-  getFloat64(byteOffset, littleEndian) {
-    const buf = this.subarray(byteOffset, byteOffset + 8);
-    const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-    return view.getFloat64(0, littleEndian);
-  }
-  setFloat64(byteOffset, value2, littleEndian) {
-    const buf = alloc(8);
-    const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-    view.setFloat64(0, value2, littleEndian);
-    this.write(buf, byteOffset);
-  }
-  equals(other) {
-    if (other == null) {
-      return false;
-    }
-    if (!(other instanceof _Uint8ArrayList)) {
-      return false;
-    }
-    if (other.bufs.length !== this.bufs.length) {
-      return false;
-    }
-    for (let i = 0; i < this.bufs.length; i++) {
-      if (!equals(this.bufs[i], other.bufs[i])) {
-        return false;
-      }
-    }
-    return true;
-  }
-  /**
-   * Create a Uint8ArrayList from a pre-existing list of Uint8Arrays.  Use this
-   * method if you know the total size of all the Uint8Arrays ahead of time.
-   */
-  static fromUint8Arrays(bufs, length) {
-    const list = new _Uint8ArrayList();
-    list.bufs = bufs;
-    if (length == null) {
-      length = bufs.reduce((acc, curr) => acc + curr.byteLength, 0);
-    }
-    list.length = length;
-    return list;
-  }
-};
-
-// ../../node_modules/.pnpm/@libp2p+utils@7.0.12/node_modules/@libp2p/utils/dist/src/multiaddr/get-net-config.js
-init_esm_shims();
-function getNetConfig(ma) {
-  const components = ma.getComponents();
-  const config = {};
-  let index = 0;
-  if (components[index]?.name === "ip6zone") {
-    config.zone = `${components[index].value}`;
-    index++;
-  }
-  if (components[index].name === "ip4" || components[index].name === "ip6") {
-    config.type = components[index].name;
-    config.host = components[index].value;
-    index++;
-  } else if (components[index].name === "dns" || components[index].name === "dns4" || components[index].name === "dns6") {
-    config.type = components[index].name;
-    config.host = components[index].value;
-    index++;
-  } else if (components[index].name === "dnsaddr") {
-    config.type = components[index].name;
-    config.host = `_dnsaddr.${components[index].value}`;
-    index++;
-  }
-  if (components[index]?.name === "tcp" || components[index]?.name === "udp") {
-    config.protocol = components[index].name === "tcp" ? "tcp" : "udp";
-    config.port = parseInt(`${components[index].value}`);
-    index++;
-  }
-  if (components[index]?.name === "ipcidr") {
-    if (config.type === "ip4") {
-      config.cidr = parseInt(`${components[index].value}`);
-    } else if (config.type === "ip6") {
-      config.cidr = `${components[index].value}`;
-    }
-    index++;
-  }
-  if (config.type == null || config.host == null) {
-    throw new InvalidParametersError(`Multiaddr ${ma} was not an IPv4, IPv6, DNS, DNS4, DNS6 or DNSADDR address`);
-  }
-  if (components[index]?.name === "tls" && components[index + 1]?.name === "sni") {
-    config.sni = components[index + 1].value;
-    index += 2;
-  }
-  return config;
-}
-
-// ../../node_modules/.pnpm/@chainsafe+is-ip@2.1.0/node_modules/@chainsafe/is-ip/lib/is-ip.node.js
-init_esm_shims();
-
-// ../../node_modules/.pnpm/it-pushable@3.2.3/node_modules/it-pushable/dist/src/index.js
-init_esm_shims();
-
-// ../../node_modules/.pnpm/p-defer@4.0.1/node_modules/p-defer/index.js
-init_esm_shims();
-function pDefer() {
-  const deferred = {};
-  deferred.promise = new Promise((resolve, reject) => {
-    deferred.resolve = resolve;
-    deferred.reject = reject;
-  });
-  return deferred;
-}
-
-// ../../node_modules/.pnpm/it-pushable@3.2.3/node_modules/it-pushable/dist/src/fifo.js
-init_esm_shims();
-var FixedFIFO = class {
-  buffer;
-  mask;
-  top;
-  btm;
-  next;
-  constructor(hwm) {
-    if (!(hwm > 0) || (hwm - 1 & hwm) !== 0) {
-      throw new Error("Max size for a FixedFIFO should be a power of two");
-    }
-    this.buffer = new Array(hwm);
-    this.mask = hwm - 1;
-    this.top = 0;
-    this.btm = 0;
-    this.next = null;
-  }
-  push(data) {
-    if (this.buffer[this.top] !== void 0) {
-      return false;
-    }
-    this.buffer[this.top] = data;
-    this.top = this.top + 1 & this.mask;
-    return true;
-  }
-  shift() {
-    const last = this.buffer[this.btm];
-    if (last === void 0) {
-      return void 0;
-    }
-    this.buffer[this.btm] = void 0;
-    this.btm = this.btm + 1 & this.mask;
-    return last;
-  }
-  isEmpty() {
-    return this.buffer[this.btm] === void 0;
-  }
-};
-var FIFO = class {
-  size;
-  hwm;
-  head;
-  tail;
-  constructor(options = {}) {
-    this.hwm = options.splitLimit ?? 16;
-    this.head = new FixedFIFO(this.hwm);
-    this.tail = this.head;
-    this.size = 0;
-  }
-  calculateSize(obj) {
-    if (obj?.byteLength != null) {
-      return obj.byteLength;
-    }
-    return 1;
-  }
-  push(val) {
-    if (val?.value != null) {
-      this.size += this.calculateSize(val.value);
-    }
-    if (!this.head.push(val)) {
-      const prev = this.head;
-      this.head = prev.next = new FixedFIFO(2 * this.head.buffer.length);
-      this.head.push(val);
-    }
-  }
-  shift() {
-    let val = this.tail.shift();
-    if (val === void 0 && this.tail.next != null) {
-      const next = this.tail.next;
-      this.tail.next = null;
-      this.tail = next;
-      val = this.tail.shift();
-    }
-    if (val?.value != null) {
-      this.size -= this.calculateSize(val.value);
-    }
-    return val;
-  }
-  isEmpty() {
-    return this.head.isEmpty();
-  }
-};
-
-// ../../node_modules/.pnpm/it-pushable@3.2.3/node_modules/it-pushable/dist/src/index.js
-var AbortError = class extends Error {
-  type;
-  code;
-  constructor(message, code2) {
-    super(message ?? "The operation was aborted");
-    this.type = "aborted";
-    this.code = code2 ?? "ABORT_ERR";
-  }
-};
-function pushable(options = {}) {
-  const getNext = (buffer) => {
-    const next = buffer.shift();
-    if (next == null) {
-      return { done: true };
-    }
-    if (next.error != null) {
-      throw next.error;
-    }
-    return {
-      done: next.done === true,
-      // @ts-expect-error if done is false, value will be present
-      value: next.value
-    };
-  };
-  return _pushable(getNext, options);
-}
-function _pushable(getNext, options) {
-  options = options ?? {};
-  let onEnd = options.onEnd;
-  let buffer = new FIFO();
-  let pushable2;
-  let onNext;
-  let ended;
-  let drain = pDefer();
-  const waitNext = async () => {
-    try {
-      if (!buffer.isEmpty()) {
-        return getNext(buffer);
-      }
-      if (ended) {
-        return { done: true };
-      }
-      return await new Promise((resolve, reject) => {
-        onNext = (next) => {
-          onNext = null;
-          buffer.push(next);
-          try {
-            resolve(getNext(buffer));
-          } catch (err) {
-            reject(err);
-          }
-          return pushable2;
-        };
-      });
-    } finally {
-      if (buffer.isEmpty()) {
-        queueMicrotask(() => {
-          drain.resolve();
-          drain = pDefer();
-        });
-      }
-    }
-  };
-  const bufferNext = (next) => {
-    if (onNext != null) {
-      return onNext(next);
-    }
-    buffer.push(next);
-    return pushable2;
-  };
-  const bufferError = (err) => {
-    buffer = new FIFO();
-    if (onNext != null) {
-      return onNext({ error: err });
-    }
-    buffer.push({ error: err });
-    return pushable2;
-  };
-  const push = (value2) => {
-    if (ended) {
-      return pushable2;
-    }
-    if (options?.objectMode !== true && value2?.byteLength == null) {
-      throw new Error("objectMode was not true but tried to push non-Uint8Array value");
-    }
-    return bufferNext({ done: false, value: value2 });
-  };
-  const end = (err) => {
-    if (ended)
-      return pushable2;
-    ended = true;
-    return err != null ? bufferError(err) : bufferNext({ done: true });
-  };
-  const _return = () => {
-    buffer = new FIFO();
-    end();
-    return { done: true };
-  };
-  const _throw = (err) => {
-    end(err);
-    return { done: true };
-  };
-  pushable2 = {
-    [Symbol.asyncIterator]() {
-      return this;
-    },
-    next: waitNext,
-    return: _return,
-    throw: _throw,
-    push,
-    end,
-    get readableLength() {
-      return buffer.size;
-    },
-    onEmpty: async (options2) => {
-      const signal = options2?.signal;
-      signal?.throwIfAborted();
-      if (buffer.isEmpty()) {
-        return;
-      }
-      let cancel;
-      let listener;
-      if (signal != null) {
-        cancel = new Promise((resolve, reject) => {
-          listener = () => {
-            reject(new AbortError());
-          };
-          signal.addEventListener("abort", listener);
-        });
-      }
-      try {
-        await Promise.race([
-          drain.promise,
-          cancel
-        ]);
-      } finally {
-        if (listener != null && signal != null) {
-          signal?.removeEventListener("abort", listener);
-        }
-      }
-    }
-  };
-  if (onEnd == null) {
-    return pushable2;
-  }
-  const _pushable2 = pushable2;
-  pushable2 = {
-    [Symbol.asyncIterator]() {
-      return this;
-    },
-    next() {
-      return _pushable2.next();
-    },
-    throw(err) {
-      _pushable2.throw(err);
-      if (onEnd != null) {
-        onEnd(err);
-        onEnd = void 0;
-      }
-      return { done: true };
-    },
-    return() {
-      _pushable2.return();
-      if (onEnd != null) {
-        onEnd();
-        onEnd = void 0;
-      }
-      return { done: true };
-    },
-    push,
-    end(err) {
-      _pushable2.end(err);
-      if (onEnd != null) {
-        onEnd(err);
-        onEnd = void 0;
-      }
-      return pushable2;
-    },
-    get readableLength() {
-      return _pushable2.readableLength;
-    },
-    onEmpty: (opts) => {
-      return _pushable2.onEmpty(opts);
-    }
-  };
-  return pushable2;
-}
-
-// ../../node_modules/.pnpm/@libp2p+utils@7.0.12/node_modules/@libp2p/utils/dist/src/debounce.js
-init_esm_shims();
-function debounce(func, wait) {
-  let timeout;
-  const output = function() {
-    const later = function() {
-      timeout = void 0;
-      void func();
-    };
-    clearTimeout(timeout);
-    timeout = setTimeout(later, wait);
-  };
-  output.start = () => {
-  };
-  output.stop = () => {
-    clearTimeout(timeout);
-  };
-  return output;
-}
-
-// ../../node_modules/.pnpm/@libp2p+utils@7.0.12/node_modules/@libp2p/utils/dist/src/errors.js
-init_esm_shims();
-var StreamClosedError = class extends Error {
-  static name = "StreamClosedError";
-  name = "StreamClosedError";
-};
-
-// ../../node_modules/.pnpm/race-signal@2.0.0/node_modules/race-signal/dist/src/index.js
-init_esm_shims();
-function defaultTranslate(signal) {
-  return signal.reason;
-}
-async function raceSignal(promise, signal, opts) {
-  if (signal == null) {
-    return promise;
-  }
-  const translateError = defaultTranslate;
-  if (signal.aborted) {
-    promise.catch(() => {
-    });
-    return Promise.reject(translateError(signal));
-  }
-  let listener;
-  try {
-    return await Promise.race([
-      promise,
-      new Promise((resolve, reject) => {
-        listener = () => {
-          reject(translateError(signal));
-        };
-        signal.addEventListener("abort", listener);
-      })
-    ]);
-  } finally {
-    if (listener != null) {
-      signal.removeEventListener("abort", listener);
-    }
-  }
-}
-
-// ../../node_modules/.pnpm/@libp2p+utils@7.0.12/node_modules/@libp2p/utils/dist/src/abstract-message-stream.js
-init_esm_shims();
-var DEFAULT_MAX_READ_BUFFER_LENGTH = Math.pow(2, 20) * 4;
-var AbstractMessageStream = class extends TypedEventEmitter {
-  status;
-  timeline;
-  inactivityTimeout;
-  maxReadBufferLength;
-  maxWriteBufferLength;
-  log;
-  direction;
-  maxMessageSize;
-  readStatus;
-  writeStatus;
-  remoteReadStatus;
-  remoteWriteStatus;
-  writableNeedsDrain;
-  /**
-   * Any data stored here is emitted before any new incoming data.
-   *
-   * This is used when the stream is paused or if data is pushed onto the stream
-   */
-  readBuffer;
-  writeBuffer;
-  sendingData;
-  onDrainPromise;
-  constructor(init) {
-    super();
-    this.status = "open";
-    this.log = init.log;
-    this.direction = init.direction ?? "outbound";
-    this.inactivityTimeout = init.inactivityTimeout ?? 12e4;
-    this.maxReadBufferLength = init.maxReadBufferLength ?? DEFAULT_MAX_READ_BUFFER_LENGTH;
-    this.maxWriteBufferLength = init.maxWriteBufferLength;
-    this.maxMessageSize = init.maxMessageSize;
-    this.readBuffer = new Uint8ArrayList();
-    this.writeBuffer = new Uint8ArrayList();
-    this.readStatus = "readable";
-    this.remoteReadStatus = "readable";
-    this.writeStatus = "writable";
-    this.remoteWriteStatus = "writable";
-    this.sendingData = false;
-    this.writableNeedsDrain = false;
-    this.timeline = {
-      open: Date.now()
-    };
-    this.processSendQueue = this.processSendQueue.bind(this);
-    const continueSendingOnDrain = () => {
-      if (this.writableNeedsDrain) {
-        this.log.trace("drain event received, continue sending data");
-        this.writableNeedsDrain = false;
-        this.processSendQueue();
-      }
-      this.onDrainPromise?.resolve();
-    };
-    this.addEventListener("drain", continueSendingOnDrain);
-    const rejectOnDrainOnClose = (evt) => {
-      this.onDrainPromise?.reject(evt.error ?? new StreamClosedError());
-    };
-    this.addEventListener("close", rejectOnDrainOnClose);
-  }
-  get readBufferLength() {
-    return this.readBuffer.byteLength;
-  }
-  get writeBufferLength() {
-    return this.writeBuffer.byteLength;
-  }
-  async onDrain(options) {
-    if (this.writableNeedsDrain !== true) {
-      return Promise.resolve();
-    }
-    if (this.onDrainPromise == null) {
-      this.onDrainPromise = Promise.withResolvers();
-    }
-    return raceSignal(this.onDrainPromise.promise, options?.signal);
-  }
-  async *[Symbol.asyncIterator]() {
-    if (this.readStatus !== "readable" && this.readStatus !== "paused") {
-      return;
-    }
-    const output = pushable();
-    const streamAsyncIterableOnMessageListener = (evt) => {
-      output.push(evt.data);
-    };
-    this.addEventListener("message", streamAsyncIterableOnMessageListener);
-    const streamAsyncIterableOnCloseListener = (evt) => {
-      output.end(evt.error);
-    };
-    this.addEventListener("close", streamAsyncIterableOnCloseListener);
-    const streamAsyncIterableOnRemoteCloseWriteListener = () => {
-      output.end();
-    };
-    this.addEventListener("remoteCloseWrite", streamAsyncIterableOnRemoteCloseWriteListener);
-    try {
-      yield* output;
-    } finally {
-      this.removeEventListener("message", streamAsyncIterableOnMessageListener);
-      this.removeEventListener("close", streamAsyncIterableOnCloseListener);
-      this.removeEventListener("remoteCloseWrite", streamAsyncIterableOnRemoteCloseWriteListener);
-    }
-  }
-  isReadable() {
-    return this.status === "open";
-  }
-  send(data) {
-    if (this.writeStatus === "closed" || this.writeStatus === "closing") {
-      throw new StreamStateError(`Cannot write to a stream that is ${this.writeStatus}`);
-    }
-    this.log.trace("append %d bytes to write buffer", data.byteLength);
-    this.writeBuffer.append(data);
-    return this.processSendQueue();
-  }
-  /**
-   * Close immediately for reading and writing and send a reset message (local
-   * error)
-   */
-  abort(err) {
-    if (this.status === "aborted" || this.status === "reset" || this.status === "closed") {
-      return;
-    }
-    this.log.error("abort with error - %e", err);
-    this.status = "aborted";
-    if (this.readBuffer.byteLength > 0) {
-      this.readBuffer.consume(this.readBuffer.byteLength);
-    }
-    if (this.writeBuffer.byteLength > 0) {
-      this.writeBuffer.consume(this.writeBuffer.byteLength);
-      this.safeDispatchEvent("idle");
-    }
-    this.writeStatus = "closed";
-    this.remoteWriteStatus = "closed";
-    this.readStatus = "closed";
-    this.remoteReadStatus = "closed";
-    this.timeline.close = Date.now();
-    try {
-      this.sendReset(err);
-    } catch (err2) {
-      this.log("failed to send reset to remote - %e", err2);
-    }
-    this.dispatchEvent(new StreamAbortEvent(err));
-  }
-  pause() {
-    if (this.readStatus === "closed" || this.readStatus === "closing") {
-      throw new StreamStateError("Cannot pause a stream that is closing/closed");
-    }
-    if (this.readStatus === "paused") {
-      return;
-    }
-    this.readStatus = "paused";
-    this.sendPause();
-  }
-  resume() {
-    if (this.readStatus === "closed" || this.readStatus === "closing") {
-      throw new StreamStateError("Cannot resume a stream that is closing/closed");
-    }
-    if (this.readStatus === "readable") {
-      return;
-    }
-    this.readStatus = "readable";
-    this.dispatchReadBuffer();
-    this.sendResume();
-  }
-  push(data) {
-    if (this.readStatus === "closed" || this.readStatus === "closing") {
-      throw new StreamStateError(`Cannot push data onto a stream that is ${this.readStatus}`);
-    }
-    if (data.byteLength === 0) {
-      return;
-    }
-    this.readBuffer.append(data);
-    if (this.readStatus === "paused" || this.listenerCount("message") === 0) {
-      this.checkReadBufferLength();
-      return;
-    }
-    setTimeout(() => {
-      this.dispatchReadBuffer();
-    }, 0);
-  }
-  unshift(data) {
-    if (this.readStatus === "closed" || this.readStatus === "closing") {
-      throw new StreamStateError(`Cannot push data onto a stream that is ${this.readStatus}`);
-    }
-    if (data.byteLength === 0) {
-      return;
-    }
-    this.readBuffer.prepend(data);
-    if (this.readStatus === "paused" || this.listenerCount("message") === 0) {
-      this.checkReadBufferLength();
-      return;
-    }
-    setTimeout(() => {
-      this.dispatchReadBuffer();
-    }, 0);
-  }
-  /**
-   * When an extending class reads data from it's implementation-specific source,
-   * call this method to allow the stream consumer to read the data.
-   */
-  onData(data) {
-    if (data.byteLength === 0) {
-      return;
-    }
-    if (this.readStatus === "closing" || this.readStatus === "closed") {
-      this.log("ignoring data - read status %s", this.readStatus);
-      return;
-    }
-    this.readBuffer.append(data);
-    this.dispatchReadBuffer();
-  }
-  addEventListener(...args) {
-    super.addEventListener.apply(this, args);
-    if (args[0] === "message" && this.readBuffer.byteLength > 0) {
-      queueMicrotask(() => {
-        this.dispatchReadBuffer();
-      });
-    }
-  }
-  /**
-   * Receive a reset message - close immediately for reading and writing (remote
-   * error)
-   */
-  onRemoteReset() {
-    this.log("remote reset");
-    this.status = "reset";
-    this.writeStatus = "closed";
-    this.remoteWriteStatus = "closed";
-    this.remoteReadStatus = "closed";
-    this.timeline.close = Date.now();
-    if (this.readBuffer.byteLength === 0) {
-      this.readStatus = "closed";
-    }
-    const err = new StreamResetError();
-    this.dispatchEvent(new StreamResetEvent(err));
-  }
-  /**
-   * The underlying resource or transport this stream uses has closed - it is
-   * not possible to send any more messages though any data still in the read
-   * buffer may still be read
-   */
-  onTransportClosed(err) {
-    this.log("transport closed");
-    if (this.readStatus === "readable" && this.readBuffer.byteLength === 0) {
-      this.log("close readable end after transport closed and read buffer is empty");
-      this.readStatus = "closed";
-    }
-    if (this.remoteReadStatus !== "closed") {
-      this.remoteReadStatus = "closed";
-    }
-    if (this.remoteWriteStatus !== "closed") {
-      this.remoteWriteStatus = "closed";
-    }
-    if (this.writeStatus !== "closed") {
-      this.writeStatus = "closed";
-    }
-    if (err != null) {
-      this.abort(err);
-    } else {
-      if (this.status === "open" || this.status === "closing") {
-        this.timeline.close = Date.now();
-        this.status = "closed";
-        this.writeStatus = "closed";
-        this.remoteWriteStatus = "closed";
-        this.remoteReadStatus = "closed";
-        this.dispatchEvent(new StreamCloseEvent());
-      }
-    }
-  }
-  /**
-   * Called by extending classes when the remote closes its writable end
-   */
-  onRemoteCloseWrite() {
-    if (this.remoteWriteStatus === "closed") {
-      return;
-    }
-    this.log.trace("on remote close write");
-    this.remoteWriteStatus = "closed";
-    this.safeDispatchEvent("remoteCloseWrite");
-    if (this.writeStatus === "closed") {
-      this.onTransportClosed();
-    }
-  }
-  /**
-   * Called by extending classes when the remote closes its readable end
-   */
-  onRemoteCloseRead() {
-    this.log.trace("on remote close read");
-    this.remoteReadStatus = "closed";
-    if (this.writeBuffer.byteLength > 0) {
-      this.writeBuffer.consume(this.writeBuffer.byteLength);
-      this.safeDispatchEvent("idle");
-    }
-  }
-  processSendQueue() {
-    if (this.writableNeedsDrain) {
-      this.log.trace("not processing send queue as drain is required");
-      this.checkWriteBufferLength();
-      return false;
-    }
-    if (this.writeBuffer.byteLength === 0) {
-      this.log.trace("not processing send queue as no bytes to send");
-      return true;
-    }
-    if (this.sendingData) {
-      this.log.trace("not processing send queue as already sending data");
-      return true;
-    }
-    this.sendingData = true;
-    this.log.trace("processing send queue with %d queued bytes", this.writeBuffer.byteLength);
-    try {
-      let canSendMore = true;
-      const totalBytes = this.writeBuffer.byteLength;
-      let sentBytes = 0;
-      while (this.writeBuffer.byteLength > 0) {
-        const end = Math.min(this.maxMessageSize ?? this.writeBuffer.byteLength, this.writeBuffer.byteLength);
-        if (end === 0) {
-          canSendMore = false;
-          break;
-        }
-        const toSend = this.writeBuffer.sublist(0, end);
-        const willSend = new Uint8ArrayList(toSend);
-        this.writeBuffer.consume(toSend.byteLength);
-        const sendResult = this.sendData(toSend);
-        canSendMore = sendResult.canSendMore;
-        sentBytes += sendResult.sentBytes;
-        if (sendResult.sentBytes !== willSend.byteLength) {
-          willSend.consume(sendResult.sentBytes);
-          this.writeBuffer.prepend(willSend);
-        }
-        if (!canSendMore) {
-          break;
-        }
-      }
-      if (!canSendMore) {
-        this.log.trace("sent %d/%d bytes, pausing sending because underlying stream is full, %d bytes left in the write buffer", sentBytes, totalBytes, this.writeBuffer.byteLength);
-        this.writableNeedsDrain = true;
-        this.checkWriteBufferLength();
-      }
-      if (this.writeBuffer.byteLength === 0) {
-        this.safeDispatchEvent("idle");
-      }
-      return canSendMore;
-    } finally {
-      this.sendingData = false;
-    }
-  }
-  dispatchReadBuffer() {
-    try {
-      if (this.listenerCount("message") === 0) {
-        this.log.trace("not dispatching pause buffer as there are no listeners for the message event");
-        return;
-      }
-      if (this.readBuffer.byteLength === 0) {
-        this.log.trace("not dispatching pause buffer as there is no data to dispatch");
-        return;
-      }
-      if (this.readStatus === "paused") {
-        this.log.trace("not dispatching pause buffer we are paused");
-        return;
-      }
-      if (this.readStatus === "closing" || this.readStatus === "closed") {
-        this.log("dropping %d bytes because the readable end is %s", this.readBuffer.byteLength, this.readStatus);
-        this.readBuffer.consume(this.readBuffer.byteLength);
-        return;
-      }
-      const buf = this.readBuffer.sublist();
-      this.readBuffer.consume(buf.byteLength);
-      this.dispatchEvent(new StreamMessageEvent(buf));
-    } finally {
-      if (this.readBuffer.byteLength === 0 && this.remoteWriteStatus === "closed") {
-        this.log("close readable end after dispatching read buffer and remote writable end is closed");
-        this.readStatus = "closed";
-      }
-      this.checkReadBufferLength();
-    }
-  }
-  checkReadBufferLength() {
-    if (this.readBuffer.byteLength > this.maxReadBufferLength) {
-      this.abort(new StreamBufferError(`Read buffer length of ${this.readBuffer.byteLength} exceeded limit of ${this.maxReadBufferLength}, read status is ${this.readStatus}`));
-    }
-  }
-  checkWriteBufferLength() {
-    if (this.maxWriteBufferLength == null) {
-      return;
-    }
-    if (this.writeBuffer.byteLength > this.maxWriteBufferLength) {
-      this.abort(new StreamBufferError(`Write buffer length of ${this.writeBuffer.byteLength} exceeded limit of ${this.maxWriteBufferLength}, write status is ${this.writeStatus}`));
-    }
-  }
-  onMuxerNeedsDrain() {
-    this.writableNeedsDrain = true;
-  }
-  onMuxerDrain() {
-    this.safeDispatchEvent("drain");
-  }
-};
-
-// ../../node_modules/.pnpm/@libp2p+utils@7.0.12/node_modules/@libp2p/utils/dist/src/abstract-multiaddr-connection.js
-init_esm_shims();
-var AbstractMultiaddrConnection = class extends AbstractMessageStream {
-  remoteAddr;
-  metricPrefix;
-  metrics;
-  constructor(init) {
-    super(init);
-    this.metricPrefix = init.metricPrefix ?? "";
-    this.metrics = init.metrics;
-    this.remoteAddr = init.remoteAddr;
-    this.addEventListener("close", (evt) => {
-      this.metrics?.increment({ [`${this.metricPrefix}end`]: true });
-      if (evt.error != null) {
-        if (evt.local) {
-          this.metrics?.increment({ [`${this.metricPrefix}abort`]: true });
-        } else {
-          this.metrics?.increment({ [`${this.metricPrefix}reset`]: true });
-        }
-      } else {
-        if (evt.local) {
-          this.metrics?.increment({ [`${this.metricPrefix}_local_close`]: true });
-        } else {
-          this.metrics?.increment({ [`${this.metricPrefix}_remote_close`]: true });
-        }
-      }
-    });
-  }
-  async close(options) {
-    if (this.status !== "open") {
-      return;
-    }
-    this.status = "closing";
-    this.writeStatus = "closing";
-    this.remoteWriteStatus = "closing";
-    this.remoteReadStatus = "closing";
-    if (this.sendingData || this.writeBuffer.byteLength > 0) {
-      this.log("waiting for write queue to become idle before closing writable end of stream, %d unsent bytes", this.writeBuffer.byteLength);
-      await pEvent(this, "idle", {
-        ...options,
-        rejectionEvents: [
-          "close"
-        ]
-      });
-    }
-    if (this.writableNeedsDrain) {
-      this.log("waiting for write queue to drain before closing writable end of stream, %d unsent bytes", this.writeBuffer.byteLength);
-      await pEvent(this, "drain", {
-        ...options,
-        rejectionEvents: [
-          "close"
-        ]
-      });
-    }
-    await this.sendClose(options);
-    this.onTransportClosed();
-  }
-};
-
-// ../../node_modules/.pnpm/any-signal@4.2.0/node_modules/any-signal/dist/src/index.js
-init_esm_shims();
-function anySignal(signals) {
-  const controller = new globalThis.AbortController();
-  function onAbort() {
-    const reason = signals.filter((s) => s?.aborted === true).map((s) => s?.reason).pop();
-    controller.abort(reason);
-    for (const signal2 of signals) {
-      if (signal2?.removeEventListener != null) {
-        signal2.removeEventListener("abort", onAbort);
-      }
-    }
-  }
-  for (const signal2 of signals) {
-    if (signal2?.aborted === true) {
-      onAbort();
-      break;
-    }
-    if (signal2?.addEventListener != null) {
-      signal2.addEventListener("abort", onAbort);
-    }
-  }
-  function clear() {
-    for (const signal2 of signals) {
-      if (signal2?.removeEventListener != null) {
-        signal2.removeEventListener("abort", onAbort);
-      }
-    }
-  }
-  const signal = controller.signal;
-  signal.clear = clear;
-  return signal;
-}
-
-// ../../node_modules/.pnpm/@libp2p+utils@7.0.12/node_modules/@libp2p/utils/dist/src/get-thin-waist-addresses.js
-init_esm_shims();
-
-// ../../node_modules/.pnpm/@libp2p+utils@7.0.12/node_modules/@libp2p/utils/dist/src/link-local-ip.js
-init_esm_shims();
-function isLinkLocalIp(ip) {
-  if (ip.startsWith("169.254.")) {
-    return true;
-  }
-  if (ip.toLowerCase().startsWith("fe80")) {
-    return true;
-  }
-  return false;
-}
-
-// ../../node_modules/.pnpm/@libp2p+utils@7.0.12/node_modules/@libp2p/utils/dist/src/multiaddr/utils.js
-init_esm_shims();
-function netConfigToMultiaddr(config, port, host) {
-  const parts = [
-    config.type,
-    host ?? config.host
-  ];
-  if (config.protocol != null) {
-    const p = port ?? config.port;
-    if (p != null) {
-      parts.push(config.protocol, p);
-    }
-  }
-  if (config.type === "ip6" && config.zone != null) {
-    parts.unshift("ip6zone", config.zone);
-  }
-  if (config.cidr != null) {
-    parts.push("ipcidr", config.cidr);
-  }
-  return multiaddr(`/${parts.join("/")}`);
-}
-
-// ../../node_modules/.pnpm/@libp2p+utils@7.0.12/node_modules/@libp2p/utils/dist/src/get-thin-waist-addresses.js
-var FAMILIES = { 4: "IPv4", 6: "IPv6" };
-function isWildcard(ip) {
-  return ["0.0.0.0", "::"].includes(ip);
-}
-function getNetworkAddrs(family) {
-  const addresses = [];
-  const networks = os.networkInterfaces();
-  for (const [, netAddrs] of Object.entries(networks)) {
-    if (netAddrs != null) {
-      for (const netAddr of netAddrs) {
-        if (isLinkLocalIp(netAddr.address)) {
-          continue;
-        }
-        if (netAddr.family === FAMILIES[family]) {
-          addresses.push(netAddr.address);
-        }
-      }
-    }
-  }
-  return addresses;
-}
-function getThinWaistAddresses(ma, port) {
-  if (ma == null) {
-    return [];
-  }
-  const config = getNetConfig(ma);
-  if ((config.type === "ip4" || config.type === "ip6") && isWildcard(config.host)) {
-    return getNetworkAddrs(config.type === "ip4" ? 4 : 6).map((host) => netConfigToMultiaddr(config, port, host));
-  }
-  return [
-    netConfigToMultiaddr(config, port)
-  ];
-}
-
-// ../../node_modules/.pnpm/@libp2p+utils@7.0.12/node_modules/@libp2p/utils/dist/src/ip-port-to-multiaddr.js
-init_esm_shims();
-function ipPortToMultiaddr(ip, port) {
-  if (typeof ip !== "string") {
-    throw new InvalidParametersError(`invalid ip provided: ${ip}`);
-  }
-  if (typeof port === "string") {
-    port = parseInt(port);
-  }
-  if (isNaN(port)) {
-    throw new InvalidParametersError(`invalid port provided: ${port}`);
-  }
-  if (isIPv4(ip)) {
-    return multiaddr(`/ip4/${ip}/tcp/${port}`);
-  }
-  if (isIPv6(ip)) {
-    return multiaddr(`/ip6/${ip}/tcp/${port}`);
-  }
-  throw new InvalidParametersError(`invalid ip:port for creating a multiaddr: ${ip}:${port}`);
-}
-
-// ../../node_modules/.pnpm/@libp2p+utils@7.0.12/node_modules/@libp2p/utils/dist/src/repeating-task.js
-init_esm_shims();
-function repeatingTask(fn, interval, options) {
-  let timeout;
-  let shutdownController;
-  let running = false;
-  function runTask() {
-    const opts = {
-      signal: shutdownController.signal
-    };
-    if (options?.timeout != null) {
-      const signal = anySignal([shutdownController.signal, AbortSignal.timeout(options.timeout)]);
-      setMaxListeners(Infinity, signal);
-      opts.signal = signal;
-    }
-    running = true;
-    Promise.resolve().then(async () => {
-      await fn(opts);
-    }).catch(() => {
-    }).finally(() => {
-      running = false;
-      if (shutdownController.signal.aborted) {
-        return;
-      }
-      timeout = setTimeout(runTask, interval);
-    });
-  }
-  const runTaskDebounced = debounce(runTask, options?.debounce ?? 100);
-  let started = false;
-  return {
-    setInterval: (ms) => {
-      if (interval === ms) {
-        return;
-      }
-      interval = ms;
-      if (timeout != null) {
-        clearTimeout(timeout);
-        timeout = setTimeout(runTask, interval);
-      }
-    },
-    setTimeout: (ms) => {
-      options ??= {};
-      options.timeout = ms;
-    },
-    run: () => {
-      if (running) {
-        return;
-      }
-      clearTimeout(timeout);
-      runTaskDebounced();
-    },
-    start: () => {
-      if (started) {
-        return;
-      }
-      started = true;
-      shutdownController = new AbortController();
-      setMaxListeners(Infinity, shutdownController.signal);
-      if (options?.runImmediately === true) {
-        queueMicrotask(() => {
-          runTask();
-        });
-      } else {
-        timeout = setTimeout(runTask, interval);
-      }
-    },
-    stop: () => {
-      clearTimeout(timeout);
-      shutdownController?.abort();
-      started = false;
-    }
-  };
-}
-
-// ../../node_modules/.pnpm/@libp2p+websockets@10.1.5/node_modules/@libp2p/websockets/dist/src/utils.js
-init_esm_shims();
-function toWebSocket(ws2) {
-  Object.defineProperty(ws2, "url", {
-    value: "",
-    writable: false
-  });
-  ws2.dispatchEvent = (evt) => {
-    if (evt.type === "close") {
-      ws2.emit("close");
-    }
-    if (evt.type === "open") {
-      ws2.emit("open");
-    }
-    if (evt.type === "message") {
-      const m = evt;
-      ws2.emit("data", m.data);
-    }
-    if (evt.type === "error") {
-      ws2.emit("error", new Error("An error occurred"));
-    }
-    ws2.emit(evt.type, evt);
-  };
-  return ws2;
-}
-
-// ../../node_modules/.pnpm/@libp2p+websockets@10.1.5/node_modules/@libp2p/websockets/dist/src/websocket-to-conn.js
-init_esm_shims();
-var DEFAULT_MAX_BUFFERED_AMOUNT = 1024 * 1024 * 4;
-var DEFAULT_BUFFERED_AMOUNT_POLL_INTERVAL = 10;
-var WebSocketMultiaddrConnection = class extends AbstractMultiaddrConnection {
-  websocket;
-  maxBufferedAmount;
-  checkBufferedAmountTask;
-  constructor(init) {
-    super(init);
-    this.websocket = init.websocket;
-    this.maxBufferedAmount = init.maxBufferedAmount ?? DEFAULT_MAX_BUFFERED_AMOUNT;
-    this.checkBufferedAmountTask = repeatingTask(this.checkBufferedAmount.bind(this), init.bufferedAmountPollInterval ?? DEFAULT_BUFFERED_AMOUNT_POLL_INTERVAL);
-    this.websocket.addEventListener("close", (evt) => {
-      this.log('closed - code %d, reason "%s", wasClean %s', evt.code, evt.reason, evt.wasClean);
-      this.checkBufferedAmountTask.stop();
-      if (!evt.wasClean) {
-        this.onRemoteReset();
-        return;
-      }
-      this.onTransportClosed();
-    }, { once: true });
-    this.websocket.addEventListener("message", (evt) => {
-      try {
-        let buf;
-        if (typeof evt.data === "string") {
-          buf = fromString(evt.data);
-        } else if (evt.data instanceof ArrayBuffer) {
-          buf = new Uint8Array(evt.data, 0, evt.data.byteLength);
-        } else {
-          this.abort(new Error("Incorrect binary type"));
-          return;
-        }
-        this.onData(buf);
-      } catch (err) {
-        this.log.error("error receiving data - %e", err);
-      }
-    });
-  }
-  sendData(data) {
-    for (const buf of data) {
-      this.websocket.send(buf);
-    }
-    const canSendMore = this.websocket.bufferedAmount < this.maxBufferedAmount;
-    if (!canSendMore) {
-      this.checkBufferedAmountTask.start();
-    }
-    return {
-      sentBytes: data.byteLength,
-      canSendMore
-    };
-  }
-  sendReset() {
-    this.websocket.close(1006);
-  }
-  async sendClose(options) {
-    this.websocket.close();
-    options?.signal?.throwIfAborted();
-  }
-  sendPause() {
-  }
-  sendResume() {
-  }
-  checkBufferedAmount() {
-    this.log("buffered amount now %d", this.websocket.bufferedAmount);
-    if (this.websocket.bufferedAmount === 0) {
-      this.checkBufferedAmountTask.stop();
-      this.safeDispatchEvent("drain");
-    }
-  }
-};
-function webSocketToMaConn(init) {
-  return new WebSocketMultiaddrConnection(init);
-}
-
-// ../../node_modules/.pnpm/@libp2p+websockets@10.1.5/node_modules/@libp2p/websockets/dist/src/listener.js
-var WebSocketListener = class extends TypedEventEmitter {
-  components;
-  log;
-  server;
-  wsServer;
-  metrics;
-  sockets;
-  upgrader;
-  httpOptions;
-  httpsOptions;
-  shutdownController;
-  http;
-  https;
-  addr;
-  listeningMultiaddr;
-  maxBufferedAmount;
-  bufferedAmountPollInterval;
-  constructor(components, init) {
-    super();
-    this.components = components;
-    this.log = components.logger.forComponent("libp2p:websockets:listener");
-    this.upgrader = init.upgrader;
-    this.httpOptions = init.http;
-    this.httpsOptions = init.https ?? init.http;
-    this.maxBufferedAmount = init.maxBufferedAmount;
-    this.bufferedAmountPollInterval = init.bufferedAmountPollInterval;
-    this.sockets = /* @__PURE__ */ new Set();
-    this.shutdownController = new AbortController();
-    setMaxListeners(Infinity, this.shutdownController.signal);
-    this.wsServer = new ws.WebSocketServer({
-      noServer: true
-    });
-    this.wsServer.addListener("connection", this.onWsServerConnection.bind(this));
-    components.metrics?.registerMetricGroup("libp2p_websockets_inbound_connections_total", {
-      label: "address",
-      help: "Current active connections in WebSocket listener",
-      calculate: () => {
-        if (this.addr == null) {
-          return {};
-        }
-        return {
-          [this.addr]: this.sockets.size
-        };
-      }
-    });
-    this.metrics = {
-      status: components.metrics?.registerMetricGroup("libp2p_websockets_listener_status_info", {
-        label: "address",
-        help: "Current status of the WebSocket listener socket"
-      }),
-      errors: components.metrics?.registerMetricGroup("libp2p_websockets_listener_errors_total", {
-        label: "address",
-        help: "Total count of WebSocket listener errors by type"
-      }),
-      events: components.metrics?.registerMetricGroup("libp2p_websockets_listener_events_total", {
-        label: "address",
-        help: "Total count of WebSocket listener events by type"
-      })
-    };
-    this.server = net.createServer({
-      pauseOnConnect: true
-    }, (socket) => {
-      this.onSocketConnection(socket).catch((err) => {
-        this.log.error("error handling socket - %e", err);
-        socket.destroy();
-      });
-    });
-    components.events.addEventListener("certificate:provision", this.onCertificateProvision.bind(this));
-    components.events.addEventListener("certificate:renew", this.onCertificateRenew.bind(this));
-  }
-  async onSocketConnection(socket) {
-    this.metrics.events?.increment({ [`${this.addr} connection`]: true });
-    let buffer = socket.read(1);
-    if (buffer == null) {
-      await pEvent(socket, "readable");
-      buffer = socket.read(1);
-    }
-    const byte = buffer[0];
-    let server = this.http;
-    if (byte < 32 || byte >= 127) {
-      server = this.https;
-    }
-    if (server == null) {
-      this.log.error("no appropriate listener configured for byte %d", byte);
-      socket.destroy();
-      return;
-    }
-    this.sockets.add(socket);
-    socket.on("close", () => {
-      this.metrics.events?.increment({ [`${this.addr} close`]: true });
-      this.sockets.delete(socket);
-    });
-    socket.on("error", (err) => {
-      this.log.error("socket error - %e", err);
-      this.metrics.events?.increment({ [`${this.addr} error`]: true });
-      socket.destroy();
-    });
-    socket.once("timeout", () => {
-      this.metrics.events?.increment({ [`${this.addr} timeout`]: true });
-    });
-    socket.once("end", () => {
-      this.metrics.events?.increment({ [`${this.addr} end`]: true });
-    });
-    socket.unshift(buffer);
-    server.emit("connection", socket);
-  }
-  onWsServerConnection(socket, req) {
-    let addr;
-    socket.binaryType = "arraybuffer";
-    try {
-      addr = this.server.address();
-      if (typeof addr === "string") {
-        throw new Error("Cannot listen on unix sockets");
-      }
-      if (addr == null) {
-        throw new Error("Server was closing or not running");
-      }
-    } catch (err) {
-      this.log.error("error obtaining remote socket address - %e", err);
-      req.destroy(err);
-      socket.close();
-      return;
-    }
-    let maConn;
-    try {
-      maConn = webSocketToMaConn({
-        websocket: toWebSocket(socket),
-        remoteAddr: ipPortToMultiaddr(req.socket.remoteAddress ?? "0.0.0.0", req.socket.remotePort ?? 0).encapsulate("/ws"),
-        metrics: this.metrics?.events,
-        metricPrefix: `${this.addr} `,
-        direction: "inbound",
-        log: this.components.logger.forComponent("libp2p:websockets:connection"),
-        maxBufferedAmount: this.maxBufferedAmount,
-        bufferedAmountPollInterval: this.bufferedAmountPollInterval
-      });
-    } catch (err) {
-      this.log.error("inbound connection failed - %e", err);
-      this.metrics.errors?.increment({ [`${this.addr} inbound_to_connection`]: true });
-      socket.close();
-      return;
-    }
-    this.log("new inbound connection %s", maConn.remoteAddr);
-    this.upgrader.upgradeInbound(maConn, {
-      signal: this.shutdownController.signal
-    }).catch(async (err) => {
-      this.log.error("inbound connection failed to upgrade - %e", err);
-      this.metrics.errors?.increment({ [`${this.addr} inbound_upgrade`]: true });
-      maConn.close();
-    });
-  }
-  onUpgrade(req, socket, head) {
-    this.wsServer.handleUpgrade(req, socket, head, this.onWsServerConnection.bind(this));
-  }
-  onTLSClientError(err, socket) {
-    this.log.error("TLS client error - %e", err);
-    socket.destroy();
-  }
-  async listen(ma) {
-    if (WebSockets.exactMatch(ma)) {
-      this.http = http.createServer(this.httpOptions ?? {}, this.httpRequestHandler.bind(this));
-      this.http.addListener("upgrade", this.onUpgrade.bind(this));
-    } else if (WebSocketsSecure.exactMatch(ma)) {
-      this.https = https.createServer(this.httpsOptions ?? {}, this.httpRequestHandler.bind(this));
-      this.https.addListener("upgrade", this.onUpgrade.bind(this));
-      this.https.addListener("tlsClientError", this.onTLSClientError.bind(this));
-    }
-    const config = getNetConfig(ma);
-    this.addr = `${config.host}:${config.port}`;
-    this.server.listen({
-      ...config,
-      ipv6Only: config.type === "ip6"
-    });
-    await new Promise((resolve, reject) => {
-      const onListening = () => {
-        removeListeners();
-        resolve();
-      };
-      const onError = (err) => {
-        this.metrics.errors?.increment({ [`${this.addr} listen_error`]: true });
-        removeListeners();
-        reject(err);
-      };
-      const onDrop = () => {
-        this.metrics.events?.increment({ [`${this.addr} drop`]: true });
-      };
-      const removeListeners = () => {
-        this.server.removeListener("listening", onListening);
-        this.server.removeListener("error", onError);
-        this.server.removeListener("drop", onDrop);
-      };
-      this.server.addListener("listening", onListening);
-      this.server.addListener("error", onError);
-      this.server.addListener("drop", onDrop);
-    });
-    this.listeningMultiaddr = ma;
-    this.safeDispatchEvent("listening");
-  }
-  onCertificateProvision(event) {
-    if (this.https != null) {
-      this.log("auto-tls certificate found but already listening on https");
-      return;
-    }
-    this.log("auto-tls certificate found, starting https server");
-    this.https = https.createServer({
-      ...this.httpsOptions,
-      ...event.detail
-    }, this.httpRequestHandler.bind(this));
-    this.https.addListener("upgrade", this.onUpgrade.bind(this));
-    this.https.addListener("tlsClientError", this.onTLSClientError.bind(this));
-    this.safeDispatchEvent("listening");
-  }
-  onCertificateRenew(event) {
-    this.https?.close();
-    this.log("auto-tls certificate renewed, restarting https server");
-    this.https = https.createServer({
-      ...this.httpsOptions,
-      ...event.detail
-    }, this.httpRequestHandler.bind(this));
-    this.https.addListener("upgrade", this.onUpgrade.bind(this));
-    this.https.addListener("tlsClientError", this.onTLSClientError.bind(this));
-  }
-  async close() {
-    this.server.close();
-    this.http?.close();
-    this.https?.close();
-    this.wsServer.close();
-    this.http?.closeAllConnections();
-    this.https?.closeAllConnections();
-    [...this.sockets].forEach((socket) => {
-      socket.destroy();
-    });
-    this.shutdownController.abort();
-    const events = [
-      pEvent(this.server, "close"),
-      pEvent(this.wsServer, "close")
-    ];
-    if (this.http != null) {
-      events.push(pEvent(this.http, "close"));
-    }
-    if (this.https != null) {
-      events.push(pEvent(this.https, "close"));
-    }
-    await Promise.all(events);
-    this.safeDispatchEvent("close");
-  }
-  getAddrs() {
-    const address = this.server.address();
-    if (address == null) {
-      return [];
-    }
-    if (typeof address === "string") {
-      return [multiaddr(`/unix/${encodeURIComponent(address)}/ws`)];
-    }
-    const multiaddrs = getThinWaistAddresses(this.listeningMultiaddr, address.port);
-    const insecureMultiaddrs = [];
-    if (this.http != null) {
-      multiaddrs.forEach((ma) => {
-        insecureMultiaddrs.push(ma.encapsulate("/ws"));
-      });
-    }
-    const secureMultiaddrs = [];
-    if (this.https != null) {
-      multiaddrs.forEach((ma) => {
-        secureMultiaddrs.push(ma.encapsulate("/tls/ws"));
-      });
-    }
-    return [
-      ...insecureMultiaddrs,
-      ...secureMultiaddrs
-    ];
-  }
-  updateAnnounceAddrs() {
-  }
-  httpRequestHandler(req, res) {
-    res.writeHead(400);
-    res.write("Only WebSocket connections are supported");
-    res.end();
-  }
-};
-function createListener(components, init) {
-  return new WebSocketListener(components, init);
-}
-
-// ../../node_modules/.pnpm/@libp2p+websockets@10.1.5/node_modules/@libp2p/websockets/dist/src/index.js
-var WebSockets2 = class {
-  log;
-  init;
-  logger;
-  metrics;
-  components;
-  constructor(components, init = {}) {
-    this.log = components.logger.forComponent("libp2p:websockets");
-    this.logger = components.logger;
-    this.components = components;
-    this.init = init;
-    if (components.metrics != null) {
-      this.metrics = {
-        dialerEvents: components.metrics.registerCounterGroup("libp2p_websockets_dialer_events_total", {
-          label: "event",
-          help: "Total count of WebSockets dialer events by type"
-        })
-      };
-    }
-  }
-  [transportSymbol] = true;
-  [Symbol.toStringTag] = "@libp2p/websockets";
-  [serviceCapabilities] = [
-    "@libp2p/transport"
-  ];
-  async dial(ma, options) {
-    this.log("dialing %s", ma);
-    options = options ?? {};
-    const maConn = webSocketToMaConn({
-      websocket: await this._connect(ma, options),
-      remoteAddr: ma,
-      metrics: this.metrics?.dialerEvents,
-      direction: "outbound",
-      log: this.components.logger.forComponent("libp2p:websockets:connection"),
-      maxBufferedAmount: this.init.maxBufferedAmount,
-      bufferedAmountPollInterval: this.init.bufferedAmountPollInterval
-    });
-    this.log("new outbound connection %s", maConn.remoteAddr);
-    const conn = await options.upgrader.upgradeOutbound(maConn, options);
-    this.log("outbound connection %s upgraded", maConn.remoteAddr);
-    return conn;
-  }
-  async _connect(ma, options) {
-    options?.signal?.throwIfAborted();
-    const uri = multiaddrToUri(ma);
-    this.log("create websocket connection to %s", uri);
-    const websocket = new WebSocket(uri);
-    websocket.binaryType = "arraybuffer";
-    try {
-      options.onProgress?.(new CustomProgressEvent("websockets:open-connection"));
-      await pEvent(websocket, "open", options);
-    } catch (err) {
-      if (options.signal?.aborted) {
-        this.metrics?.dialerEvents.increment({ abort: true });
-        throw new ConnectionFailedError(`Could not connect to ${uri}`);
-      } else {
-        this.metrics?.dialerEvents.increment({ error: true });
-      }
-      try {
-        websocket.close();
-      } catch {
-      }
-      throw err;
-    }
-    this.log("connected %s", ma);
-    this.metrics?.dialerEvents.increment({ connect: true });
-    return websocket;
-  }
-  /**
-   * Creates a WebSockets listener. The provided `handler` function will be called
-   * anytime a new incoming Connection has been successfully upgraded via
-   * `upgrader.upgradeInbound`
-   */
-  createListener(options) {
-    return createListener({
-      logger: this.logger,
-      events: this.components.events,
-      metrics: this.components.metrics
-    }, {
-      ...this.init,
-      ...options
-    });
-  }
-  listenFilter(multiaddrs) {
-    return multiaddrs.filter((ma) => WebSockets.exactMatch(ma) || WebSocketsSecure.exactMatch(ma));
-  }
-  dialFilter(multiaddrs) {
-    return this.listenFilter(multiaddrs);
-  }
-};
-function webSockets(init = {}) {
-  return (components) => {
-    return new WebSockets2(components, init);
-  };
-}
-
-// src/utils/logger.ts
-init_esm_shims();
-var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
-  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
-  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
-  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
-  LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
-  return LogLevel2;
-})(LogLevel || {});
-var Logger = class {
-  level;
-  prefix;
-  constructor(prefix, level = 1 /* INFO */) {
-    this.prefix = prefix;
-    this.level = level;
-  }
-  setLevel(level) {
-    this.level = level;
-  }
-  debug(message, ...args) {
-    if (this.level <= 0 /* DEBUG */) {
-      console.debug(`[${this.prefix}] DEBUG:`, message, ...args);
-    }
-  }
-  info(message, ...args) {
-    if (this.level <= 1 /* INFO */) {
-      console.info(`[${this.prefix}] INFO:`, message, ...args);
+      }
+      case "PONG": {
+        conn.peerCount = msg.peers;
+        logger.debug("Received PONG", { peers: msg.peers });
+        break;
+      }
+      case "GOODBYE": {
+        const goodbye = msg;
+        const reconnectAfter = goodbye.reconnectAfter || 5e3;
+        logger.info("Received GOODBYE", { url: conn.url, reconnectAfter });
+        if (conn.ws) {
+          conn.ws.close();
+        }
+        setTimeout(() => {
+          if (!stopped) {
+            connectToRelay(conn);
+          }
+        }, reconnectAfter);
+        break;
+      }
+      default:
+        logger.debug("Received relay message", { type: msg.type });
     }
   }
-  warn(message, ...args) {
-    if (this.level <= 2 /* WARN */) {
-      console.warn(`[${this.prefix}] WARN:`, message, ...args);
-    }
+  function getConnectedConnection() {
+    return connections.find((c) => c.connected && c.ws) || null;
   }
-  error(message, ...args) {
-    if (this.level <= 3 /* ERROR */) {
-      console.error(`[${this.prefix}] ERROR:`, message, ...args);
+  async function sendToRelay(msg) {
+    const conn = getConnectedConnection();
+    if (!conn || !conn.ws) {
+      throw new TransportError("No connected relay");
     }
+    conn.ws.send(encode(msg));
   }
-};
-var createLogger = (prefix, level) => {
-  return new Logger(prefix, level);
-};
-
-// src/transport/node.ts
-var logger = createLogger("transport");
-async function createNode(config) {
-  try {
-    const {
-      listenAddresses = ["/ip4/0.0.0.0/tcp/0", "/ip4/0.0.0.0/tcp/0/ws"],
-      // CVP-0010 §5: Add WebSocket listener
-      bootstrapPeers = [],
-      enableDHT = true,
-      enableRelay = false,
-      reserveRelaySlot = false,
-      enableMDNS = false,
-      privateKey
-    } = config;
-    const relayListenAddrs = reserveRelaySlot ? bootstrapPeers.map((peer) => `${peer}/p2p-circuit`) : [];
-    const libp2pConfig = {
-      addresses: {
-        listen: [...listenAddresses, ...relayListenAddrs]
-      },
-      ...privateKey ? { privateKey } : {},
-      transports: [
-        tcp(),
-        webSockets(),
-        // CVP-0010 §5: WebSocket for firewall traversal
-        circuitRelayTransport()
-      ],
-      connectionEncrypters: [noise()],
-      streamMuxers: [mplex()],
-      connectionManager: {
-        minConnections: bootstrapPeers.length > 0 ? 1 : 0,
-        maxConnections: 50
-      },
-      services: {
-        identify: identify(),
-        ping: ping()
+  return {
+    async start() {
+      stopped = false;
+      logger.info("Starting relay client", { relays: relayUrls.length });
+      for (let i = 0; i < connections.length; i++) {
+        const conn = connections[i];
+        setTimeout(() => {
+          connectToRelay(conn);
+        }, Math.random() * 2e3);
+      }
+      const maxWait = 15e3;
+      const start = Date.now();
+      while (Date.now() - start < maxWait) {
+        if (getConnectedConnection()) {
+          logger.info("Relay client started");
+          return;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 100));
       }
-    };
-    if (enableRelay) {
-      libp2pConfig.services.relay = circuitRelayServer({
-        reservations: {
-          maxReservations: 100
-          // Allow up to 100 concurrent relay reservations
+      throw new TransportError("Failed to connect to any relay");
+    },
+    async stop() {
+      stopped = true;
+      logger.info("Stopping relay client");
+      for (const conn of connections) {
+        if (conn.reconnectTimer) {
+          clearTimeout(conn.reconnectTimer);
+          conn.reconnectTimer = null;
+        }
+        if (conn.stableTimer) {
+          clearTimeout(conn.stableTimer);
+          conn.stableTimer = null;
         }
+        if (conn.pingTimer) {
+          clearInterval(conn.pingTimer);
+          conn.pingTimer = null;
+        }
+        if (conn.ws) {
+          conn.ws.close();
+          conn.ws = null;
+        }
+        conn.connected = false;
+      }
+      logger.info("Relay client stopped");
+    },
+    async sendEnvelope(toDid, envelopeBytes) {
+      const msg = {
+        type: "SEND",
+        to: toDid,
+        envelope: envelopeBytes
+      };
+      await sendToRelay(msg);
+      logger.debug("Sent envelope", { to: toDid, size: envelopeBytes.length });
+    },
+    async discover(query, minTrust, limit) {
+      const conn = getConnectedConnection();
+      const ws = conn?.ws;
+      if (!conn || !ws) {
+        throw new TransportError("No connected relay");
+      }
+      return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          reject(new TransportError("Discover timeout"));
+        }, 1e4);
+        const handler = (data) => {
+          try {
+            const msg = decode(data);
+            if (msg.type === "DISCOVERED") {
+              clearTimeout(timeout);
+              ws.off("message", handler);
+              resolve(msg.agents);
+            }
+          } catch (err) {
+          }
+        };
+        ws.on("message", handler);
+        ws.send(encode({ type: "DISCOVER", query, minTrust, limit }));
       });
-    }
-    if (enableDHT) {
-      libp2pConfig.services.dht = kadDHT({
-        clientMode: false,
-        peerInfoMapper: passthroughMapper,
-        validators: {
-          clawiverse: async () => {
+    },
+    async fetchCard(did2) {
+      const conn = getConnectedConnection();
+      const ws = conn?.ws;
+      if (!conn || !ws) {
+        throw new TransportError("No connected relay");
+      }
+      return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          reject(new TransportError("Fetch card timeout"));
+        }, 5e3);
+        const handler = (data) => {
+          try {
+            const msg = decode(data);
+            if (msg.type === "CARD" && msg.did === did2) {
+              clearTimeout(timeout);
+              ws.off("message", handler);
+              resolve(msg.card);
+            }
+          } catch (err) {
           }
-        },
-        selectors: {
-          clawiverse: () => 0
-        },
-        // Optimize for small networks: reduce replication factor and query timeout
-        kBucketSize: 20,
-        // Default K=20, keep for compatibility
-        querySelfInterval: 3e4,
-        // Self-query every 30 seconds (libp2p default)
-        // Allow queries to complete faster in small networks
-        allowQueryWithZeroPeers: true
+        };
+        ws.on("message", handler);
+        ws.send(encode({ type: "FETCH_CARD", did: did2 }));
       });
+    },
+    onDeliver(handler) {
+      deliveryHandler = handler;
+    },
+    onDeliveryReport(handler) {
+      deliveryReportHandler = handler;
+    },
+    isConnected() {
+      return getConnectedConnection() !== null;
+    },
+    getConnectedRelays() {
+      return connections.filter((c) => c.connected).map((c) => c.url);
+    },
+    getPeerCount() {
+      const conn = getConnectedConnection();
+      return conn ? conn.peerCount : 0;
     }
-    const peerDiscovery = [];
-    if (bootstrapPeers.length > 0) peerDiscovery.push(bootstrap({ list: bootstrapPeers }));
-    if (enableMDNS) {
-      const { mdns } = await import('@libp2p/mdns');
-      peerDiscovery.push(mdns());
-    }
-    if (peerDiscovery.length > 0) libp2pConfig.peerDiscovery = peerDiscovery;
-    const libp2p = await createLibp2p(libp2pConfig);
-    logger.info("Libp2p node created", {
-      listenAddresses: libp2pConfig.addresses.listen,
-      reserveRelaySlot
-    });
-    return {
-      libp2p,
-      start: async () => {
-        await libp2p.start();
-        logger.info("Node started", {
-          peerId: libp2p.peerId.toString(),
-          addresses: libp2p.getMultiaddrs().map((ma) => ma.toString()),
-          relay: enableRelay,
-          reserveRelaySlot
-        });
-      },
-      stop: async () => {
-        await libp2p.stop();
-        logger.info("Node stopped");
-      },
-      getMultiaddrs: () => {
-        return libp2p.getMultiaddrs().map((ma) => ma.toString());
-      },
-      getPeerId: () => {
-        return libp2p.peerId.toString();
-      }
-    };
-  } catch (error) {
-    throw new TransportError("Failed to create transport node", error);
-  }
+  };
 }
 
-// src/discovery/agent-card.ts
-init_esm_shims();
+// src/transport/relay-types.ts
+var RELAY_PROTOCOL_VERSION = 1;
 
 // src/discovery/agent-card-types.ts
-init_esm_shims();
 function isLegacyCard(card) {
   return Array.isArray(card.capabilities) && card.capabilities.length > 0 && typeof card.capabilities[0] === "string";
 }
@@ -3137,7 +629,6 @@ function matchesCapability(card, capability) {
 }
 
 // src/discovery/agent-card-schema.ts
-init_esm_shims();
 var CLAWIVERSE_CONTEXT = "https://clawiverse.org/context/v1";
 var SCHEMA_ORG_CONTEXT = "https://schema.org";
 var clawiverseContext = {
@@ -3196,9 +687,6 @@ function isValidContext(context) {
   if (!Array.isArray(context)) return false;
   return context.every((c) => typeof c === "string");
 }
-
-// src/discovery/agent-card-encoder.ts
-init_esm_shims();
 function encodeForDHT(card) {
   try {
     const { "@context": _, ...cardWithoutContext } = card;
@@ -3267,15 +755,70 @@ function getEncodedSize(card) {
   };
 }
 
-// src/discovery/dht.ts
-init_esm_shims();
-
-// src/discovery/semantic-search.ts
-init_esm_shims();
-
-// src/discovery/search-index.ts
-init_esm_shims();
-var logger2 = createLogger("search-index");
+// src/discovery/relay-index.ts
+var logger2 = createLogger("relay-index");
+function createRelayIndexOperations(client) {
+  return {
+    publishAgentCard: async (card) => {
+      logger2.debug("Agent Card published via HELLO", { did: card.did });
+    },
+    queryAgentCard: async (did) => {
+      try {
+        const card = await client.fetchCard(did);
+        if (card) {
+          logger2.debug("Found Agent Card via relay", { did });
+        } else {
+          logger2.debug("Agent Card not found via relay", { did });
+        }
+        return card;
+      } catch (error) {
+        logger2.warn("Failed to query Agent Card", { did, error });
+        return null;
+      }
+    },
+    queryByCapability: async (capability) => {
+      try {
+        const results = await client.discover(capability);
+        const cards = results.map((r) => r.card);
+        logger2.debug("Query by capability", { capability, count: cards.length });
+        return cards;
+      } catch (error) {
+        throw new DiscoveryError("Failed to query by capability", error);
+      }
+    },
+    searchSemantic: async (query) => {
+      try {
+        const queryText = query.text || query.capability || "";
+        const minTrust = query.filters?.minTrustScore;
+        const limit = query.limit || 10;
+        const results = await client.discover(queryText, minTrust, limit);
+        const cards = results.map((r) => r.card);
+        logger2.debug("Semantic search", { query: queryText, count: cards.length });
+        return cards;
+      } catch (error) {
+        throw new DiscoveryError("Failed to perform semantic search", error);
+      }
+    },
+    resolveDID: async (did) => {
+      try {
+        const relays = client.getConnectedRelays();
+        if (relays.length === 0) {
+          logger2.debug("DID resolution failed: no connected relays", { did });
+          return null;
+        }
+        logger2.debug("Resolved DID to relay", { did, relay: relays[0] });
+        return { relayUrl: relays[0] };
+      } catch (error) {
+        logger2.warn("Failed to resolve DID", { did, error });
+        return null;
+      }
+    },
+    queryRelayPeers: async () => {
+      return client.getConnectedRelays();
+    }
+  };
+}
+var logger3 = createLogger("search-index");
 var SearchIndex = class {
   cards = /* @__PURE__ */ new Map();
   lunrIndex;
@@ -3287,7 +830,7 @@ var SearchIndex = class {
   indexAgentCard(card) {
     this.cards.set(card.did, card);
     this.needsRebuild = true;
-    logger2.debug("Indexed Agent Card", { did: card.did, capabilities: card.capabilities.length });
+    logger3.debug("Indexed Agent Card", { did: card.did, capabilities: card.capabilities.length });
   }
   /**
    * Remove an Agent Card from the index
@@ -3295,7 +838,7 @@ var SearchIndex = class {
   removeAgentCard(did) {
     this.cards.delete(did);
     this.needsRebuild = true;
-    logger2.debug("Removed Agent Card from index", { did });
+    logger3.debug("Removed Agent Card from index", { did });
   }
   /**
    * Search for agents matching a query
@@ -3322,7 +865,7 @@ var SearchIndex = class {
     if (query.limit) {
       results = results.slice(0, query.limit);
     }
-    logger2.debug("Search completed", { query, results: results.length });
+    logger3.debug("Search completed", { query, results: results.length });
     return results;
   }
   /**
@@ -3339,7 +882,7 @@ var SearchIndex = class {
     this.lunrIndex = void 0;
     this.fuse = void 0;
     this.needsRebuild = false;
-    logger2.info("Search index cleared");
+    logger3.info("Search index cleared");
   }
   /**
    * Get index size
@@ -3351,7 +894,7 @@ var SearchIndex = class {
    * Rebuild search indexes
    */
   rebuild() {
-    logger2.info("Rebuilding search indexes", { cards: this.cards.size });
+    logger3.info("Rebuilding search indexes", { cards: this.cards.size });
     const cards = Array.from(this.cards.values());
     this.lunrIndex = lunr(function() {
       this.ref("did");
@@ -3378,7 +921,7 @@ var SearchIndex = class {
       includeScore: true
     });
     this.needsRebuild = false;
-    logger2.info("Search indexes rebuilt");
+    logger3.info("Search indexes rebuilt");
   }
   /**
    * Search by text using Lunr
@@ -3436,7 +979,6 @@ var SearchIndex = class {
 };
 
 // src/discovery/capability-matcher.ts
-init_esm_shims();
 var CapabilityMatcher = class {
   /**
    * Match a query against a capability
@@ -3590,7 +1132,7 @@ var CapabilityMatcher = class {
 };
 
 // src/discovery/semantic-search.ts
-var logger3 = createLogger("semantic-search");
+var logger4 = createLogger("semantic-search");
 var SemanticSearchEngine = class {
   constructor(dht) {
     this.dht = dht;
@@ -3604,12 +1146,12 @@ var SemanticSearchEngine = class {
    * Local-first with network fallback
    */
   async search(query) {
-    logger3.info("Searching for agents", { query });
+    logger4.info("Searching for agents", { query });
     const localResults = this.index.search(query);
-    logger3.debug("Local search results", { count: localResults.length });
+    logger4.debug("Local search results", { count: localResults.length });
     const limit = query.limit || 10;
     if (localResults.length < limit && this.dht) {
-      logger3.debug("Insufficient local results, querying network");
+      logger4.debug("Insufficient local results, querying network");
       const networkResults = await this.searchNetwork(query);
       return this.mergeResults(localResults, networkResults, limit);
     }
@@ -3655,17 +1197,17 @@ var SemanticSearchEngine = class {
     try {
       const capability = query.capability || this.extractPrimaryCapability(query.text);
       if (!capability) {
-        logger3.debug("No capability extracted from query, skipping network search");
+        logger4.debug("No capability extracted from query, skipping network search");
         return [];
       }
       const cards = await this.dht.queryByCapability(capability);
-      logger3.debug("Network search results", { count: cards.length });
+      logger4.debug("Network search results", { count: cards.length });
       return cards.map((card) => {
         const score = this.scoreCard(card, query);
         return { card, score };
       });
     } catch (error) {
-      logger3.error("Network search failed", { error });
+      logger4.error("Network search failed", { error });
       return [];
     }
   }
@@ -3749,238 +1291,7 @@ function createSemanticSearch(dht) {
   return new SemanticSearchEngine(dht);
 }
 
-// src/discovery/dht.ts
-var logger4 = createLogger("dht");
-var peerCache = /* @__PURE__ */ new Map();
-var CACHE_TTL = 5 * 60 * 1e3;
-function extractValue(event) {
-  if (event.name === "VALUE" && event.value) return event.value;
-  if (event.name === "PEER_RESPONSE" && event.value) return event.value;
-  return null;
-}
-function capKey(cap) {
-  return cap.toLowerCase().replace(/[^a-z0-9_-]/g, "_");
-}
-async function readDIDList(dht, key) {
-  try {
-    for await (const event of dht.get(key, { signal: AbortSignal.timeout(3e4) })) {
-      const raw = extractValue(event);
-      if (raw) {
-        const text = toString(raw);
-        return text.split("\n").filter(Boolean);
-      }
-    }
-  } catch {
-  }
-  return [];
-}
-async function writeDIDList(dht, key, dids) {
-  const value2 = fromString([...new Set(dids)].join("\n"));
-  for (let attempt = 1; attempt <= 3; attempt++) {
-    try {
-      for await (const _ of dht.put(key, value2, { signal: AbortSignal.timeout(3e4) })) {
-      }
-      return;
-    } catch (e) {
-      if (e?.name === "AbortError" && attempt < 3) {
-        logger4.debug(`DHT put timeout, retrying (${attempt}/3)...`);
-        continue;
-      }
-      if (e?.name !== "AbortError") throw e;
-    }
-  }
-}
-function createDHTOperations(libp2p) {
-  const operations = {};
-  const searchEngine = createSemanticSearch(operations);
-  return Object.assign(operations, {
-    publishAgentCard: async (card) => {
-      try {
-        const dht = libp2p.services?.dht;
-        if (!dht) throw new DiscoveryError("DHT service not available");
-        const agentKey = fromString(`/clawiverse/agent/${card.did}`);
-        for (let attempt = 1; attempt <= 3; attempt++) {
-          try {
-            for await (const _ of dht.put(agentKey, encodeForDHT(card), { signal: AbortSignal.timeout(3e4) })) {
-            }
-            break;
-          } catch (e) {
-            if (e?.name === "AbortError" && attempt < 3) {
-              logger4.debug(`DHT put agent card timeout, retrying (${attempt}/3)...`);
-              continue;
-            }
-            logger4.warn("DHT put agent card failed (non-fatal)", { error: e.message });
-            break;
-          }
-        }
-        const caps = (card.capabilities ?? []).flatMap((c) => {
-          if (typeof c === "string") return [c];
-          return [c.name, c.id].filter((v) => typeof v === "string" && v.length > 0);
-        });
-        caps.push("__all__");
-        const importantCaps = ["__all__"];
-        if (caps.some((cap) => capKey(cap) === "relay")) {
-          importantCaps.push("relay");
-        }
-        await Promise.all(importantCaps.map(async (cap) => {
-          const capKeyStr = `/clawiverse/cap/${capKey(cap)}`;
-          const capDHTKey = fromString(capKeyStr);
-          try {
-            const existing = await readDIDList(dht, capDHTKey);
-            if (!existing.includes(card.did)) {
-              await writeDIDList(dht, capDHTKey, [...existing, card.did]);
-              logger4.debug("Indexed capability in DHT", { cap: capKey(cap), did: card.did });
-            }
-          } catch (e) {
-            logger4.warn("Failed to index capability (non-fatal)", { cap: capKey(cap), error: e.message });
-          }
-        }));
-        searchEngine.indexAgentCard(card);
-        logger4.info("Published Agent Card to DHT", { did: card.did });
-      } catch (error) {
-        logger4.warn("Failed to publish Agent Card to DHT (non-fatal)", { error: error.message });
-        searchEngine.indexAgentCard(card);
-      }
-    },
-    queryAgentCard: async (did) => {
-      try {
-        const dht = libp2p.services?.dht;
-        if (!dht) throw new DiscoveryError("DHT service not available");
-        const key = fromString(`/clawiverse/agent/${did}`);
-        for await (const event of dht.get(key)) {
-          const raw = extractValue(event);
-          if (raw) {
-            const card = decodeFromCBOR(raw);
-            searchEngine.indexAgentCard(card);
-            logger4.debug("Found Agent Card in DHT", { did });
-            return card;
-          }
-        }
-        logger4.debug("Agent Card not found in DHT", { did });
-        return null;
-      } catch (error) {
-        logger4.warn("Failed to query Agent Card", { did, error });
-        return null;
-      }
-    },
-    queryByCapability: async (capability) => {
-      try {
-        const dht = libp2p.services?.dht;
-        const local = searchEngine.getAllIndexedCards().filter(
-          (card) => card.capabilities.some((cap) => {
-            const name = typeof cap === "string" ? cap : cap.name;
-            return name?.toLowerCase().includes(capability.toLowerCase());
-          })
-        );
-        if (local.length > 0) return local;
-        if (!dht) return [];
-        const capDHTKey = fromString(`/clawiverse/cap/${capKey(capability)}`);
-        const dids = await readDIDList(dht, capDHTKey);
-        logger4.debug("DHT capability index", { capability, dids });
-        const cards = await Promise.all(
-          dids.map(async (did) => {
-            const key = fromString(`/clawiverse/agent/${did}`);
-            try {
-              for await (const event of dht.get(key)) {
-                const raw = extractValue(event);
-                if (raw) {
-                  const card = decodeFromCBOR(raw);
-                  searchEngine.indexAgentCard(card);
-                  return card;
-                }
-              }
-            } catch {
-            }
-            return null;
-          })
-        );
-        return cards.filter((c) => c !== null);
-      } catch (error) {
-        throw new DiscoveryError("Failed to query by capability", error);
-      }
-    },
-    searchSemantic: async (query) => {
-      try {
-        const dht = libp2p.services?.dht;
-        if (dht) {
-          const allKey = fromString("/clawiverse/cap/__all__");
-          const dids = await readDIDList(dht, allKey);
-          logger4.debug("DHT __all__ index", { count: dids.length });
-          await Promise.all(
-            dids.map(async (did) => {
-              const key = fromString(`/clawiverse/agent/${did}`);
-              try {
-                for await (const event of dht.get(key)) {
-                  const raw = extractValue(event);
-                  if (raw) {
-                    searchEngine.indexAgentCard(decodeFromCBOR(raw));
-                    break;
-                  }
-                }
-              } catch {
-              }
-            })
-          );
-        }
-        return searchEngine.search(query);
-      } catch (error) {
-        throw new DiscoveryError("Failed to perform semantic search", error);
-      }
-    },
-    queryRelayPeers: async () => {
-      const dht = libp2p.services?.dht;
-      if (!dht) return [];
-      const capDHTKey = fromString("/clawiverse/cap/relay");
-      const dids = await readDIDList(dht, capDHTKey);
-      const addrs = [];
-      await Promise.all(dids.map(async (did) => {
-        const card = await operations.queryAgentCard(did);
-        if (card?.endpoints) {
-          addrs.push(...card.endpoints.filter((e) => !e.includes("/p2p-circuit/")));
-        }
-      }));
-      return addrs;
-    },
-    resolveDID: async (did) => {
-      try {
-        const cached = peerCache.get(did);
-        if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
-          logger4.debug("Using cached peer info", { did });
-          return { peerId: cached.peerId, multiaddrs: cached.multiaddrs };
-        }
-        const dht = libp2p.services?.dht;
-        if (!dht) throw new DiscoveryError("DHT service not available");
-        const key = fromString(`/clawiverse/agent/${did}`);
-        for await (const event of dht.get(key)) {
-          const raw = extractValue(event);
-          if (raw) {
-            const card = decodeFromCBOR(raw);
-            if (card.peerId) {
-              logger4.debug("Resolved DID to peer", { did, peerId: card.peerId });
-              const result = { peerId: card.peerId, multiaddrs: card.endpoints || [] };
-              peerCache.set(did, {
-                peerId: result.peerId,
-                multiaddrs: result.multiaddrs,
-                timestamp: Date.now()
-              });
-              return result;
-            }
-            logger4.warn("Agent Card found but has no peerId", { did });
-            return null;
-          }
-        }
-        logger4.debug("DID not found in DHT", { did });
-        return null;
-      } catch (error) {
-        logger4.warn("Failed to resolve DID", { did, error });
-        return null;
-      }
-    }
-  });
-}
-
 // src/messaging/envelope.ts
-init_esm_shims();
 function createEnvelope(from, to, type, protocol, payload, replyTo) {
   return {
     id: generateMessageId(),
@@ -4027,9 +1338,6 @@ function validateEnvelope(msg) {
 function generateMessageId() {
   return `msg_${Date.now()}_${Math.random().toString(36).substring(2, 15)}`;
 }
-
-// src/messaging/codec.ts
-init_esm_shims();
 function encodeMessage(envelope) {
   try {
     return encode(envelope);
@@ -4060,24 +1368,11 @@ function decodeMessageJSON(json) {
 }
 
 // src/messaging/router.ts
-init_esm_shims();
 var logger5 = createLogger("router");
-function concatUint8Arrays(arrays) {
-  if (arrays.length === 0) return new Uint8Array(0);
-  if (arrays.length === 1) return arrays[0];
-  const totalLength = arrays.reduce((acc, arr) => acc + arr.length, 0);
-  const result = new Uint8Array(totalLength);
-  let offset = 0;
-  for (const arr of arrays) {
-    result.set(arr, offset);
-    offset += arr.length;
-  }
-  return result;
-}
-function createMessageRouter(libp2p, verifyFn, dht, relayPeers) {
+function createMessageRouter(relayClient, verifyFn) {
   const handlers = /* @__PURE__ */ new Map();
   let catchAllHandler;
-  const PROTOCOL_PREFIX = "/clawiverse/msg/1.0.0";
+  const pendingRequests = /* @__PURE__ */ new Map();
   return {
     registerHandler: (protocol, handler) => {
       handlers.set(protocol, handler);
@@ -4091,134 +1386,14 @@ function createMessageRouter(libp2p, verifyFn, dht, relayPeers) {
       catchAllHandler = handler;
       logger5.info("Registered catch-all message handler");
     },
-    sendMessage: async (envelope, peerHint) => {
+    sendMessage: async (envelope) => {
       try {
         if (!validateEnvelope(envelope)) {
           throw new MessagingError("Invalid message envelope");
         }
-        let targetPeerIdStr;
-        let targetMultiaddrs = [];
-        if (peerHint) {
-          targetPeerIdStr = peerHint.peerId;
-          targetMultiaddrs = peerHint.multiaddrs;
-          logger5.info("Using peer hint for direct addressing", { peerId: targetPeerIdStr });
-        } else if (dht) {
-          const resolved = await dht.resolveDID(envelope.to);
-          if (resolved) {
-            targetPeerIdStr = resolved.peerId;
-            targetMultiaddrs = resolved.multiaddrs;
-          }
-        }
-        if (!targetPeerIdStr) {
-          throw new MessagingError(
-            `Cannot resolve recipient: ${envelope.to} \u2014 provide peerHint or ensure agent is in DHT`
-          );
-        }
-        const targetPeerId = peerIdFromString(targetPeerIdStr);
-        if (targetMultiaddrs.length > 0) {
-          const mas = targetMultiaddrs.map((a) => multiaddr(a));
-          await libp2p.peerStore.merge(targetPeerId, { multiaddrs: mas });
-        }
-        logger5.info("Dialing peer for message delivery", {
-          peerId: targetPeerIdStr,
-          multiaddrs: targetMultiaddrs
-        });
-        let stream;
-        const DIAL_TIMEOUT = 3e3;
-        const relayMultiaddrs = targetMultiaddrs.filter((a) => a.includes("/p2p-circuit/"));
-        const directMultiaddrs = targetMultiaddrs.filter((a) => !a.includes("/p2p-circuit/"));
-        if (directMultiaddrs.length > 0) {
-          const directDialPromises = directMultiaddrs.map(async (addr) => {
-            try {
-              const conn = await libp2p.dial(multiaddr(addr), {
-                signal: AbortSignal.timeout(DIAL_TIMEOUT)
-              });
-              const s = await conn.newStream(PROTOCOL_PREFIX, { runOnLimitedConnection: true });
-              logger5.info("Direct dial succeeded", { addr });
-              return { conn, stream: s };
-            } catch {
-              return null;
-            }
-          });
-          const winner = await Promise.race(
-            directDialPromises.map((p) => p.then((r) => r || Promise.reject()))
-          ).catch(() => void 0);
-          if (winner) {
-            stream = winner.stream;
-            Promise.allSettled(directDialPromises).then((results) => {
-              for (const result of results) {
-                if (result.status === "fulfilled" && result.value && result.value.stream !== stream) {
-                  result.value.conn.close().catch(() => {
-                  });
-                }
-              }
-            });
-          }
-        }
-        let lastError;
-        if (!stream) {
-          const allRelayAddrs = [
-            ...relayMultiaddrs,
-            ...(relayPeers ?? []).map((r) => buildCircuitRelayAddr(r, targetPeerIdStr))
-          ];
-          const uniqueRelayAddrs = [...new Set(allRelayAddrs)];
-          if (uniqueRelayAddrs.length > 0) {
-            const relayDialPromises = uniqueRelayAddrs.map(async (addr) => {
-              try {
-                const conn = await libp2p.dial(multiaddr(addr), {
-                  signal: AbortSignal.timeout(DIAL_TIMEOUT)
-                });
-                logger5.info("Relay connection established", { addr });
-                const s = await conn.newStream(PROTOCOL_PREFIX, { runOnLimitedConnection: true });
-                logger5.info("Relay stream opened", { addr });
-                return { conn, stream: s };
-              } catch (relayErr) {
-                logger5.warn("Relay dial failed", { addr, error: relayErr.message });
-                lastError = relayErr;
-                return null;
-              }
-            });
-            const winner = await Promise.race(
-              relayDialPromises.map((p) => p.then((r) => r || Promise.reject()))
-            ).catch(() => void 0);
-            if (winner) {
-              stream = winner.stream;
-              Promise.allSettled(relayDialPromises).then((results) => {
-                for (const result of results) {
-                  if (result.status === "fulfilled" && result.value && result.value.stream !== stream) {
-                    result.value.conn.close().catch(() => {
-                    });
-                  }
-                }
-              });
-            }
-          }
-        }
-        if (!stream && dht && "queryRelayPeers" in dht) {
-          const discoveredRelays = await dht.queryRelayPeers();
-          for (const relayAddr of discoveredRelays) {
-            const circuitAddr = buildCircuitRelayAddr(relayAddr, targetPeerIdStr);
-            try {
-              const conn = await libp2p.dial(multiaddr(circuitAddr));
-              stream = await conn.newStream(PROTOCOL_PREFIX, { runOnLimitedConnection: true });
-              logger5.info("DHT-discovered relay succeeded", { relayAddr });
-              break;
-            } catch (e) {
-              logger5.warn("DHT relay failed", { relayAddr, error: e.message });
-              lastError = e;
-            }
-          }
-        }
-        if (!stream) {
-          throw lastError ?? new MessagingError("All dial attempts failed (including DHT-discovered relays)");
-        }
         const encoded = encodeMessage(envelope);
-        await stream.sink(
-          (async function* () {
-            yield encoded;
-          })()
-        );
-        logger5.info("Message sent over libp2p stream", {
+        await relayClient.sendEnvelope(envelope.to, encoded);
+        logger5.info("Message sent via relay", {
           id: envelope.id,
           from: envelope.from,
           to: envelope.to,
@@ -4226,38 +1401,15 @@ function createMessageRouter(libp2p, verifyFn, dht, relayPeers) {
         });
         if (envelope.type === "request") {
           logger5.debug("Waiting for response to request", { id: envelope.id });
-          try {
-            const RESPONSE_TIMEOUT = 3e4;
-            const responsePromise = (async () => {
-              const responseChunks = [];
-              for await (const chunk of stream.source) {
-                responseChunks.push(chunk.subarray());
-              }
-              if (responseChunks.length > 0) {
-                const responseData = concatUint8Arrays(responseChunks);
-                const responseEnvelope = decodeMessage(responseData);
-                logger5.info("Received response", {
-                  id: responseEnvelope.id,
-                  replyTo: responseEnvelope.replyTo
-                });
-                return responseEnvelope;
-              } else {
-                logger5.warn("No response received for request", { id: envelope.id });
-                return void 0;
-              }
-            })();
-            const timeoutPromise = new Promise((resolve) => {
-              setTimeout(() => {
-                logger5.warn("Response timeout", { id: envelope.id, timeout: RESPONSE_TIMEOUT });
-                resolve(void 0);
-              }, RESPONSE_TIMEOUT);
-            });
-            const response = await Promise.race([responsePromise, timeoutPromise]);
-            return response;
-          } catch (error) {
-            logger5.warn("Error reading response", { error });
-            return void 0;
-          }
+          const RESPONSE_TIMEOUT = 3e4;
+          return new Promise((resolve) => {
+            const timeout = setTimeout(() => {
+              pendingRequests.delete(envelope.id);
+              logger5.warn("Response timeout", { id: envelope.id, timeout: RESPONSE_TIMEOUT });
+              resolve(void 0);
+            }, RESPONSE_TIMEOUT);
+            pendingRequests.set(envelope.id, { resolve, timeout });
+          });
         }
         return void 0;
       } catch (error) {
@@ -4266,113 +1418,100 @@ function createMessageRouter(libp2p, verifyFn, dht, relayPeers) {
       }
     },
     start: async () => {
-      await libp2p.handle(PROTOCOL_PREFIX, async ({ stream }) => {
+      relayClient.onDeliver(async (deliverMsg) => {
         try {
-          await handleIncomingStream(stream, handlers, catchAllHandler, verifyFn);
+          const envelope = decodeMessage(deliverMsg.envelope);
+          if (!validateEnvelope(envelope)) {
+            logger5.warn("Received invalid message envelope");
+            return;
+          }
+          const isValidSignature = await verifyEnvelope(envelope, async (signature, data) => {
+            const senderPublicKey = extractPublicKey(envelope.from);
+            return verify(signature, data, senderPublicKey);
+          });
+          if (!isValidSignature) {
+            logger5.warn("Received message with invalid signature", {
+              id: envelope.id,
+              from: envelope.from
+            });
+            return;
+          }
+          try {
+            const { signature, ...envelopeWithoutSig } = envelope;
+            const dataBytes = new TextEncoder().encode(JSON.stringify(envelopeWithoutSig));
+            const signatureBytes = Buffer.from(signature, "hex");
+            const hookValid = await verifyFn(signatureBytes, dataBytes);
+            if (!hookValid) {
+              logger5.warn("Message rejected by custom verifier", {
+                id: envelope.id,
+                from: envelope.from
+              });
+              return;
+            }
+          } catch (error) {
+            logger5.warn("Custom verification hook failed", {
+              id: envelope.id,
+              from: envelope.from,
+              error: error.message
+            });
+            return;
+          }
+          logger5.info("Received message", {
+            id: envelope.id,
+            from: envelope.from,
+            to: envelope.to,
+            protocol: envelope.protocol,
+            type: envelope.type
+          });
+          if (envelope.type === "response" && envelope.replyTo) {
+            const pending = pendingRequests.get(envelope.replyTo);
+            if (pending) {
+              clearTimeout(pending.timeout);
+              pendingRequests.delete(envelope.replyTo);
+              pending.resolve(envelope);
+              logger5.info("Matched response to pending request", {
+                requestId: envelope.replyTo,
+                responseId: envelope.id
+              });
+              return;
+            }
+          }
+          const handler = handlers.get(envelope.protocol);
+          let response = void 0;
+          if (handler) {
+            response = await handler(envelope);
+          } else if (catchAllHandler) {
+            logger5.debug("Using catch-all handler for protocol", { protocol: envelope.protocol });
+            response = await catchAllHandler(envelope);
+          } else {
+            logger5.warn("No handler for protocol", { protocol: envelope.protocol });
+          }
+          if (response) {
+            const encoded = encodeMessage(response);
+            await relayClient.sendEnvelope(response.to, encoded);
+            logger5.info("Sent response back to sender", {
+              responseId: response.id,
+              replyTo: response.replyTo
+            });
+          }
         } catch (error) {
-          logger5.error("Error handling incoming stream", error);
+          logger5.error("Error handling incoming message", error);
         }
-      }, { runOnLimitedConnection: true });
+      });
       logger5.info("Message router started");
     },
     stop: async () => {
-      await libp2p.unhandle(PROTOCOL_PREFIX);
+      for (const [, pending] of pendingRequests.entries()) {
+        clearTimeout(pending.timeout);
+        pending.resolve(void 0);
+      }
+      pendingRequests.clear();
       handlers.clear();
       catchAllHandler = void 0;
       logger5.info("Message router stopped");
     }
   };
 }
-function buildCircuitRelayAddr(relayAddr, targetPeerId) {
-  return `${relayAddr}/p2p-circuit/p2p/${targetPeerId}`;
-}
-async function handleIncomingStream(stream, handlers, catchAllHandler, verifyFn) {
-  try {
-    const chunks = [];
-    for await (const chunk of stream.source) {
-      chunks.push(chunk.subarray());
-    }
-    const data = concatUint8Arrays(chunks);
-    if (data.length === 0) {
-      logger5.debug("Received empty stream, ignoring");
-      return;
-    }
-    const envelope = decodeMessage(data);
-    if (!validateEnvelope(envelope)) {
-      logger5.warn("Received invalid message envelope");
-      return;
-    }
-    const isValidSignature = await verifyEnvelope(envelope, async (signature, data2) => {
-      const senderPublicKey = extractPublicKey(envelope.from);
-      return verify(signature, data2, senderPublicKey);
-    });
-    if (!isValidSignature) {
-      logger5.warn("Received message with invalid signature", {
-        id: envelope.id,
-        from: envelope.from
-      });
-      return;
-    }
-    try {
-      const { signature, ...envelopeWithoutSig } = envelope;
-      const dataBytes = new TextEncoder().encode(JSON.stringify(envelopeWithoutSig));
-      const signatureBytes = Buffer.from(signature, "hex");
-      const hookValid = await verifyFn(signatureBytes, dataBytes);
-      if (!hookValid) {
-        logger5.warn("Message rejected by custom verifier", {
-          id: envelope.id,
-          from: envelope.from
-        });
-        return;
-      }
-    } catch (error) {
-      logger5.warn("Custom verification hook failed", {
-        id: envelope.id,
-        from: envelope.from,
-        error: error.message
-      });
-      return;
-    }
-    logger5.info("Received message", {
-      id: envelope.id,
-      from: envelope.from,
-      to: envelope.to,
-      protocol: envelope.protocol,
-      payload: envelope.payload
-    });
-    const handler = handlers.get(envelope.protocol);
-    let response = void 0;
-    if (handler) {
-      response = await handler(envelope);
-    } else if (catchAllHandler) {
-      logger5.debug("Using catch-all handler for protocol", { protocol: envelope.protocol });
-      response = await catchAllHandler(envelope);
-    } else {
-      logger5.warn("No handler for protocol", { protocol: envelope.protocol });
-    }
-    if (response) {
-      const encoded = encodeMessage(response);
-      logger5.info("Sending response back to sender", {
-        responseId: response.id,
-        replyTo: response.replyTo,
-        size: encoded.length
-      });
-      await stream.sink(
-        (async function* () {
-          yield encoded;
-        })()
-      );
-    }
-  } catch (error) {
-    logger5.error("Error handling incoming message", error);
-  }
-}
-
-// src/messaging/types.ts
-init_esm_shims();
-
-// src/messaging/storage.ts
-init_esm_shims();
 var logger6 = createLogger("message-storage");
 var MessageStorage = class {
   db;
@@ -4403,12 +1542,12 @@ var MessageStorage = class {
   async getMessage(id) {
     for (const direction of ["inbound", "outbound"]) {
       const prefix = `msg:${direction}:`;
-      for await (const [, value2] of this.db.iterator({
+      for await (const [, value] of this.db.iterator({
         gte: prefix,
         lte: prefix + "\xFF",
         valueEncoding: "json"
       })) {
-        if (value2.envelope.id === id) return value2;
+        if (value.envelope.id === id) return value;
       }
     }
     return null;
@@ -4437,20 +1576,20 @@ var MessageStorage = class {
     const results = [];
     let total = 0;
     let skipped = 0;
-    for await (const [, value2] of this.db.iterator({
+    for await (const [, value] of this.db.iterator({
       gte: prefix,
       lte: prefix + "\xFF",
       reverse: true,
       // newest first
       valueEncoding: "json"
     })) {
-      if (!this.matchesFilter(value2, filter)) continue;
+      if (!this.matchesFilter(value, filter)) continue;
       total++;
       if (skipped < offset) {
         skipped++;
         continue;
       }
-      if (results.length < limit) results.push(value2);
+      if (results.length < limit) results.push(value);
     }
     return {
       messages: results,
@@ -4487,12 +1626,12 @@ var MessageStorage = class {
   async countMessages(direction, filter = {}) {
     const prefix = `msg:${direction}:`;
     let count = 0;
-    for await (const [, value2] of this.db.iterator({
+    for await (const [, value] of this.db.iterator({
       gte: prefix,
       lte: prefix + "\xFF",
       valueEncoding: "json"
     })) {
-      if (this.matchesFilter(value2, filter)) count++;
+      if (this.matchesFilter(value, filter)) count++;
     }
     return count;
   }
@@ -4515,12 +1654,12 @@ var MessageStorage = class {
   }
   async listBlocked() {
     const results = [];
-    for await (const [, value2] of this.db.iterator({
+    for await (const [, value] of this.db.iterator({
       gte: "block:",
       lte: "block:\xFF",
       valueEncoding: "json"
     })) {
-      results.push(value2);
+      results.push(value);
     }
     return results;
   }
@@ -4543,12 +1682,12 @@ var MessageStorage = class {
   }
   async listAllowed() {
     const results = [];
-    for await (const [, value2] of this.db.iterator({
+    for await (const [, value] of this.db.iterator({
       gte: "allow:",
       lte: "allow:\xFF",
       valueEncoding: "json"
     })) {
-      results.push(value2);
+      results.push(value);
     }
     return results;
   }
@@ -4566,12 +1705,12 @@ var MessageStorage = class {
   async cleanupSeen(maxAgeMs) {
     const cutoff = Date.now() - maxAgeMs;
     const toDelete = [];
-    for await (const [key, value2] of this.db.iterator({
+    for await (const [key, value] of this.db.iterator({
       gte: "seen:",
       lte: "seen:\xFF",
       valueEncoding: "json"
     })) {
-      if (value2.seenAt < cutoff) toDelete.push(key);
+      if (value.seenAt < cutoff) toDelete.push(key);
     }
     await this.db.batch(toDelete.map((key) => ({ type: "del", key })));
   }
@@ -4589,19 +1728,18 @@ var MessageStorage = class {
   async cleanupRateLimits(maxAgeMs) {
     const cutoff = Date.now() - maxAgeMs;
     const toDelete = [];
-    for await (const [key, value2] of this.db.iterator({
+    for await (const [key, value] of this.db.iterator({
       gte: "rate:",
       lte: "rate:\xFF",
       valueEncoding: "json"
     })) {
-      if (value2.lastRefill < cutoff) toDelete.push(key);
+      if (value.lastRefill < cutoff) toDelete.push(key);
     }
     await this.db.batch(toDelete.map((key) => ({ type: "del", key })));
   }
 };
 
 // src/messaging/queue.ts
-init_esm_shims();
 var logger7 = createLogger("message-queue");
 var MessageQueue = class {
   storage;
@@ -4727,11 +1865,7 @@ var MessageQueue = class {
   }
 };
 
-// src/messaging/defense.ts
-init_esm_shims();
-
 // src/messaging/rate-limiter.ts
-init_esm_shims();
 var TokenBucket = class {
   tokens;
   lastRefill;
@@ -4950,11 +2084,7 @@ var DefenseMiddleware = class {
   }
 };
 
-// src/trust/index.ts
-init_esm_shims();
-
 // src/trust/trust-score.ts
-init_esm_shims();
 var TrustMetrics = class {
   /**
    * Calculate trust score from interaction history
@@ -5022,9 +2152,6 @@ function createDefaultTrustScore() {
     lastUpdated: Date.now()
   };
 }
-
-// src/trust/interaction-history.ts
-init_esm_shims();
 var logger9 = createLogger("interaction-history");
 var InteractionHistory = class {
   db;
@@ -5060,14 +2187,14 @@ var InteractionHistory = class {
     const interactions = [];
     const prefix = `interaction:${agentDid}:`;
     try {
-      for await (const [_, value2] of this.db.iterator({
+      for await (const [_, value] of this.db.iterator({
         gte: prefix,
         lte: prefix + "\xFF",
         limit,
         reverse: true
         // Most recent first
       })) {
-        interactions.push(value2);
+        interactions.push(value);
       }
     } catch (error) {
       logger9.error("Failed to get interaction history", { agentDid, error });
@@ -5134,8 +2261,8 @@ var InteractionHistory = class {
   async cleanup(maxAge = 90 * 24 * 60 * 60 * 1e3) {
     const cutoff = Date.now() - maxAge;
     const keysToDelete = [];
-    for await (const [key, value2] of this.db.iterator()) {
-      if (value2.timestamp < cutoff) {
+    for await (const [key, value] of this.db.iterator()) {
+      if (value.timestamp < cutoff) {
         keysToDelete.push(key);
       }
     }
@@ -5148,7 +2275,6 @@ var InteractionHistory = class {
 };
 
 // src/trust/endorsement.ts
-init_esm_shims();
 var logger10 = createLogger("endorsement");
 var EndorsementManager = class {
   constructor(db, getPublicKey) {
@@ -5209,11 +2335,11 @@ var EndorsementManager = class {
     const endorsements = [];
     const prefix = `endorsement:${agentDid}:`;
     try {
-      for await (const [_, value2] of this.db.iterator({
+      for await (const [_, value] of this.db.iterator({
         gte: prefix,
         lte: prefix + "\xFF"
       })) {
-        endorsements.push(value2);
+        endorsements.push(value);
       }
     } catch (error) {
       logger10.error("Failed to get endorsements", { agentDid, error });
@@ -5226,9 +2352,9 @@ var EndorsementManager = class {
   async getEndorsementsBy(fromDid) {
     const endorsements = [];
     try {
-      for await (const [_, value2] of this.db.iterator()) {
-        if (value2.from === fromDid) {
-          endorsements.push(value2);
+      for await (const [_, value] of this.db.iterator()) {
+        if (value.from === fromDid) {
+          endorsements.push(value);
         }
       }
     } catch (error) {
@@ -5256,9 +2382,6 @@ var EndorsementManager = class {
     logger10.info("Deleted endorsement", { from: fromDid, to: toDid });
   }
 };
-
-// src/trust/sybil-defense.ts
-init_esm_shims();
 var logger11 = createLogger("sybil-defense");
 var SybilDefense = class {
   rateLimits = /* @__PURE__ */ new Map();
@@ -5537,6 +2660,6 @@ function createTrustSystem(config) {
   return new TrustSystem(config);
 }
 
-export { CLAWIVERSE_CONTEXT, CapabilityMatcher, CapabilityTypes, ClawiverseError, DEFAULT_RATE_LIMIT_TIERS, DefenseMiddleware, DiscoveryError, EndorsementManager, IdentityError, InteractionHistory, LogLevel, Logger, MessageQueue, MessageStorage, MessagingError, ParameterTypes, SCHEMA_ORG_CONTEXT, SearchIndex, SemanticSearchEngine, SybilDefense, TokenBucket, TransportError, TrustMetrics, TrustSystem, clawiverseContext, createAgentCard, createDHTOperations, createDefaultTrustScore, createEnvelope, createLegacyAgentCard, createLogger, createMessageRouter, createNode, createSemanticSearch, createTrustSystem, decodeAgentCard, decodeFromCBOR, decodeFromJSON, decodeMessage, decodeMessageJSON, deriveDID, downgradeToLegacyCard, encodeForDHT, encodeForWeb, encodeMessage, encodeMessageJSON, exportKeyPair, extractPublicKey, generateKeyPair, getAgentCardContext, getEncodedSize, getTierConfig, importKeyPair, isLegacyCard, isValidContext, matchesCapability, sign, signAgentCard, signEnvelope, signMessage, upgradeLegacyCard, validateAgentCard, validateDID, validateEnvelope, verify, verifyAgentCard, verifyEnvelope, verifyMessage };
+export { CLAWIVERSE_CONTEXT, CapabilityMatcher, CapabilityTypes, ClawiverseError, DEFAULT_RATE_LIMIT_TIERS, DefenseMiddleware, DiscoveryError, EndorsementManager, IdentityError, InteractionHistory, LogLevel, Logger, MessageQueue, MessageStorage, MessagingError, ParameterTypes, RELAY_PROTOCOL_VERSION, SCHEMA_ORG_CONTEXT, SearchIndex, SemanticSearchEngine, SybilDefense, TokenBucket, TransportError, TrustMetrics, TrustSystem, clawiverseContext, createAgentCard, createDefaultTrustScore, createEnvelope, createLegacyAgentCard, createLogger, createMessageRouter, createRelayClient, createRelayIndexOperations, createSemanticSearch, createTrustSystem, decodeAgentCard, decodeFromCBOR, decodeFromJSON, decodeMessage, decodeMessageJSON, deriveDID, downgradeToLegacyCard, encodeForDHT, encodeForWeb, encodeMessage, encodeMessageJSON, exportKeyPair, extractPublicKey, generateKeyPair, getAgentCardContext, getEncodedSize, getTierConfig, importKeyPair, isLegacyCard, isValidContext, matchesCapability, sign, signAgentCard, signEnvelope, signMessage, upgradeLegacyCard, validateAgentCard, validateDID, validateEnvelope, verify, verifyAgentCard, verifyEnvelope, verifyMessage };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map