@highway1/core 0.1.47 → 0.1.48

package/dist/index.js

@@ -1,7 +1,20 @@
+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';
@@ -11,23 +24,35 @@ import { ping } from '@libp2p/ping';
 import { circuitRelayTransport, circuitRelayServer } from '@libp2p/circuit-relay-v2';
 import Ajv from 'ajv';
 import { encode, decode } from 'cbor-x';
-import { fromString } from 'uint8arrays/from-string';
 import { toString } from 'uint8arrays/to-string';
 import lunr from 'lunr';
 import Fuse from 'fuse.js';
 import { peerIdFromString } from '@libp2p/peer-id';
-import { multiaddr } from '@multiformats/multiaddr';
 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, code, details) {
+  constructor(message, code2, details) {
     super(message);
-    this.code = code;
+    this.code = code2;
     this.details = details;
     this.name = "ClawiverseError";
   }
@@ -96,6 +121,9 @@ 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);
@@ -114,51 +142,2721 @@ function extractPublicKey(did) {
   } catch (error) {
     throw new IdentityError("Failed to extract public key from DID", error);
   }
-}
-function validateDID(did) {
-  if (!did.startsWith("did:clawiverse:")) {
-    return false;
+}
+function validateDID(did) {
+  if (!did.startsWith("did:clawiverse:")) {
+    return false;
+  }
+  try {
+    const encoded = did.replace("did:clawiverse:", "");
+    base58btc.decode(encoded);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/identity/signer.ts
+init_esm_shims();
+async function signMessage(payload, privateKey, publicKey) {
+  try {
+    const signature = await sign(payload, privateKey);
+    const signer = deriveDID(publicKey);
+    return {
+      payload,
+      signature,
+      signer
+    };
+  } catch (error) {
+    throw new IdentityError("Failed to sign message", error);
+  }
+}
+async function verifyMessage(signedMessage, expectedPublicKey) {
+  try {
+    const expectedDID = deriveDID(expectedPublicKey);
+    if (signedMessage.signer !== expectedDID) {
+      return false;
+    }
+    return await verify(
+      signedMessage.signature,
+      signedMessage.payload,
+      expectedPublicKey
+    );
+  } catch (error) {
+    throw new IdentityError("Failed to verify message", error);
+  }
+}
+
+// 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 {
+  }
+};
+
+// ../../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
+    });
+  }
+  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;
+    }
+    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;
+    }
+    return parts;
+  }
+  function matches(ma) {
+    const result = match(ma);
+    return result !== false;
+  }
+  function exactMatch(ma) {
+    const result = match(ma);
+    if (result === false) {
+      return false;
+    }
+    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");
+    }
+    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();
+
+// ../../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);
+  }
+};
+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) {
+        try {
+          resolve(fallback());
+        } catch (error) {
+          reject(error);
+        }
+        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);
+      }
+    }, 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;
+          }
+        } 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);
+      }
+      for (const rejectionEvent of options.rejectionEvents) {
+        if (!events.includes(rejectionEvent)) {
+          removeListener(rejectionEvent, rejectHandler);
+        }
+      }
+    };
+    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;
+        }
+        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
+    ];
   }
-  try {
-    const encoded = did.replace("did:clawiverse:", "");
-    base58btc.decode(encoded);
-    return true;
-  } catch {
-    return false;
+  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);
 }
 
-// src/identity/signer.ts
-async function signMessage(payload, privateKey, publicKey) {
-  try {
-    const signature = await sign(payload, privateKey);
-    const signer = deriveDID(publicKey);
-    return {
-      payload,
-      signature,
-      signer
-    };
-  } catch (error) {
-    throw new IdentityError("Failed to sign message", error);
+// ../../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"
+        })
+      };
+    }
   }
