@rookdaemon/agora 0.2.7 → 0.2.9

package/dist/chunk-JUOGKXFN.js

@@ -0,0 +1,1645 @@
+// src/identity/keypair.ts
+import { sign, verify, generateKeyPairSync } from "crypto";
+function generateKeyPair() {
+  const { publicKey, privateKey } = generateKeyPairSync("ed25519");
+  return {
+    publicKey: publicKey.export({ type: "spki", format: "der" }).toString("hex"),
+    privateKey: privateKey.export({ type: "pkcs8", format: "der" }).toString("hex")
+  };
+}
+function signMessage(message, privateKeyHex) {
+  const messageBuffer = typeof message === "string" ? Buffer.from(message) : message;
+  const privateKey = Buffer.from(privateKeyHex, "hex");
+  const signature = sign(null, messageBuffer, {
+    key: privateKey,
+    format: "der",
+    type: "pkcs8"
+  });
+  return signature.toString("hex");
+}
+function verifySignature(message, signatureHex, publicKeyHex) {
+  const messageBuffer = typeof message === "string" ? Buffer.from(message) : message;
+  const signature = Buffer.from(signatureHex, "hex");
+  const publicKey = Buffer.from(publicKeyHex, "hex");
+  try {
+    return verify(null, messageBuffer, {
+      key: publicKey,
+      format: "der",
+      type: "spki"
+    }, signature);
+  } catch {
+    return false;
+  }
+}
+function exportKeyPair(keyPair) {
+  return {
+    publicKey: keyPair.publicKey,
+    privateKey: keyPair.privateKey
+  };
+}
+function importKeyPair(publicKeyHex, privateKeyHex) {
+  const hexPattern = /^[0-9a-f]+$/i;
+  if (!hexPattern.test(publicKeyHex)) {
+    throw new Error("Invalid public key: must be a hex string");
+  }
+  if (!hexPattern.test(privateKeyHex)) {
+    throw new Error("Invalid private key: must be a hex string");
+  }
+  return {
+    publicKey: publicKeyHex,
+    privateKey: privateKeyHex
+  };
+}
+
+// src/transport/peer-config.ts
+import { readFileSync, writeFileSync, existsSync } from "fs";
+function loadPeerConfig(path2) {
+  const content = readFileSync(path2, "utf-8");
+  return JSON.parse(content);
+}
+function savePeerConfig(path2, config) {
+  const content = JSON.stringify(config, null, 2);
+  writeFileSync(path2, content, "utf-8");
+}
+function initPeerConfig(path2) {
+  if (existsSync(path2)) {
+    return loadPeerConfig(path2);
+  }
+  const identity = generateKeyPair();
+  const config = {
+    identity,
+    peers: {}
+  };
+  savePeerConfig(path2, config);
+  return config;
+}
+
+// src/message/envelope.ts
+import { createHash } from "crypto";
+function stableStringify(value) {
+  if (value === null || value === void 0) return JSON.stringify(value);
+  if (typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) {
+    return "[" + value.map(stableStringify).join(",") + "]";
+  }
+  const keys = Object.keys(value).sort();
+  const pairs = keys.map((k) => JSON.stringify(k) + ":" + stableStringify(value[k]));
+  return "{" + pairs.join(",") + "}";
+}
+function canonicalize(type, sender, timestamp, payload, inReplyTo) {
+  const obj = { payload, sender, timestamp, type };
+  if (inReplyTo !== void 0) {
+    obj.inReplyTo = inReplyTo;
+  }
+  return stableStringify(obj);
+}
+function computeId(canonical) {
+  return createHash("sha256").update(canonical).digest("hex");
+}
+function createEnvelope(type, sender, privateKey, payload, timestamp = Date.now(), inReplyTo) {
+  const canonical = canonicalize(type, sender, timestamp, payload, inReplyTo);
+  const id = computeId(canonical);
+  const signature = signMessage(canonical, privateKey);
+  return {
+    id,
+    type,
+    sender,
+    timestamp,
+    ...inReplyTo !== void 0 ? { inReplyTo } : {},
+    payload,
+    signature
+  };
+}
+function verifyEnvelope(envelope) {
+  const { id, type, sender, timestamp, payload, signature, inReplyTo } = envelope;
+  const canonical = canonicalize(type, sender, timestamp, payload, inReplyTo);
+  const expectedId = computeId(canonical);
+  if (id !== expectedId) {
+    return { valid: false, reason: "id_mismatch" };
+  }
+  const sigValid = verifySignature(canonical, signature, sender);
+  if (!sigValid) {
+    return { valid: false, reason: "signature_invalid" };
+  }
+  return { valid: true };
+}
+
+// src/transport/http.ts
+async function sendToPeer(config, peerPublicKey, type, payload, inReplyTo) {
+  const peer = config.peers.get(peerPublicKey);
+  if (!peer) {
+    return { ok: false, status: 0, error: "Unknown peer" };
+  }
+  if (!peer.url) {
+    return { ok: false, status: 0, error: "No webhook URL configured" };
+  }
+  const envelope = createEnvelope(
+    type,
+    config.identity.publicKey,
+    config.identity.privateKey,
+    payload,
+    Date.now(),
+    inReplyTo
+  );
+  const envelopeJson = JSON.stringify(envelope);
+  const envelopeBase64 = Buffer.from(envelopeJson).toString("base64url");
+  const webhookPayload = {
+    message: `[AGORA_ENVELOPE]${envelopeBase64}`,
+    name: "Agora",
+    sessionKey: `agora:${envelope.sender.substring(0, 16)}`,
+    deliver: false
+  };
+  try {
+    const response = await fetch(`${peer.url}/agent`, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${peer.token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(webhookPayload)
+    });
+    return {
+      ok: response.ok,
+      status: response.status,
+      error: response.ok ? void 0 : await response.text()
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      status: 0,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+function decodeInboundEnvelope(message, knownPeers) {
+  const prefix = "[AGORA_ENVELOPE]";
+  if (!message.startsWith(prefix)) {
+    return { ok: false, reason: "not_agora_message" };
+  }
+  const base64Payload = message.substring(prefix.length);
+  if (!base64Payload) {
+    return { ok: false, reason: "invalid_base64" };
+  }
+  let envelopeJson;
+  try {
+    const decoded = Buffer.from(base64Payload, "base64url");
+    if (decoded.length === 0) {
+      return { ok: false, reason: "invalid_base64" };
+    }
+    envelopeJson = decoded.toString("utf-8");
+  } catch {
+    return { ok: false, reason: "invalid_base64" };
+  }
+  let envelope;
+  try {
+    envelope = JSON.parse(envelopeJson);
+  } catch {
+    return { ok: false, reason: "invalid_json" };
+  }
+  const verification = verifyEnvelope(envelope);
+  if (!verification.valid) {
+    return { ok: false, reason: verification.reason || "verification_failed" };
+  }
+  const senderKnown = knownPeers.has(envelope.sender);
+  if (!senderKnown) {
+    return { ok: false, reason: "unknown_sender" };
+  }
+  return { ok: true, envelope };
+}
+
+// src/transport/relay.ts
+import WebSocket from "ws";
+async function sendViaRelay(config, peerPublicKey, type, payload, inReplyTo) {
+  if (config.relayClient && config.relayClient.connected()) {
+    const envelope = createEnvelope(
+      type,
+      config.identity.publicKey,
+      config.identity.privateKey,
+      payload,
+      Date.now(),
+      inReplyTo
+    );
+    return config.relayClient.send(peerPublicKey, envelope);
+  }
+  return new Promise((resolve) => {
+    const ws = new WebSocket(config.relayUrl);
+    let registered = false;
+    let messageSent = false;
+    let resolved = false;
+    const resolveOnce = (result) => {
+      if (!resolved) {
+        resolved = true;
+        clearTimeout(timeout);
+        resolve(result);
+      }
+    };
+    const timeout = setTimeout(() => {
+      if (!messageSent) {
+        ws.close();
+        resolveOnce({ ok: false, error: "Relay connection timeout" });
+      }
+    }, 1e4);
+    ws.on("open", () => {
+      const registerMsg = {
+        type: "register",
+        publicKey: config.identity.publicKey
+      };
+      ws.send(JSON.stringify(registerMsg));
+    });
+    ws.on("message", (data) => {
+      try {
+        const msg = JSON.parse(data.toString());
+        if (msg.type === "registered" && !registered) {
+          registered = true;
+          const envelope = createEnvelope(
+            type,
+            config.identity.publicKey,
+            config.identity.privateKey,
+            payload,
+            Date.now(),
+            inReplyTo
+          );
+          const relayMsg = {
+            type: "message",
+            to: peerPublicKey,
+            envelope
+          };
+          ws.send(JSON.stringify(relayMsg));
+          messageSent = true;
+          setTimeout(() => {
+            ws.close();
+            resolveOnce({ ok: true });
+          }, 100);
+        } else if (msg.type === "error") {
+          ws.close();
+          resolveOnce({ ok: false, error: msg.message || "Relay server error" });
+        }
+      } catch (err) {
+        ws.close();
+        resolveOnce({ ok: false, error: err instanceof Error ? err.message : String(err) });
+      }
+    });
+    ws.on("error", (err) => {
+      ws.close();
+      resolveOnce({ ok: false, error: err.message });
+    });
+    ws.on("close", () => {
+      if (!messageSent) {
+        resolveOnce({ ok: false, error: "Connection closed before message sent" });
+      }
+    });
+  });
+}
+
+// src/relay/store.ts
+import * as fs from "fs";
+import * as path from "path";
+var MessageStore = class {
+  storageDir;
+  constructor(storageDir) {
+    this.storageDir = storageDir;
+    fs.mkdirSync(storageDir, { recursive: true });
+  }
+  recipientDir(publicKey) {
+    const safe = publicKey.replace(/[^a-zA-Z0-9_-]/g, "_");
+    return path.join(this.storageDir, safe);
+  }
+  save(recipientKey, message) {
+    const dir = this.recipientDir(recipientKey);
+    fs.mkdirSync(dir, { recursive: true });
+    const filename = `${Date.now()}-${crypto.randomUUID()}.json`;
+    fs.writeFileSync(path.join(dir, filename), JSON.stringify(message));
+  }
+  load(recipientKey) {
+    const dir = this.recipientDir(recipientKey);
+    if (!fs.existsSync(dir)) return [];
+    const files = fs.readdirSync(dir).sort();
+    const messages = [];
+    for (const file of files) {
+      if (!file.endsWith(".json")) continue;
+      try {
+        const data = fs.readFileSync(path.join(dir, file), "utf8");
+        messages.push(JSON.parse(data));
+      } catch {
+      }
+    }
+    return messages;
+  }
+  clear(recipientKey) {
+    const dir = this.recipientDir(recipientKey);
+    if (!fs.existsSync(dir)) return;
+    const files = fs.readdirSync(dir);
+    for (const file of files) {
+      if (file.endsWith(".json")) {
+        fs.unlinkSync(path.join(dir, file));
+      }
+    }
+  }
+};
+
+// src/relay/server.ts
+import { EventEmitter } from "events";
+import { WebSocketServer, WebSocket as WebSocket2 } from "ws";
+var RelayServer = class extends EventEmitter {
+  wss = null;
+  agents = /* @__PURE__ */ new Map();
+  identity;
+  storagePeers = [];
+  store = null;
+  constructor(options) {
+    super();
+    if (options) {
+      if ("identity" in options && options.identity) {
+        this.identity = options.identity;
+      } else if ("publicKey" in options && "privateKey" in options) {
+        this.identity = { publicKey: options.publicKey, privateKey: options.privateKey };
+      }
+      const opts = options;
+      if (opts.storagePeers?.length && opts.storageDir) {
+        this.storagePeers = opts.storagePeers;
+        this.store = new MessageStore(opts.storageDir);
+      }
+    }
+  }
+  /**
+   * Start the relay server
+   * @param port - Port to listen on
+   * @param host - Optional host (default: all interfaces)
+   */
+  start(port, host) {
+    return new Promise((resolve, reject) => {
+      try {
+        this.wss = new WebSocketServer({ port, host: host ?? "0.0.0.0" });
+        let resolved = false;
+        this.wss.on("error", (error) => {
+          this.emit("error", error);
+          if (!resolved) {
+            resolved = true;
+            reject(error);
+          }
+        });
+        this.wss.on("listening", () => {
+          if (!resolved) {
+            resolved = true;
+            resolve();
+          }
+        });
+        this.wss.on("connection", (socket) => {
+          this.handleConnection(socket);
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Stop the relay server
+   */
+  async stop() {
+    return new Promise((resolve, reject) => {
+      if (!this.wss) {
+        resolve();
+        return;
+      }
+      for (const agent of this.agents.values()) {
+        agent.socket.close();
+      }
+      this.agents.clear();
+      this.wss.close((err) => {
+        if (err) {
+          reject(err);
+        } else {
+          this.wss = null;
+          resolve();
+        }
+      });
+    });
+  }
+  /**
+   * Get all connected agents
+   */
+  getAgents() {
+    return new Map(this.agents);
+  }
+  /**
+   * Handle incoming connection
+   */
+  handleConnection(socket) {
+    let agentPublicKey = null;
+    socket.on("message", (data) => {
+      try {
+        const msg = JSON.parse(data.toString());
+        if (msg.type === "register" && !agentPublicKey) {
+          if (!msg.publicKey || typeof msg.publicKey !== "string") {
+            this.sendError(socket, "Invalid registration: missing or invalid publicKey");
+            socket.close();
+            return;
+          }
+          const publicKey = msg.publicKey;
+          const name = msg.name;
+          agentPublicKey = publicKey;
+          const existing = this.agents.get(publicKey);
+          if (existing) {
+            existing.socket.close();
+          }
+          const agent = {
+            publicKey,
+            name,
+            socket,
+            lastSeen: Date.now()
+          };
+          this.agents.set(publicKey, agent);
+          this.emit("agent-registered", publicKey);
+          let peers = Array.from(this.agents.values()).filter((a) => a.publicKey !== publicKey).map((a) => ({ publicKey: a.publicKey, name: a.name }));
+          for (const storagePeer of this.storagePeers) {
+            if (storagePeer !== publicKey && !this.agents.has(storagePeer)) {
+              peers.push({ publicKey: storagePeer, name: void 0 });
+            }
+          }
+          socket.send(JSON.stringify({
+            type: "registered",
+            publicKey,
+            peers
+          }));
+          this.broadcastPeerEvent("peer_online", publicKey, name);
+          if (this.store && this.storagePeers.includes(publicKey)) {
+            const queued = this.store.load(publicKey);
+            for (const stored of queued) {
+              socket.send(JSON.stringify({
+                type: "message",
+                from: stored.from,
+                name: stored.name,
+                envelope: stored.envelope
+              }));
+            }
+            this.store.clear(publicKey);
+          }
+          return;
+        }
+        if (!agentPublicKey) {
+          this.sendError(socket, "Not registered: send registration message first");
+          socket.close();
+          return;
+        }
+        if (msg.type === "message") {
+          if (!msg.to || typeof msg.to !== "string") {
+            this.sendError(socket, 'Invalid message: missing or invalid "to" field');
+            return;
+          }
+          if (!msg.envelope || typeof msg.envelope !== "object") {
+            this.sendError(socket, 'Invalid message: missing or invalid "envelope" field');
+            return;
+          }
+          const envelope = msg.envelope;
+          const verification = verifyEnvelope(envelope);
+          if (!verification.valid) {
+            this.sendError(socket, `Invalid envelope: ${verification.reason || "verification failed"}`);
+            return;
+          }
+          if (envelope.sender !== agentPublicKey) {
+            this.sendError(socket, "Envelope sender does not match registered public key");
+            return;
+          }
+          const senderAgent = this.agents.get(agentPublicKey);
+          if (senderAgent) {
+            senderAgent.lastSeen = Date.now();
+          }
+          if (envelope.type === "peer_list_request" && this.identity && msg.to === this.identity.publicKey) {
+            this.handlePeerListRequest(envelope, socket, agentPublicKey);
+            return;
+          }
+          const recipient = this.agents.get(msg.to);
+          if (!recipient || recipient.socket.readyState !== WebSocket2.OPEN) {
+            if (this.store && this.storagePeers.includes(msg.to)) {
+              const senderAgent2 = this.agents.get(agentPublicKey);
+              this.store.save(msg.to, {
+                from: agentPublicKey,
+                name: senderAgent2?.name,
+                envelope
+              });
+              this.emit("message-relayed", agentPublicKey, msg.to, envelope);
+            } else {
+              this.sendError(socket, "Recipient not connected");
+            }
+            return;
+          }
+          try {
+            const senderAgent2 = this.agents.get(agentPublicKey);
+            const relayMessage = {
+              type: "message",
+              from: agentPublicKey,
+              name: senderAgent2?.name,
+              envelope
+            };
+            recipient.socket.send(JSON.stringify(relayMessage));
+            this.emit("message-relayed", agentPublicKey, msg.to, envelope);
+          } catch (err) {
+            this.sendError(socket, "Failed to relay message");
+            this.emit("error", err);
+          }
+          return;
+        }
+        if (msg.type === "broadcast") {
+          if (!msg.envelope || typeof msg.envelope !== "object") {
+            this.sendError(socket, 'Invalid broadcast: missing or invalid "envelope" field');
+            return;
+          }
+          const envelope = msg.envelope;
+          const verification = verifyEnvelope(envelope);
+          if (!verification.valid) {
+            this.sendError(socket, `Invalid envelope: ${verification.reason || "verification failed"}`);
+            return;
+          }
+          if (envelope.sender !== agentPublicKey) {
+            this.sendError(socket, "Envelope sender does not match registered public key");
+            return;
+          }
+          const senderAgentBroadcast = this.agents.get(agentPublicKey);
+          if (senderAgentBroadcast) {
+            senderAgentBroadcast.lastSeen = Date.now();
+          }
+          const senderAgent = this.agents.get(agentPublicKey);
+          const relayMessage = {
+            type: "message",
+            from: agentPublicKey,
+            name: senderAgent?.name,
+            envelope
+          };
+          const messageStr = JSON.stringify(relayMessage);
+          for (const agent of this.agents.values()) {
+            if (agent.publicKey !== agentPublicKey && agent.socket.readyState === WebSocket2.OPEN) {
+              try {
+                agent.socket.send(messageStr);
+              } catch (err) {
+                this.emit("error", err);
+              }
+            }
+          }
+          return;
+        }
+        if (msg.type === "ping") {
+          socket.send(JSON.stringify({ type: "pong" }));
+          return;
+        }
+        this.sendError(socket, `Unknown message type: ${msg.type}`);
+      } catch (err) {
+        this.emit("error", new Error(`Message parsing failed: ${err instanceof Error ? err.message : String(err)}`));
+        this.sendError(socket, "Invalid message format");
+      }
+    });
+    socket.on("close", () => {
+      if (agentPublicKey) {
+        const agent = this.agents.get(agentPublicKey);
+        const agentName = agent?.name;
+        this.agents.delete(agentPublicKey);
+        this.emit("agent-disconnected", agentPublicKey);
+        if (!this.storagePeers.includes(agentPublicKey)) {
+          this.broadcastPeerEvent("peer_offline", agentPublicKey, agentName);
+        }
+      }
+    });
+    socket.on("error", (error) => {
+      this.emit("error", error);
+    });
+  }
+  /**
+   * Send an error message to a client
+   */
+  sendError(socket, message) {
+    try {
+      if (socket.readyState === WebSocket2.OPEN) {
+        socket.send(JSON.stringify({ type: "error", message }));
+      }
+    } catch (err) {
+      this.emit("error", new Error(`Failed to send error message: ${err instanceof Error ? err.message : String(err)}`));
+    }
+  }
+  /**
+   * Broadcast a peer event to all connected agents
+   */
+  broadcastPeerEvent(eventType, publicKey, name) {
+    const message = {
+      type: eventType,
+      publicKey,
+      name
+    };
+    const messageStr = JSON.stringify(message);
+    for (const agent of this.agents.values()) {
+      if (agent.publicKey !== publicKey && agent.socket.readyState === WebSocket2.OPEN) {
+        try {
+          agent.socket.send(messageStr);
+        } catch (err) {
+          this.emit("error", new Error(`Failed to send ${eventType} event: ${err instanceof Error ? err.message : String(err)}`));
+        }
+      }
+    }
+  }
+  /**
+   * Handle peer list request from an agent
+   */
+  handlePeerListRequest(envelope, socket, requesterPublicKey) {
+    if (!this.identity) {
+      this.sendError(socket, "Relay does not support peer discovery (no identity configured)");
+      return;
+    }
+    const { filters } = envelope.payload;
+    const now = Date.now();
+    let peers = Array.from(this.agents.values());
+    peers = peers.filter((p) => p.publicKey !== requesterPublicKey);
+    if (filters?.activeWithin) {
+      peers = peers.filter((p) => now - p.lastSeen < filters.activeWithin);
+    }
+    if (filters?.limit && filters.limit > 0) {
+      peers = peers.slice(0, filters.limit);
+    }
+    const response = {
+      peers: peers.map((p) => ({
+        publicKey: p.publicKey,
+        metadata: p.name || p.metadata ? {
+          name: p.name,
+          version: p.metadata?.version,
+          capabilities: p.metadata?.capabilities
+        } : void 0,
+        lastSeen: p.lastSeen
+      })),
+      totalPeers: this.agents.size - 1,
+      // Exclude requester from count
+      relayPublicKey: this.identity.publicKey
+    };
+    const responseEnvelope = createEnvelope(
+      "peer_list_response",
+      this.identity.publicKey,
+      this.identity.privateKey,
+      response,
+      Date.now(),
+      envelope.id
+      // Reply to the request
+    );
+    const relayMessage = {
+      type: "message",
+      from: this.identity.publicKey,
+      name: "relay",
+      envelope: responseEnvelope
+    };
+    try {
+      socket.send(JSON.stringify(relayMessage));
+    } catch (err) {
+      this.emit("error", new Error(`Failed to send peer list response: ${err instanceof Error ? err.message : String(err)}`));
+    }
+  }
+};
+
+// src/relay/client.ts
+import { EventEmitter as EventEmitter2 } from "events";
+import WebSocket3 from "ws";
+var RelayClient = class extends EventEmitter2 {
+  ws = null;
+  config;
+  reconnectAttempts = 0;
+  reconnectTimeout = null;
+  pingInterval = null;
+  isConnected = false;
+  isRegistered = false;
+  shouldReconnect = true;
+  onlinePeers = /* @__PURE__ */ new Map();
+  constructor(config) {
+    super();
+    this.config = {
+      pingInterval: 3e4,
+      maxReconnectDelay: 6e4,
+      ...config
+    };
+  }
+  /**
+   * Connect to the relay server
+   */
+  async connect() {
+    if (this.ws && (this.ws.readyState === WebSocket3.CONNECTING || this.ws.readyState === WebSocket3.OPEN)) {
+      return;
+    }
+    this.shouldReconnect = true;
+    return this.doConnect();
+  }
+  /**
+   * Disconnect from the relay server
+   */
+  disconnect() {
+    this.shouldReconnect = false;
+    this.cleanup();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+  /**
+   * Check if currently connected and registered
+   */
+  connected() {
+    return this.isConnected && this.isRegistered;
+  }
+  /**
+   * Send a message to a specific peer
+   */
+  async send(to, envelope) {
+    if (!this.connected()) {
+      return { ok: false, error: "Not connected to relay" };
+    }
+    const message = {
+      type: "message",
+      to,
+      envelope
+    };
+    try {
+      this.ws.send(JSON.stringify(message));
+      return { ok: true };
+    } catch (err) {
+      return { ok: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  /**
+   * Broadcast a message to all connected peers
+   */
+  async broadcast(envelope) {
+    if (!this.connected()) {
+      return { ok: false, error: "Not connected to relay" };
+    }
+    const message = {
+      type: "broadcast",
+      envelope
+    };
+    try {
+      this.ws.send(JSON.stringify(message));
+      return { ok: true };
+    } catch (err) {
+      return { ok: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  /**
+   * Get list of currently online peers
+   */
+  getOnlinePeers() {
+    return Array.from(this.onlinePeers.values());
+  }
+  /**
+   * Check if a specific peer is online
+   */
+  isPeerOnline(publicKey) {
+    return this.onlinePeers.has(publicKey);
+  }
+  /**
+   * Internal: Perform connection
+   */
+  async doConnect() {
+    return new Promise((resolve, reject) => {
+      try {
+        this.ws = new WebSocket3(this.config.relayUrl);
+        let resolved = false;
+        const resolveOnce = (callback) => {
+          if (!resolved) {
+            resolved = true;
+            callback();
+          }
+        };
+        this.ws.on("open", () => {
+          this.isConnected = true;
+          this.reconnectAttempts = 0;
+          this.startPingInterval();
+          const registerMsg = {
+            type: "register",
+            publicKey: this.config.publicKey,
+            name: this.config.name
+          };
+          this.ws.send(JSON.stringify(registerMsg));
+        });
+        this.ws.on("message", (data) => {
+          try {
+            const msg = JSON.parse(data.toString());
+            this.handleMessage(msg);
+            if (msg.type === "registered" && !resolved) {
+              resolveOnce(() => resolve());
+            }
+          } catch (err) {
+            this.emit("error", new Error(`Failed to parse message: ${err instanceof Error ? err.message : String(err)}`));
+          }
+        });
+        this.ws.on("close", () => {
+          this.isConnected = false;
+          this.isRegistered = false;
+          this.cleanup();
+          this.emit("disconnected");
+          if (this.shouldReconnect) {
+            this.scheduleReconnect();
+          }
+          if (!resolved) {
+            resolveOnce(() => reject(new Error("Connection closed before registration")));
+          }
+        });
+        this.ws.on("error", (err) => {
+          this.emit("error", err);
+          if (!resolved) {
+            resolveOnce(() => reject(err));
+          }
+        });
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+  /**
+   * Handle incoming message from relay
+   */
+  handleMessage(msg) {
+    switch (msg.type) {
+      case "registered":
+        this.isRegistered = true;
+        if (msg.peers) {
+          for (const peer of msg.peers) {
+            this.onlinePeers.set(peer.publicKey, peer);
+          }
+        }
+        this.emit("connected");
+        break;
+      case "message":
+        if (msg.envelope && msg.from) {
+          const verification = verifyEnvelope(msg.envelope);
+          if (!verification.valid) {
+            this.emit("error", new Error(`Invalid envelope signature: ${verification.reason}`));
+            return;
+          }
+          if (msg.envelope.sender !== msg.from) {
+            this.emit("error", new Error("Envelope sender does not match relay from field"));
+            return;
+          }
+          this.emit("message", msg.envelope, msg.from, msg.name);
+        }
+        break;
+      case "peer_online":
+        if (msg.publicKey) {
+          const peer = {
+            publicKey: msg.publicKey,
+            name: msg.name
+          };
+          this.onlinePeers.set(msg.publicKey, peer);
+          this.emit("peer_online", peer);
+        }
+        break;
+      case "peer_offline":
+        if (msg.publicKey) {
+          const peer = this.onlinePeers.get(msg.publicKey);
+          if (peer) {
+            this.onlinePeers.delete(msg.publicKey);
+            this.emit("peer_offline", peer);
+          }
+        }
+        break;
+      case "error":
+        this.emit("error", new Error(`Relay error: ${msg.message || "Unknown error"}`));
+        break;
+      case "pong":
+        break;
+      default:
+        break;
+    }
+  }
+  /**
+   * Schedule reconnection with exponential backoff
+   */
+  scheduleReconnect() {
+    if (this.reconnectTimeout) {
+      return;
+    }
+    const delay = Math.min(
+      1e3 * Math.pow(2, this.reconnectAttempts),
+      this.config.maxReconnectDelay
+    );
+    this.reconnectAttempts++;
+    this.reconnectTimeout = setTimeout(() => {
+      this.reconnectTimeout = null;
+      if (this.shouldReconnect) {
+        this.doConnect().catch((err) => {
+          this.emit("error", err);
+        });
+      }
+    }, delay);
+  }
+  /**
+   * Start periodic ping messages
+   */
+  startPingInterval() {
+    this.stopPingInterval();
+    this.pingInterval = setInterval(() => {
+      if (this.ws && this.ws.readyState === WebSocket3.OPEN) {
+        const ping = { type: "ping" };
+        this.ws.send(JSON.stringify(ping));
+      }
+    }, this.config.pingInterval);
+  }
+  /**
+   * Stop ping interval
+   */
+  stopPingInterval() {
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+      this.pingInterval = null;
+    }
+  }
+  /**
+   * Cleanup resources
+   */
+  cleanup() {
+    this.stopPingInterval();
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+    this.onlinePeers.clear();
+  }
+};
+
+// src/discovery/peer-discovery.ts
+import { EventEmitter as EventEmitter3 } from "events";
+var PeerDiscoveryService = class extends EventEmitter3 {
+  config;
+  constructor(config) {
+    super();
+    this.config = config;
+    this.config.relayClient.on("message", (envelope, from) => {
+      if (envelope.type === "peer_list_response") {
+        this.handlePeerList(envelope);
+      } else if (envelope.type === "peer_referral") {
+        this.handleReferral(envelope, from);
+      }
+    });
+  }
+  /**
+   * Request peer list from relay
+   */
+  async discoverViaRelay(filters) {
+    if (!this.config.relayPublicKey) {
+      throw new Error("Relay public key not configured");
+    }
+    if (!this.config.relayClient.connected()) {
+      throw new Error("Not connected to relay");
+    }
+    const payload = filters ? { filters } : {};
+    const envelope = createEnvelope(
+      "peer_list_request",
+      this.config.publicKey,
+      this.config.privateKey,
+      payload
+    );
+    const result = await this.config.relayClient.send(this.config.relayPublicKey, envelope);
+    if (!result.ok) {
+      throw new Error(`Failed to send peer list request: ${result.error}`);
+    }
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        cleanup();
+        reject(new Error("Peer list request timed out"));
+      }, 1e4);
+      const messageHandler = (responseEnvelope, from) => {
+        if (responseEnvelope.type === "peer_list_response" && responseEnvelope.inReplyTo === envelope.id && from === this.config.relayPublicKey) {
+          cleanup();
+          resolve(responseEnvelope.payload);
+        }
+      };
+      const cleanup = () => {
+        clearTimeout(timeout);
+        this.config.relayClient.off("message", messageHandler);
+      };
+      this.config.relayClient.on("message", messageHandler);
+    });
+  }
+  /**
+   * Send peer referral to another agent
+   */
+  async referPeer(recipientPublicKey, referredPublicKey, metadata) {
+    if (!this.config.relayClient.connected()) {
+      return { ok: false, error: "Not connected to relay" };
+    }
+    const payload = {
+      publicKey: referredPublicKey,
+      endpoint: metadata?.endpoint,
+      metadata: metadata?.name ? { name: metadata.name } : void 0,
+      comment: metadata?.comment,
+      trustScore: metadata?.trustScore
+    };
+    const envelope = createEnvelope(
+      "peer_referral",
+      this.config.publicKey,
+      this.config.privateKey,
+      payload
+    );
+    return this.config.relayClient.send(recipientPublicKey, envelope);
+  }
+  /**
+   * Handle incoming peer referral
+   */
+  handleReferral(envelope, from) {
+    const verification = verifyEnvelope(envelope);
+    if (!verification.valid) {
+      this.emit("error", new Error(`Invalid peer referral: ${verification.reason}`));
+      return;
+    }
+    this.emit("peer-referral", envelope.payload, from);
+  }
+  /**
+   * Handle incoming peer list from relay
+   */
+  handlePeerList(envelope) {
+    const verification = verifyEnvelope(envelope);
+    if (!verification.valid) {
+      this.emit("error", new Error(`Invalid peer list response: ${verification.reason}`));
+      return;
+    }
+    if (envelope.sender !== this.config.relayPublicKey) {
+      this.emit("error", new Error("Peer list response not from configured relay"));
+      return;
+    }
+    this.emit("peers-discovered", envelope.payload.peers);
+  }
+};
+
+// src/discovery/bootstrap.ts
+var DEFAULT_BOOTSTRAP_RELAYS = [
+  {
+    url: "wss://agora-relay.lbsa71.net",
+    name: "Primary Bootstrap Relay"
+    // Note: Public key would need to be set when the relay is actually deployed
+    // For now, this is a placeholder that would be configured when the relay is running
+  }
+];
+function getDefaultBootstrapRelay() {
+  return {
+    relayUrl: DEFAULT_BOOTSTRAP_RELAYS[0].url,
+    timeout: 1e4
+  };
+}
+function parseBootstrapRelay(url, publicKey) {
+  return {
+    relayUrl: url,
+    relayPublicKey: publicKey,
+    timeout: 1e4
+  };
+}
+
+// src/utils.ts
+function shortKey(publicKey) {
+  return "..." + publicKey.slice(-8);
+}
+function resolveBroadcastName(config, cliName) {
+  if (cliName) {
+    return cliName;
+  }
+  if (config.relay) {
+    if (typeof config.relay === "object" && config.relay.name) {
+      return config.relay.name;
+    }
+  }
+  if (config.identity.name) {
+    return config.identity.name;
+  }
+  return void 0;
+}
+function formatDisplayName(name, publicKey) {
+  const shortId = shortKey(publicKey);
+  if (!name || name.trim() === "" || name.startsWith("...")) {
+    return shortId;
+  }
+  return `${name} (${shortId})`;
+}
+
+// src/reputation/types.ts
+function validateVerificationRecord(record) {
+  const errors = [];
+  if (typeof record !== "object" || record === null) {
+    return { valid: false, errors: ["Record must be an object"] };
+  }
+  const r = record;
+  if (typeof r.id !== "string" || r.id.length === 0) {
+    errors.push("id must be a non-empty string");
+  }
+  if (typeof r.verifier !== "string" || r.verifier.length === 0) {
+    errors.push("verifier must be a non-empty string");
+  }
+  if (typeof r.target !== "string" || r.target.length === 0) {
+    errors.push("target must be a non-empty string");
+  }
+  if (typeof r.domain !== "string" || r.domain.length === 0) {
+    errors.push("domain must be a non-empty string");
+  }
+  if (!["correct", "incorrect", "disputed"].includes(r.verdict)) {
+    errors.push("verdict must be one of: correct, incorrect, disputed");
+  }
+  if (typeof r.confidence !== "number" || r.confidence < 0 || r.confidence > 1) {
+    errors.push("confidence must be a number between 0 and 1");
+  }
+  if (r.evidence !== void 0 && typeof r.evidence !== "string") {
+    errors.push("evidence must be a string if provided");
+  }
+  if (typeof r.timestamp !== "number" || r.timestamp <= 0) {
+    errors.push("timestamp must be a positive number");
+  }
+  if (typeof r.signature !== "string" || r.signature.length === 0) {
+    errors.push("signature must be a non-empty string");
+  }
+  return { valid: errors.length === 0, errors };
+}
+function validateCommitRecord(record) {
+  const errors = [];
+  if (typeof record !== "object" || record === null) {
+    return { valid: false, errors: ["Record must be an object"] };
+  }
+  const r = record;
+  if (typeof r.id !== "string" || r.id.length === 0) {
+    errors.push("id must be a non-empty string");
+  }
+  if (typeof r.agent !== "string" || r.agent.length === 0) {
+    errors.push("agent must be a non-empty string");
+  }
+  if (typeof r.domain !== "string" || r.domain.length === 0) {
+    errors.push("domain must be a non-empty string");
+  }
+  if (typeof r.commitment !== "string" || r.commitment.length !== 64) {
+    errors.push("commitment must be a 64-character hex string (SHA-256 hash)");
+  }
+  if (typeof r.timestamp !== "number" || r.timestamp <= 0) {
+    errors.push("timestamp must be a positive number");
+  }
+  if (typeof r.expiry !== "number" || r.expiry <= 0) {
+    errors.push("expiry must be a positive number");
+  }
+  if (typeof r.expiry === "number" && typeof r.timestamp === "number" && r.expiry <= r.timestamp) {
+    errors.push("expiry must be after timestamp");
+  }
+  if (typeof r.signature !== "string" || r.signature.length === 0) {
+    errors.push("signature must be a non-empty string");
+  }
+  return { valid: errors.length === 0, errors };
+}
+function validateRevealRecord(record) {
+  const errors = [];
+  if (typeof record !== "object" || record === null) {
+    return { valid: false, errors: ["Record must be an object"] };
+  }
+  const r = record;
+  if (typeof r.id !== "string" || r.id.length === 0) {
+    errors.push("id must be a non-empty string");
+  }
+  if (typeof r.agent !== "string" || r.agent.length === 0) {
+    errors.push("agent must be a non-empty string");
+  }
+  if (typeof r.commitmentId !== "string" || r.commitmentId.length === 0) {
+    errors.push("commitmentId must be a non-empty string");
+  }
+  if (typeof r.prediction !== "string" || r.prediction.length === 0) {
+    errors.push("prediction must be a non-empty string");
+  }
+  if (typeof r.outcome !== "string" || r.outcome.length === 0) {
+    errors.push("outcome must be a non-empty string");
+  }
+  if (r.evidence !== void 0 && typeof r.evidence !== "string") {
+    errors.push("evidence must be a string if provided");
+  }
+  if (typeof r.timestamp !== "number" || r.timestamp <= 0) {
+    errors.push("timestamp must be a positive number");
+  }
+  if (typeof r.signature !== "string" || r.signature.length === 0) {
+    errors.push("signature must be a non-empty string");
+  }
+  return { valid: errors.length === 0, errors };
+}
+
+// src/reputation/store.ts
+import { promises as fs2 } from "fs";
+import { dirname } from "path";
+var ReputationStore = class {
+  filePath;
+  verifications = /* @__PURE__ */ new Map();
+  commits = /* @__PURE__ */ new Map();
+  reveals = /* @__PURE__ */ new Map();
+  loaded = false;
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  /**
+   * Load records from JSONL file
+   */
+  async load() {
+    try {
+      const content = await fs2.readFile(this.filePath, "utf-8");
+      const lines = content.trim().split("\n").filter((line) => line.length > 0);
+      for (const line of lines) {
+        try {
+          const record = JSON.parse(line);
+          switch (record.type) {
+            case "verification": {
+              const { type: _type, ...verification } = record;
+              const validation = validateVerificationRecord(verification);
+              if (validation.valid) {
+                this.verifications.set(verification.id, verification);
+              }
+              break;
+            }
+            case "commit": {
+              const { type: _type, ...commit } = record;
+              const validation = validateCommitRecord(commit);
+              if (validation.valid) {
+                this.commits.set(commit.id, commit);
+              }
+              break;
+            }
+            case "reveal": {
+              const { type: _type, ...reveal } = record;
+              const validation = validateRevealRecord(reveal);
+              if (validation.valid) {
+                this.reveals.set(reveal.id, reveal);
+              }
+              break;
+            }
+          }
+        } catch {
+          continue;
+        }
+      }
+      this.loaded = true;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        this.loaded = true;
+        return;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Ensure the store is loaded
+   */
+  async ensureLoaded() {
+    if (!this.loaded) {
+      await this.load();
+    }
+  }
+  /**
+   * Append a record to the JSONL file
+   */
+  async appendToFile(record) {
+    await fs2.mkdir(dirname(this.filePath), { recursive: true });
+    const line = JSON.stringify(record) + "\n";
+    await fs2.appendFile(this.filePath, line, "utf-8");
+  }
+  /**
+   * Add a verification record
+   */
+  async addVerification(verification) {
+    await this.ensureLoaded();
+    const validation = validateVerificationRecord(verification);
+    if (!validation.valid) {
+      throw new Error(`Invalid verification: ${validation.errors.join(", ")}`);
+    }
+    this.verifications.set(verification.id, verification);
+    await this.appendToFile({ type: "verification", ...verification });
+  }
+  /**
+   * Add a commit record
+   */
+  async addCommit(commit) {
+    await this.ensureLoaded();
+    const validation = validateCommitRecord(commit);
+    if (!validation.valid) {
+      throw new Error(`Invalid commit: ${validation.errors.join(", ")}`);
+    }
+    this.commits.set(commit.id, commit);
+    await this.appendToFile({ type: "commit", ...commit });
+  }
+  /**
+   * Add a reveal record
+   */
+  async addReveal(reveal) {
+    await this.ensureLoaded();
+    const validation = validateRevealRecord(reveal);
+    if (!validation.valid) {
+      throw new Error(`Invalid reveal: ${validation.errors.join(", ")}`);
+    }
+    this.reveals.set(reveal.id, reveal);
+    await this.appendToFile({ type: "reveal", ...reveal });
+  }
+  /**
+   * Get all verifications
+   */
+  async getVerifications() {
+    await this.ensureLoaded();
+    return Array.from(this.verifications.values());
+  }
+  /**
+   * Get verifications for a specific target
+   */
+  async getVerificationsByTarget(target) {
+    await this.ensureLoaded();
+    return Array.from(this.verifications.values()).filter((v) => v.target === target);
+  }
+  /**
+   * Get verifications by domain
+   */
+  async getVerificationsByDomain(domain) {
+    await this.ensureLoaded();
+    return Array.from(this.verifications.values()).filter((v) => v.domain === domain);
+  }
+  /**
+   * Get verifications for an agent (where they are the target of verification)
+   * This requires looking up the target message to find the agent
+   * For now, we'll return all verifications and let the caller filter
+   */
+  async getVerificationsByDomainForAgent(domain) {
+    return this.getVerificationsByDomain(domain);
+  }
+  /**
+   * Get all commits
+   */
+  async getCommits() {
+    await this.ensureLoaded();
+    return Array.from(this.commits.values());
+  }
+  /**
+   * Get commit by ID
+   */
+  async getCommit(id) {
+    await this.ensureLoaded();
+    return this.commits.get(id) || null;
+  }
+  /**
+   * Get commits by agent
+   */
+  async getCommitsByAgent(agent) {
+    await this.ensureLoaded();
+    return Array.from(this.commits.values()).filter((c) => c.agent === agent);
+  }
+  /**
+   * Get all reveals
+   */
+  async getReveals() {
+    await this.ensureLoaded();
+    return Array.from(this.reveals.values());
+  }
+  /**
+   * Get reveal by commitment ID
+   */
+  async getRevealByCommitment(commitmentId) {
+    await this.ensureLoaded();
+    return Array.from(this.reveals.values()).find((r) => r.commitmentId === commitmentId) || null;
+  }
+  /**
+   * Get reveals by agent
+   */
+  async getRevealsByAgent(agent) {
+    await this.ensureLoaded();
+    return Array.from(this.reveals.values()).filter((r) => r.agent === agent);
+  }
+};
+
+// src/reputation/verification.ts
+function createVerification(verifier, privateKey, target, domain, verdict, confidence, timestamp, evidence) {
+  if (confidence < 0 || confidence > 1) {
+    throw new Error("confidence must be between 0 and 1");
+  }
+  const payload = {
+    verifier,
+    target,
+    domain,
+    verdict,
+    confidence,
+    timestamp
+  };
+  if (evidence !== void 0) {
+    payload.evidence = evidence;
+  }
+  const envelope = createEnvelope("verification", verifier, privateKey, payload, timestamp);
+  const record = {
+    id: envelope.id,
+    verifier,
+    target,
+    domain,
+    verdict,
+    confidence,
+    timestamp,
+    signature: envelope.signature
+  };
+  if (evidence !== void 0) {
+    record.evidence = evidence;
+  }
+  return record;
+}
+function verifyVerificationSignature(record) {
+  const structureValidation = validateVerificationRecord(record);
+  if (!structureValidation.valid) {
+    return {
+      valid: false,
+      reason: `Invalid structure: ${structureValidation.errors.join(", ")}`
+    };
+  }
+  const payload = {
+    verifier: record.verifier,
+    target: record.target,
+    domain: record.domain,
+    verdict: record.verdict,
+    confidence: record.confidence,
+    timestamp: record.timestamp
+  };
+  if (record.evidence !== void 0) {
+    payload.evidence = record.evidence;
+  }
+  const envelope = {
+    id: record.id,
+    type: "verification",
+    sender: record.verifier,
+    timestamp: record.timestamp,
+    payload,
+    signature: record.signature
+  };
+  return verifyEnvelope(envelope);
+}
+
+// src/reputation/commit-reveal.ts
+import { createHash as createHash2 } from "crypto";
+function hashPrediction(prediction) {
+  return createHash2("sha256").update(prediction).digest("hex");
+}
+function createCommit(agent, privateKey, domain, prediction, timestamp, expiryMs) {
+  const commitment = hashPrediction(prediction);
+  const expiry = timestamp + expiryMs;
+  const payload = {
+    agent,
+    domain,
+    commitment,
+    timestamp,
+    expiry
+  };
+  const envelope = createEnvelope("commit", agent, privateKey, payload, timestamp);
+  return {
+    id: envelope.id,
+    agent,
+    domain,
+    commitment,
+    timestamp,
+    expiry,
+    signature: envelope.signature
+  };
+}
+function createReveal(agent, privateKey, commitmentId, prediction, outcome, timestamp, evidence) {
+  const payload = {
+    agent,
+    commitmentId,
+    prediction,
+    outcome,
+    timestamp
+  };
+  if (evidence !== void 0) {
+    payload.evidence = evidence;
+  }
+  const envelope = createEnvelope("reveal", agent, privateKey, payload, timestamp);
+  const record = {
+    id: envelope.id,
+    agent,
+    commitmentId,
+    prediction,
+    outcome,
+    timestamp,
+    signature: envelope.signature
+  };
+  if (evidence !== void 0) {
+    record.evidence = evidence;
+  }
+  return record;
+}
+function verifyReveal(commit, reveal) {
+  const commitValidation = validateCommitRecord(commit);
+  if (!commitValidation.valid) {
+    return { valid: false, reason: `Invalid commit: ${commitValidation.errors.join(", ")}` };
+  }
+  const revealValidation = validateRevealRecord(reveal);
+  if (!revealValidation.valid) {
+    return { valid: false, reason: `Invalid reveal: ${revealValidation.errors.join(", ")}` };
+  }
+  if (reveal.commitmentId !== commit.id) {
+    return { valid: false, reason: "Reveal does not reference this commit" };
+  }
+  if (reveal.agent !== commit.agent) {
+    return { valid: false, reason: "Reveal agent does not match commit agent" };
+  }
+  if (reveal.timestamp < commit.expiry) {
+    return { valid: false, reason: "Reveal timestamp is before commit expiry" };
+  }
+  const predictedHash = hashPrediction(reveal.prediction);
+  if (predictedHash !== commit.commitment) {
+    return { valid: false, reason: "Prediction hash does not match commitment" };
+  }
+  return { valid: true };
+}
+
+// src/reputation/scoring.ts
+function decay(deltaTimeMs, lambda = Math.log(2) / 70) {
+  const deltaDays = deltaTimeMs / (1e3 * 60 * 60 * 24);
+  return Math.exp(-lambda * deltaDays);
+}
+function verdictWeight(verdict) {
+  switch (verdict) {
+    case "correct":
+      return 1;
+    case "incorrect":
+      return -1;
+    case "disputed":
+      return 0;
+  }
+}
+function computeTrustScore(agent, domain, verifications, currentTime) {
+  const relevantVerifications = verifications.filter(
+    (v) => v.target === agent && v.domain === domain
+  );
+  if (relevantVerifications.length === 0) {
+    return {
+      agent,
+      domain,
+      score: 0,
+      verificationCount: 0,
+      lastVerified: 0,
+      topVerifiers: []
+    };
+  }
+  let totalWeight = 0;
+  const verifierWeights = /* @__PURE__ */ new Map();
+  for (const verification of relevantVerifications) {
+    const deltaTime = currentTime - verification.timestamp;
+    const decayFactor = decay(deltaTime);
+    const verdict = verdictWeight(verification.verdict);
+    const weight = verdict * verification.confidence * decayFactor;
+    totalWeight += weight;
+    const currentVerifierWeight = verifierWeights.get(verification.verifier) || 0;
+    verifierWeights.set(verification.verifier, currentVerifierWeight + Math.abs(weight));
+  }
+  const rawScore = totalWeight / Math.max(relevantVerifications.length, 1);
+  const normalizedScore = Math.max(0, Math.min(1, (rawScore + 1) / 2));
+  const lastVerified = Math.max(...relevantVerifications.map((v) => v.timestamp));
+  const topVerifiers = Array.from(verifierWeights.entries()).sort((a, b) => b[1] - a[1]).slice(0, 5).map(([verifier]) => verifier);
+  return {
+    agent,
+    domain,
+    score: normalizedScore,
+    verificationCount: relevantVerifications.length,
+    lastVerified,
+    topVerifiers
+  };
+}
+function computeTrustScores(agent, verifications, currentTime) {
+  const domains = new Set(
+    verifications.filter((v) => v.target === agent).map((v) => v.domain)
+  );
+  const scores = /* @__PURE__ */ new Map();
+  for (const domain of domains) {
+    const score = computeTrustScore(agent, domain, verifications, currentTime);
+    scores.set(domain, score);
+  }
+  return scores;
+}
+var computeAllTrustScores = computeTrustScores;
+
+export {
+  generateKeyPair,
+  signMessage,
+  verifySignature,
+  exportKeyPair,
+  importKeyPair,
+  loadPeerConfig,
+  savePeerConfig,
+  initPeerConfig,
+  canonicalize,
+  computeId,
+  createEnvelope,
+  verifyEnvelope,
+  sendToPeer,
+  decodeInboundEnvelope,
+  sendViaRelay,
+  MessageStore,
+  RelayServer,
+  RelayClient,
+  PeerDiscoveryService,
+  DEFAULT_BOOTSTRAP_RELAYS,
+  getDefaultBootstrapRelay,
+  parseBootstrapRelay,
+  shortKey,
+  resolveBroadcastName,
+  formatDisplayName,
+  validateVerificationRecord,
+  validateCommitRecord,
+  validateRevealRecord,
+  ReputationStore,
+  createVerification,
+  verifyVerificationSignature,
+  hashPrediction,
+  createCommit,
+  createReveal,
+  verifyReveal,
+  decay,
+  computeTrustScore,
+  computeTrustScores,
+  computeAllTrustScores
+};
+//# sourceMappingURL=chunk-JUOGKXFN.js.map