-}
-async function verifyMessage(signedMessage, expectedPublicKey) {
-  try {
-    const expectedDID = deriveDID(expectedPublicKey);
-    if (signedMessage.signer !== expectedDID) {
-      return false;
+  [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;
     }
-    return await verify(
-      signedMessage.signature,
-      signedMessage.payload,
-      expectedPublicKey
-    );
-  } catch (error) {
-    throw new IdentityError("Failed to verify message", error);
+    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";
@@ -206,7 +2904,8 @@ var logger = createLogger("transport");
 async function createNode(config) {
   try {
     const {
-      listenAddresses = ["/ip4/0.0.0.0/tcp/0"],
+      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,
@@ -222,6 +2921,8 @@ async function createNode(config) {
       ...privateKey ? { privateKey } : {},
       transports: [
         tcp(),
+        webSockets(),
+        // CVP-0010 §5: WebSocket for firewall traversal
         circuitRelayTransport()
       ],
       connectionEncrypters: [noise()],
@@ -302,7 +3003,11 @@ async function createNode(config) {
   }
 }
 
+// src/discovery/agent-card.ts
+init_esm_shims();
+
 // 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";
 }
@@ -432,6 +3137,7 @@ 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 = {
@@ -490,6 +3196,9 @@ 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;
@@ -557,6 +3266,15 @@ function getEncodedSize(card) {
     json: encodeForWeb(card).length
   };
 }
+
+// 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");
 var SearchIndex = class {
   cards = /* @__PURE__ */ new Map();
@@ -718,6 +3436,7 @@ var SearchIndex = class {
 };
 
 // src/discovery/capability-matcher.ts
+init_esm_shims();
 var CapabilityMatcher = class {
   /**
    * Match a query against a capability
@@ -1056,10 +3775,10 @@ async function readDIDList(dht, key) {
   return [];
 }
 async function writeDIDList(dht, key, dids) {
-  const value = fromString([...new Set(dids)].join("\n"));
+  const value2 = fromString([...new Set(dids)].join("\n"));
   for (let attempt = 1; attempt <= 3; attempt++) {
     try {
-      for await (const _ of dht.put(key, value, { signal: AbortSignal.timeout(3e4) })) {
+      for await (const _ of dht.put(key, value2, { signal: AbortSignal.timeout(3e4) })) {
       }
       return;
     } catch (e) {
@@ -1261,6 +3980,7 @@ function createDHTOperations(libp2p) {
 }
 
 // src/messaging/envelope.ts
+init_esm_shims();
 function createEnvelope(from, to, type, protocol, payload, replyTo) {
   return {
     id: generateMessageId(),
@@ -1307,6 +4027,9 @@ 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);
@@ -1335,6 +4058,9 @@ function decodeMessageJSON(json) {
     throw new MessagingError("Failed to decode message from JSON", error);
   }
 }
+
+// src/messaging/router.ts
+init_esm_shims();
 var logger5 = createLogger("router");
 function concatUint8Arrays(arrays) {
   if (arrays.length === 0) return new Uint8Array(0);
@@ -1501,7 +4227,7 @@ function createMessageRouter(libp2p, verifyFn, dht, relayPeers) {
         if (envelope.type === "request") {
           logger5.debug("Waiting for response to request", { id: envelope.id });
           try {
-            const RESPONSE_TIMEOUT = 5e3;
+            const RESPONSE_TIMEOUT = 3e4;
             const responsePromise = (async () => {
               const responseChunks = [];
               for await (const chunk of stream.source) {
@@ -1642,7 +4368,593 @@ async function handleIncomingStream(stream, handlers, catchAllHandler, verifyFn)
   }
 }
 
+// src/messaging/types.ts
+init_esm_shims();
+
+// src/messaging/storage.ts
+init_esm_shims();
+var logger6 = createLogger("message-storage");
+var MessageStorage = class {
+  db;
+  ready = false;
+  constructor(dbPath) {
+    this.db = new Level(dbPath, { valueEncoding: "json" });
+  }
+  async open() {
+    await this.db.open();
+    this.ready = true;
+    logger6.info("Message storage opened");
+  }
+  async close() {
+    if (this.ready) {
+      await this.db.close();
+      this.ready = false;
+      logger6.info("Message storage closed");
+    }
+  }
+  // ─── Message Operations ───────────────────────────────────────────────────
+  async putMessage(msg) {
+    const ts = String(msg.receivedAt ?? msg.sentAt ?? Date.now()).padStart(16, "0");
+    const key = `msg:${msg.direction}:${ts}:${msg.envelope.id}`;
+    await this.db.put(key, msg);
+    const idxKey = `idx:from:${msg.envelope.from}:${ts}:${msg.envelope.id}`;
+    await this.db.put(idxKey, "1");
+  }
+  async getMessage(id) {
+    for (const direction of ["inbound", "outbound"]) {
+      const prefix = `msg:${direction}:`;
+      for await (const [, value2] of this.db.iterator({
+        gte: prefix,
+        lte: prefix + "\xFF",
+        valueEncoding: "json"
+      })) {
+        if (value2.envelope.id === id) return value2;
+      }
+    }
+    return null;
+  }
+  async updateMessage(id, updates) {
+    const msg = await this.getMessage(id);
+    if (!msg) return;
+    const ts = String(msg.receivedAt ?? msg.sentAt ?? Date.now()).padStart(16, "0");
+    const key = `msg:${msg.direction}:${ts}:${id}`;
+    await this.db.put(key, { ...msg, ...updates });
+  }
+  async deleteMessage(id) {
+    const msg = await this.getMessage(id);
+    if (!msg) return;
+    const ts = String(msg.receivedAt ?? msg.sentAt ?? Date.now()).padStart(16, "0");
+    const key = `msg:${msg.direction}:${ts}:${id}`;
+    const idxKey = `idx:from:${msg.envelope.from}:${ts}:${id}`;
+    await this.db.batch([
+      { type: "del", key },
+      { type: "del", key: idxKey }
+    ]);
+  }
+  async queryMessages(direction, filter = {}, pagination = {}) {
+    const { limit = 50, offset = 0 } = pagination;
+    const prefix = `msg:${direction}:`;
+    const results = [];
+    let total = 0;
+    let skipped = 0;
+    for await (const [, value2] of this.db.iterator({
+      gte: prefix,
+      lte: prefix + "\xFF",
+      reverse: true,
+      // newest first
+      valueEncoding: "json"
+    })) {
+      if (!this.matchesFilter(value2, filter)) continue;
+      total++;
+      if (skipped < offset) {
+        skipped++;
+        continue;
+      }
+      if (results.length < limit) results.push(value2);
+    }
+    return {
+      messages: results,
+      total,
+      hasMore: total > offset + results.length
+    };
+  }
+  matchesFilter(msg, filter) {
+    if (filter.fromDid) {
+      const froms = Array.isArray(filter.fromDid) ? filter.fromDid : [filter.fromDid];
+      if (!froms.includes(msg.envelope.from)) return false;
+    }
+    if (filter.toDid) {
+      const tos = Array.isArray(filter.toDid) ? filter.toDid : [filter.toDid];
+      if (!tos.includes(msg.envelope.to)) return false;
+    }
+    if (filter.protocol) {
+      const protos = Array.isArray(filter.protocol) ? filter.protocol : [filter.protocol];
+      if (!protos.includes(msg.envelope.protocol)) return false;
+    }
+    if (filter.type && msg.envelope.type !== filter.type) return false;
+    if (filter.unreadOnly && msg.readAt != null) return false;
+    if (filter.status) {
+      const statuses = Array.isArray(filter.status) ? filter.status : [filter.status];
+      if (!statuses.includes(msg.status)) return false;
+    }
+    if (filter.maxAge) {
+      const age = Date.now() - (msg.receivedAt ?? msg.sentAt ?? 0);
+      if (age > filter.maxAge) return false;
+    }
+    if (filter.minTrustScore != null && (msg.trustScore ?? 0) < filter.minTrustScore) return false;
+    return true;
+  }
+  async countMessages(direction, filter = {}) {
+    const prefix = `msg:${direction}:`;
+    let count = 0;
+    for await (const [, value2] of this.db.iterator({
+      gte: prefix,
+      lte: prefix + "\xFF",
+      valueEncoding: "json"
+    })) {
+      if (this.matchesFilter(value2, filter)) count++;
+    }
+    return count;
+  }
+  // ─── Blocklist ────────────────────────────────────────────────────────────
+  async putBlock(entry) {
+    await this.db.put(`block:${entry.did}`, entry);
+  }
+  async getBlock(did) {
+    try {
+      return await this.db.get(`block:${did}`);
+    } catch {
+      return null;
+    }
+  }
+  async deleteBlock(did) {
+    try {
+      await this.db.del(`block:${did}`);
+    } catch {
+    }
+  }
+  async listBlocked() {
+    const results = [];
+    for await (const [, value2] of this.db.iterator({
+      gte: "block:",
+      lte: "block:\xFF",
+      valueEncoding: "json"
+    })) {
+      results.push(value2);
+    }
+    return results;
+  }
+  // ─── Allowlist ────────────────────────────────────────────────────────────
+  async putAllow(entry) {
+    await this.db.put(`allow:${entry.did}`, entry);
+  }
+  async getAllow(did) {
+    try {
+      return await this.db.get(`allow:${did}`);
+    } catch {
+      return null;
+    }
+  }
+  async deleteAllow(did) {
+    try {
+      await this.db.del(`allow:${did}`);
+    } catch {
+    }
+  }
+  async listAllowed() {
+    const results = [];
+    for await (const [, value2] of this.db.iterator({
+      gte: "allow:",
+      lte: "allow:\xFF",
+      valueEncoding: "json"
+    })) {
+      results.push(value2);
+    }
+    return results;
+  }
+  // ─── Seen Cache ───────────────────────────────────────────────────────────
+  async putSeen(entry) {
+    await this.db.put(`seen:${entry.messageId}`, entry);
+  }
+  async getSeen(messageId) {
+    try {
+      return await this.db.get(`seen:${messageId}`);
+    } catch {
+      return null;
+    }
+  }
+  async cleanupSeen(maxAgeMs) {
+    const cutoff = Date.now() - maxAgeMs;
+    const toDelete = [];
+    for await (const [key, value2] of this.db.iterator({
+      gte: "seen:",
+      lte: "seen:\xFF",
+      valueEncoding: "json"
+    })) {
+      if (value2.seenAt < cutoff) toDelete.push(key);
+    }
+    await this.db.batch(toDelete.map((key) => ({ type: "del", key })));
+  }
+  // ─── Rate Limit State ─────────────────────────────────────────────────────
+  async putRateLimit(state) {
+    await this.db.put(`rate:${state.did}`, state);
+  }
+  async getRateLimit(did) {
+    try {
+      return await this.db.get(`rate:${did}`);
+    } catch {
+      return null;
+    }
+  }
+  async cleanupRateLimits(maxAgeMs) {
+    const cutoff = Date.now() - maxAgeMs;
+    const toDelete = [];
+    for await (const [key, value2] of this.db.iterator({
+      gte: "rate:",
+      lte: "rate:\xFF",
+      valueEncoding: "json"
+    })) {
+      if (value2.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;
+  subscriptions = /* @__PURE__ */ new Map();
+  subCounter = 0;
+  constructor(config) {
+    this.storage = new MessageStorage(config.dbPath);
+  }
+  get store() {
+    return this.storage;
+  }
+  async start() {
+    await this.storage.open();
+    logger7.info("Message queue started");
+  }
+  async stop() {
+    await this.storage.close();
+    this.subscriptions.clear();
+    logger7.info("Message queue stopped");
+  }
+  // ─── Inbox ────────────────────────────────────────────────────────────────
+  async getInbox(filter = {}, pagination = {}) {
+    return this.storage.queryMessages("inbound", filter, pagination);
+  }
+  async getMessage(id) {
+    return this.storage.getMessage(id);
+  }
+  async markAsRead(id) {
+    await this.storage.updateMessage(id, { readAt: Date.now() });
+  }
+  async deleteMessage(id) {
+    await this.storage.deleteMessage(id);
+  }
+  // ─── Outbox ───────────────────────────────────────────────────────────────
+  async getOutbox(pagination = {}) {
+    return this.storage.queryMessages("outbound", {}, pagination);
+  }
+  async retryMessage(id) {
+    await this.storage.updateMessage(id, { status: "pending", error: void 0 });
+  }
+  // ─── Enqueue ──────────────────────────────────────────────────────────────
+  async enqueueInbound(envelope, trustScore) {
+    const msg = {
+      envelope,
+      direction: "inbound",
+      status: "pending",
+      receivedAt: Date.now(),
+      trustScore
+    };
+    await this.storage.putMessage(msg);
+    logger7.debug("Enqueued inbound message", { id: envelope.id, from: envelope.from });
+    this.notifySubscribers(msg);
+    return msg;
+  }
+  async enqueueOutbound(envelope) {
+    const msg = {
+      envelope,
+      direction: "outbound",
+      status: "pending",
+      sentAt: Date.now()
+    };
+    await this.storage.putMessage(msg);
+    logger7.debug("Enqueued outbound message", { id: envelope.id, to: envelope.to });
+    return msg;
+  }
+  async markOutboundDelivered(id) {
+    await this.storage.updateMessage(id, { status: "delivered" });
+  }
+  async markOutboundFailed(id, error) {
+    await this.storage.updateMessage(id, { status: "failed", error });
+  }
+  // ─── Subscriptions ────────────────────────────────────────────────────────
+  subscribe(filter, callback) {
+    const id = `sub_${++this.subCounter}`;
+    this.subscriptions.set(id, { id, filter, callback });
+    logger7.debug("Subscription added", { id });
+    return id;
+  }
+  unsubscribe(subscriptionId) {
+    this.subscriptions.delete(subscriptionId);
+    logger7.debug("Subscription removed", { id: subscriptionId });
+  }
+  notifySubscribers(msg) {
+    for (const sub of this.subscriptions.values()) {
+      if (this.matchesSubscriptionFilter(msg, sub.filter)) {
+        Promise.resolve(sub.callback(msg)).catch((err) => {
+          logger7.warn("Subscription callback error", { id: sub.id, error: err.message });
+        });
+      }
+    }
+  }
+  matchesSubscriptionFilter(msg, filter) {
+    if (filter.fromDid) {
+      const froms = Array.isArray(filter.fromDid) ? filter.fromDid : [filter.fromDid];
+      if (!froms.includes(msg.envelope.from)) return false;
+    }
+    if (filter.protocol) {
+      const protos = Array.isArray(filter.protocol) ? filter.protocol : [filter.protocol];
+      if (!protos.includes(msg.envelope.protocol)) return false;
+    }
+    if (filter.type && msg.envelope.type !== filter.type) return false;
+    return true;
+  }
+  // ─── Stats ────────────────────────────────────────────────────────────────
+  async getStats() {
+    const [inboxTotal, inboxUnread, outboxPending, outboxFailed, blocked, allowed] = await Promise.all([
+      this.storage.countMessages("inbound"),
+      this.storage.countMessages("inbound", { unreadOnly: true }),
+      this.storage.countMessages("outbound", { status: "pending" }),
+      this.storage.countMessages("outbound", { status: "failed" }),
+      this.storage.listBlocked().then((l) => l.length),
+      this.storage.listAllowed().then((l) => l.length)
+    ]);
+    return {
+      inboxTotal,
+      inboxUnread,
+      outboxPending,
+      outboxFailed,
+      blockedAgents: blocked,
+      allowedAgents: allowed,
+      rateLimitedAgents: 0
+    };
+  }
+};
+
+// src/messaging/defense.ts
+init_esm_shims();
+
+// src/messaging/rate-limiter.ts
+init_esm_shims();
+var TokenBucket = class {
+  tokens;
+  lastRefill;
+  capacity;
+  refillRate;
+  // tokens per ms
+  constructor(config, initialTokens, lastRefill) {
+    this.capacity = config.capacity;
+    this.refillRate = config.refillRate;
+    this.tokens = initialTokens ?? config.capacity;
+    this.lastRefill = lastRefill ?? Date.now();
+  }
+  /** Attempt to consume one token. Returns true if allowed. */
+  consume() {
+    this.refill();
+    if (this.tokens >= 1) {
+      this.tokens -= 1;
+      return true;
+    }
+    return false;
+  }
+  getRemaining() {
+    this.refill();
+    return Math.floor(this.tokens);
+  }
+  /** Milliseconds until at least one token is available */
+  getResetTime() {
+    this.refill();
+    if (this.tokens >= 1) return 0;
+    const needed = 1 - this.tokens;
+    return Math.ceil(needed / this.refillRate);
+  }
+  /** Serialize state for persistence */
+  toState() {
+    return { tokens: this.tokens, lastRefill: this.lastRefill };
+  }
+  refill() {
+    const now = Date.now();
+    const elapsed = now - this.lastRefill;
+    const newTokens = elapsed * this.refillRate;
+    this.tokens = Math.min(this.capacity, this.tokens + newTokens);
+    this.lastRefill = now;
+  }
+};
+var DEFAULT_RATE_LIMIT_TIERS = {
+  newAgent: { capacity: 10, refillRate: 10 / (60 * 1e3) },
+  // 10/min, burst 10
+  established: { capacity: 100, refillRate: 60 / (60 * 1e3) },
+  // 60/min, burst 100
+  trusted: { capacity: 1e3, refillRate: 600 / (60 * 1e3) }
+  // 600/min, burst 1000
+};
+function getTierConfig(trustScore, tiers) {
+  if (trustScore >= 0.6) return tiers.trusted;
+  if (trustScore >= 0.3) return tiers.established;
+  return tiers.newAgent;
+}
+
+// src/messaging/defense.ts
+var logger8 = createLogger("defense");
+var DefenseMiddleware = class {
+  trust;
+  storage;
+  minTrustScore;
+  autoBlockThreshold;
+  tiers;
+  seenTtlMs;
+  // In-memory LRU-style seen cache (backed by LevelDB for persistence)
+  seenCache = /* @__PURE__ */ new Map();
+  // id → seenAt
+  MAX_SEEN_CACHE = 1e4;
+  // In-memory token buckets (backed by LevelDB for persistence)
+  buckets = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.trust = config.trustSystem;
+    this.storage = config.storage;
+    this.minTrustScore = config.minTrustScore ?? 0;
+    this.autoBlockThreshold = config.autoBlockThreshold ?? 0.1;
+    this.tiers = config.rateLimitTiers ?? DEFAULT_RATE_LIMIT_TIERS;
+    this.seenTtlMs = config.seenTtlMs ?? 60 * 60 * 1e3;
+  }
+  /**
+   * Run all defense checks on an incoming message.
+   * Returns { allowed: true } if the message should be processed,
+   * or { allowed: false, reason } if it should be dropped.
+   */
+  async checkMessage(envelope) {
+    const did = envelope.from;
+    if (await this.isAllowed(did)) {
+      this.markAsSeen(envelope.id);
+      return { allowed: true };
+    }
+    if (await this.isBlocked(did)) {
+      logger8.debug("Message rejected: blocked", { id: envelope.id, from: did });
+      return { allowed: false, reason: "blocked" };
+    }
+    if (this.hasSeen(envelope.id)) {
+      logger8.debug("Message rejected: duplicate", { id: envelope.id });
+      return { allowed: false, reason: "duplicate" };
+    }
+    let trustScore = 0;
+    try {
+      const score = await this.trust.getTrustScore(did);
+      trustScore = score.interactionScore;
+      if (trustScore < this.autoBlockThreshold && trustScore > 0) {
+        logger8.warn("Auto-blocking low-trust agent", { did, trustScore });
+        await this.blockAgent(did, `Auto-blocked: trust score ${trustScore.toFixed(2)} below threshold`);
+        return { allowed: false, reason: "blocked" };
+      }
+      if (trustScore < this.minTrustScore) {
+        logger8.debug("Message rejected: trust too low", { id: envelope.id, trustScore });
+        return { allowed: false, reason: "trust_too_low", trustScore };
+      }
+    } catch (err) {
+      logger8.warn("Trust score lookup failed, using 0", { did, error: err.message });
+    }
+    const rateLimitResult = await this.checkRateLimit(did, trustScore);
+    if (!rateLimitResult.allowed) {
+      logger8.debug("Message rejected: rate limited", {
+        id: envelope.id,
+        from: did,
+        resetTime: rateLimitResult.resetTime
+      });
+      return {
+        allowed: false,
+        reason: "rate_limited",
+        remainingTokens: rateLimitResult.remaining,
+        resetTime: rateLimitResult.resetTime
+      };
+    }
+    this.markAsSeen(envelope.id);
+    return { allowed: true, trustScore, remainingTokens: rateLimitResult.remaining };
+  }
+  // ─── Blocklist ────────────────────────────────────────────────────────────
+  async blockAgent(did, reason, blockedBy = "local") {
+    await this.storage.putBlock({ did, reason, blockedAt: Date.now(), blockedBy });
+    logger8.info("Agent blocked", { did, reason });
+  }
+  async unblockAgent(did) {
+    await this.storage.deleteBlock(did);
+    logger8.info("Agent unblocked", { did });
+  }
+  async isBlocked(did) {
+    return await this.storage.getBlock(did) !== null;
+  }
+  // ─── Allowlist ────────────────────────────────────────────────────────────
+  async allowAgent(did, note) {
+    await this.storage.putAllow({ did, addedAt: Date.now(), note });
+    logger8.info("Agent allowlisted", { did });
+  }
+  async removeFromAllowlist(did) {
+    await this.storage.deleteAllow(did);
+    logger8.info("Agent removed from allowlist", { did });
+  }
+  async isAllowed(did) {
+    return await this.storage.getAllow(did) !== null;
+  }
+  // ─── Rate Limiting ────────────────────────────────────────────────────────
+  async checkRateLimit(did, trustScore) {
+    const tierConfig = getTierConfig(trustScore, this.tiers);
+    let bucket = this.buckets.get(did);
+    if (!bucket) {
+      const persisted = await this.storage.getRateLimit(did);
+      if (persisted) {
+        bucket = new TokenBucket(tierConfig, persisted.tokens, persisted.lastRefill);
+      } else {
+        bucket = new TokenBucket(tierConfig);
+      }
+      this.buckets.set(did, bucket);
+    }
+    const allowed = bucket.consume();
+    const state = bucket.toState();
+    await this.storage.putRateLimit({
+      did,
+      tokens: state.tokens,
+      lastRefill: state.lastRefill,
+      totalRequests: 0,
+      firstSeen: Date.now()
+    });
+    return {
+      allowed,
+      remaining: bucket.getRemaining(),
+      resetTime: bucket.getResetTime(),
+      limit: tierConfig.capacity
+    };
+  }
+  // ─── Seen Cache (deduplication) ───────────────────────────────────────────
+  hasSeen(messageId) {
+    return this.seenCache.has(messageId);
+  }
+  markAsSeen(messageId) {
+    if (this.seenCache.size >= this.MAX_SEEN_CACHE) {
+      const firstKey = this.seenCache.keys().next().value;
+      if (firstKey) this.seenCache.delete(firstKey);
+    }
+    this.seenCache.set(messageId, Date.now());
+    this.storage.putSeen({ messageId, seenAt: Date.now(), fromDid: "" }).catch(() => {
+    });
+  }
+  /** Periodic cleanup of expired seen entries */
+  async cleanupSeen() {
+    const cutoff = Date.now() - this.seenTtlMs;
+    for (const [id, seenAt] of this.seenCache) {
+      if (seenAt < cutoff) this.seenCache.delete(id);
+    }
+    await this.storage.cleanupSeen(this.seenTtlMs);
+  }
+  /** Periodic cleanup of stale rate limit buckets (24h inactive) */
+  async cleanupRateLimits() {
+    const staleMs = 24 * 60 * 60 * 1e3;
+    const cutoff = Date.now() - staleMs;
+    for (const [did, bucket] of this.buckets) {
+      if (bucket.toState().lastRefill < cutoff) this.buckets.delete(did);
+    }
+    await this.storage.cleanupRateLimits(staleMs);
+  }
+};
+
+// src/trust/index.ts
+init_esm_shims();
+
 // src/trust/trust-score.ts
+init_esm_shims();
 var TrustMetrics = class {
   /**
    * Calculate trust score from interaction history
@@ -1710,7 +5022,10 @@ function createDefaultTrustScore() {
     lastUpdated: Date.now()
   };
 }
-var logger6 = createLogger("interaction-history");
+
+// src/trust/interaction-history.ts
+init_esm_shims();
+var logger9 = createLogger("interaction-history");
 var InteractionHistory = class {
   db;
   constructor(dbPath) {
@@ -1721,14 +5036,14 @@ var InteractionHistory = class {
    */
   async open() {
     await this.db.open();
-    logger6.info("Interaction history database opened", { path: this.db.location });
+    logger9.info("Interaction history database opened", { path: this.db.location });
   }
   /**
    * Close database connection
    */
   async close() {
     await this.db.close();
-    logger6.info("Interaction history database closed");
+    logger9.info("Interaction history database closed");
   }
   /**
    * Record an interaction
@@ -1736,7 +5051,7 @@ var InteractionHistory = class {
   async record(interaction) {
     const key = `interaction:${interaction.agentDid}:${interaction.timestamp}`;
     await this.db.put(key, interaction);
-    logger6.debug("Recorded interaction", { agentDid: interaction.agentDid, type: interaction.type });
+    logger9.debug("Recorded interaction", { agentDid: interaction.agentDid, type: interaction.type });
   }
   /**
    * Get interaction history for an agent
@@ -1745,17 +5060,17 @@ var InteractionHistory = class {
     const interactions = [];
     const prefix = `interaction:${agentDid}:`;
     try {
-      for await (const [_, value] of this.db.iterator({
+      for await (const [_, value2] of this.db.iterator({
         gte: prefix,
         lte: prefix + "\xFF",
         limit,
         reverse: true
         // Most recent first
       })) {
-        interactions.push(value);
+        interactions.push(value2);
       }
     } catch (error) {
-      logger6.error("Failed to get interaction history", { agentDid, error });
+      logger9.error("Failed to get interaction history", { agentDid, error });
     }
     return interactions;
   }
@@ -1794,7 +5109,7 @@ var InteractionHistory = class {
         }
       }
     } catch (error) {
-      logger6.error("Failed to get all agents", { error });
+      logger9.error("Failed to get all agents", { error });
     }
     return Array.from(agents);
   }
@@ -1811,7 +5126,7 @@ var InteractionHistory = class {
       keysToDelete.push(key);
     }
     await this.db.batch(keysToDelete.map((key) => ({ type: "del", key })));
-    logger6.info("Deleted interaction history", { agentDid, count: keysToDelete.length });
+    logger9.info("Deleted interaction history", { agentDid, count: keysToDelete.length });
   }
   /**
    * Clean up old interactions (older than 90 days)
@@ -1819,21 +5134,22 @@ var InteractionHistory = class {
   async cleanup(maxAge = 90 * 24 * 60 * 60 * 1e3) {
     const cutoff = Date.now() - maxAge;
     const keysToDelete = [];
-    for await (const [key, value] of this.db.iterator()) {
-      if (value.timestamp < cutoff) {
+    for await (const [key, value2] of this.db.iterator()) {
+      if (value2.timestamp < cutoff) {
         keysToDelete.push(key);
       }
     }
     if (keysToDelete.length > 0) {
       await this.db.batch(keysToDelete.map((key) => ({ type: "del", key })));
-      logger6.info("Cleaned up old interactions", { count: keysToDelete.length });
+      logger9.info("Cleaned up old interactions", { count: keysToDelete.length });
     }
     return keysToDelete.length;
   }
 };
 
 // src/trust/endorsement.ts
-var logger7 = createLogger("endorsement");
+init_esm_shims();
+var logger10 = createLogger("endorsement");
 var EndorsementManager = class {
   constructor(db, getPublicKey) {
     this.db = db;
@@ -1860,7 +5176,7 @@ var EndorsementManager = class {
       ...endorsement,
       signature
     };
-    logger7.info("Created endorsement", { from: fromDid, to: toDid, score });
+    logger10.info("Created endorsement", { from: fromDid, to: toDid, score });
     return signedEndorsement;
   }
   /**
@@ -1874,7 +5190,7 @@ var EndorsementManager = class {
       const publicKey = await this.getPublicKey(endorsement.from);
       return await verifyFn(signatureBytes, data, publicKey);
     } catch (error) {
-      logger7.error("Failed to verify endorsement", { error });
+      logger10.error("Failed to verify endorsement", { error });
       return false;
     }
   }
@@ -1884,7 +5200,7 @@ var EndorsementManager = class {
   async publish(endorsement) {
     const key = `endorsement:${endorsement.to}:${endorsement.from}`;
     await this.db.put(key, endorsement);
-    logger7.info("Published endorsement", { from: endorsement.from, to: endorsement.to });
+    logger10.info("Published endorsement", { from: endorsement.from, to: endorsement.to });
   }
   /**
    * Get all endorsements for an agent
@@ -1893,14 +5209,14 @@ var EndorsementManager = class {
     const endorsements = [];
     const prefix = `endorsement:${agentDid}:`;
     try {
-      for await (const [_, value] of this.db.iterator({
+      for await (const [_, value2] of this.db.iterator({
         gte: prefix,
         lte: prefix + "\xFF"
       })) {
-        endorsements.push(value);
+        endorsements.push(value2);
       }
     } catch (error) {
-      logger7.error("Failed to get endorsements", { agentDid, error });
+      logger10.error("Failed to get endorsements", { agentDid, error });
     }
     return endorsements;
   }
@@ -1910,13 +5226,13 @@ var EndorsementManager = class {
   async getEndorsementsBy(fromDid) {
     const endorsements = [];
     try {
-      for await (const [_, value] of this.db.iterator()) {
-        if (value.from === fromDid) {
-          endorsements.push(value);
+      for await (const [_, value2] of this.db.iterator()) {
+        if (value2.from === fromDid) {
+          endorsements.push(value2);
         }
       }
     } catch (error) {
-      logger7.error("Failed to get endorsements by agent", { fromDid, error });
+      logger10.error("Failed to get endorsements by agent", { fromDid, error });
     }
     return endorsements;
   }
@@ -1937,10 +5253,13 @@ var EndorsementManager = class {
   async deleteEndorsement(fromDid, toDid) {
     const key = `endorsement:${toDid}:${fromDid}`;
     await this.db.del(key);
-    logger7.info("Deleted endorsement", { from: fromDid, to: toDid });
+    logger10.info("Deleted endorsement", { from: fromDid, to: toDid });
   }
 };
-var logger8 = createLogger("sybil-defense");
+
+// src/trust/sybil-defense.ts
+init_esm_shims();
+var logger11 = createLogger("sybil-defense");
 var SybilDefense = class {
   rateLimits = /* @__PURE__ */ new Map();
   peerFirstSeen = /* @__PURE__ */ new Map();
@@ -1970,7 +5289,7 @@ var SybilDefense = class {
   verifyChallenge(solution) {
     const { challenge, solution: solutionNonce } = solution;
     if (Date.now() - challenge.timestamp > 60 * 60 * 1e3) {
-      logger8.warn("Challenge expired", { did: challenge.did });
+      logger11.warn("Challenge expired", { did: challenge.did });
       return false;
     }
     const data = `${challenge.did}:${challenge.nonce}:${solutionNonce}`;
@@ -1978,9 +5297,9 @@ var SybilDefense = class {
     const leadingZeros = this.countLeadingZeroBits(hash);
     const valid = leadingZeros >= challenge.difficulty;
     if (valid) {
-      logger8.info("Challenge verified", { did: challenge.did, leadingZeros });
+      logger11.info("Challenge verified", { did: challenge.did, leadingZeros });
     } else {
-      logger8.warn("Challenge failed", { did: challenge.did, leadingZeros, required: challenge.difficulty });
+      logger11.warn("Challenge failed", { did: challenge.did, leadingZeros, required: challenge.difficulty });
     }
     return valid;
   }
@@ -2020,7 +5339,7 @@ var SybilDefense = class {
     record.requests = record.requests.filter(
       (t) => now - t < this.RATE_LIMIT_WINDOW
     );
-    logger8.debug("Recorded request", { did, count: record.requests.length });
+    logger11.debug("Recorded request", { did, count: record.requests.length });
   }
   /**
    * Get peer trust level based on age
@@ -2045,7 +5364,7 @@ var SybilDefense = class {
   recordPeerSeen(peerId) {
     if (!this.peerFirstSeen.has(peerId)) {
       this.peerFirstSeen.set(peerId, Date.now());
-      logger8.debug("Recorded new peer", { peerId });
+      logger11.debug("Recorded new peer", { peerId });
     }
   }
   /**
@@ -2059,7 +5378,7 @@ var SybilDefense = class {
         this.rateLimits.delete(did);
       }
     }
-    logger8.info("Cleaned up Sybil defense records", {
+    logger11.info("Cleaned up Sybil defense records", {
       rateLimits: this.rateLimits.size,
       peers: this.peerFirstSeen.size
     });
@@ -2092,7 +5411,7 @@ var SybilDefense = class {
     return count;
   }
 };
-var logger9 = createLogger("trust-system");
+var logger12 = createLogger("trust-system");
 var TrustSystem = class {
   metrics;
   history;
@@ -2115,14 +5434,14 @@ var TrustSystem = class {
    */
   async start() {
     await this.history.open();
-    logger9.info("Trust system started");
+    logger12.info("Trust system started");
   }
   /**
    * Shutdown the trust system
    */
   async stop() {
     await this.history.close();
-    logger9.info("Trust system stopped");
+    logger12.info("Trust system stopped");
   }
   /**
    * Record an interaction
@@ -2211,13 +5530,13 @@ var TrustSystem = class {
     await this.history.cleanup();
     this.sybilDefense.cleanup();
     this.trustCache.clear();
-    logger9.info("Trust system cleanup completed");
+    logger12.info("Trust system cleanup completed");
   }
 };
 function createTrustSystem(config) {
   return new TrustSystem(config);
 }
 
-export { CLAWIVERSE_CONTEXT, CapabilityMatcher, CapabilityTypes, ClawiverseError, DiscoveryError, EndorsementManager, IdentityError, InteractionHistory, LogLevel, Logger, MessagingError, ParameterTypes, SCHEMA_ORG_CONTEXT, SearchIndex, SemanticSearchEngine, SybilDefense, 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, 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, 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 };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map