sx-peerjs-http-util 1.0.6 → 1.2.0

package/dist/index.esm.js

@@ -1,22 +1,38 @@
-// src/index.ts
+// src/PeerJsWrapper.ts
 import { Peer } from "peerjs";
-var VERSION = "1.0.6";
-console.log(`[sx-peerjs-http-util] v${VERSION}`);
-function generateUUID() {
-  return crypto.randomUUID();
-}
+
+// src/CallSession.ts
 var CallSessionImpl = class {
+  /** 对端的 Peer ID */
   peerId;
+  /** 是否包含视频 */
   hasVideo;
+  /** PeerJS MediaConnection 实例 */
   mediaConnection;
+  /** 本地媒体流（麦克风/摄像头） */
   localStream = null;
+  /** 远程媒体流（对方的音频/视频） */
   remoteStream = null;
+  /** 通话状态监听器集合 */
   stateListeners = /* @__PURE__ */ new Set();
+  /** 调试日志函数 */
   debugLogFn;
+  /** 清理回调（通话结束时调用） */
   onCleanup;
+  /** 当前通话状态 */
   _state = "connecting";
+  /** 是否已静音 */
   isMuted = false;
+  /** 视频是否开启 */
   isVideoEnabled = true;
+  /**
+   * 创建通话会话实例
+   * @param peerId 对端 Peer ID
+   * @param mediaConnection PeerJS MediaConnection 实例
+   * @param hasVideo 是否包含视频
+   * @param debugLog 调试日志函数
+   * @param onCleanup 通话结束时的清理回调
+   */
   constructor(peerId, mediaConnection, hasVideo, debugLog, onCleanup) {
     this.peerId = peerId;
     this.mediaConnection = mediaConnection;
@@ -24,28 +40,43 @@ var CallSessionImpl = class {
     this.debugLogFn = debugLog;
     this.onCleanup = onCleanup;
   }
+  /** 是否已连接 */
   get isConnected() {
     return this._state === "connected";
   }
+  /** 当前通话状态 */
   get state() {
     return this._state;
   }
+  /**
+   * 设置通话状态
+   * @param state 新的通话状态
+   * @param reason 状态变化原因（可选）
+   */
   setState(state, reason) {
     this._state = state;
     this.notifyStateChange(state, reason);
   }
+  /** 设置本地媒体流 */
   setLocalStream(stream) {
     this.localStream = stream;
   }
+  /** 设置远程媒体流 */
   setRemoteStream(stream) {
     this.remoteStream = stream;
   }
+  /** 获取本地媒体流 */
   getLocalStream() {
     return this.localStream;
   }
+  /** 获取远程媒体流 */
   getRemoteStream() {
     return this.remoteStream;
   }
+  /**
+   * 切换静音状态
+   * @returns 切换后的静音状态（true = 已静音）
+   */
   toggleMute() {
     if (!this.localStream) return this.isMuted;
     const audioTracks = this.localStream.getAudioTracks();
@@ -56,6 +87,10 @@ var CallSessionImpl = class {
     this.debugLogFn("CallSession", "toggleMute", this.isMuted);
     return this.isMuted;
   }
+  /**
+   * 切换视频开关（仅视频通话有效）
+   * @returns 切换后的视频状态（true = 视频开启）
+   */
   toggleVideo() {
     if (!this.hasVideo || !this.localStream) return this.isVideoEnabled;
     const videoTracks = this.localStream.getVideoTracks();
@@ -66,10 +101,15 @@ var CallSessionImpl = class {
     this.debugLogFn("CallSession", "toggleVideo", this.isVideoEnabled);
     return this.isVideoEnabled;
   }
+  /** 挂断通话 */
   hangUp() {
     this.debugLogFn("CallSession", "hangUp", this.peerId);
     this.mediaConnection.close();
   }
+  /**
+   * 关闭通话会话
+   * 停止本地流，清理资源
+   */
   close() {
     if (this.localStream) {
       this.localStream.getTracks().forEach((track) => track.stop());
@@ -78,12 +118,19 @@ var CallSessionImpl = class {
     this.remoteStream = null;
     this._state = "ended";
   }
+  /** 注册通话状态变化监听器 */
   onStateChange(listener) {
     this.stateListeners.add(listener);
   }
+  /** 移除通话状态变化监听器 */
   offStateChange(listener) {
     this.stateListeners.delete(listener);
   }
+  /**
+   * 通知状态变化
+   * @param state 新状态
+   * @param reason 变化原因（可选）
+   */
   notifyStateChange(state, reason) {
     this.debugLogFn("CallSession", "stateChange", { peer: this.peerId, state, reason });
     this.stateListeners.forEach((listener) => {
@@ -98,86 +145,916 @@ var CallSessionImpl = class {
     }
   }
 };
-var PeerJsWrapper = class {
+
+// src/constants.ts
+var CONNECTION_TIMEOUT_MS = 3e4;
+var SEND_TIMEOUT_MS = 1e4;
+var RECONNECT_DELAY_MS = 1e3;
+var ROUTE_EXPIRE_AGE_MS = 5 * 60 * 1e3;
+var MAX_DIRECT_NODES = 5;
+var ROUTE_CLEANUP_INTERVAL_MS = 60 * 1e3;
+var ROUTE_BROADCAST_INTERVAL_MS = 30 * 1e3;
+var DEFAULT_TTL = 128;
+
+// src/RoutingDB.ts
+var DB_NAME = "peerjs-routing-db";
+var DB_VERSION = 1;
+var ROUTING_TABLE_STORE = "routing-table";
+var DIRECT_NODES_STORE = "direct-nodes";
+var db = null;
+function withStore(storeName, mode, operation) {
+  return openDB().then((database) => {
+    return new Promise((resolve, reject) => {
+      const tx = database.transaction(storeName, mode);
+      const store = tx.objectStore(storeName);
+      const request = operation(store);
+      if (request) {
+        request.onerror = () => reject(request.error);
+        request.onsuccess = () => resolve(request.result);
+      } else {
+        tx.oncomplete = () => resolve(void 0);
+        tx.onerror = () => reject(tx.error);
+      }
+    });
+  });
+}
+function openDB() {
+  return new Promise((resolve, reject) => {
+    if (db) {
+      resolve(db);
+      return;
+    }
+    const request = indexedDB.open(DB_NAME, DB_VERSION);
+    request.onerror = () => reject(request.error);
+    request.onsuccess = () => {
+      db = request.result;
+      resolve(db);
+    };
+    request.onupgradeneeded = (e) => {
+      const req = e.target;
+      const database = req.result;
+      if (!database.objectStoreNames.contains(ROUTING_TABLE_STORE)) {
+        const routingStore = database.createObjectStore(ROUTING_TABLE_STORE, {
+          keyPath: "target"
+        });
+        routingStore.createIndex("timestamp", "timestamp", { unique: false });
+      }
+      if (!database.objectStoreNames.contains(DIRECT_NODES_STORE)) {
+        const nodesStore = database.createObjectStore(DIRECT_NODES_STORE, {
+          keyPath: "nodeId"
+        });
+        nodesStore.createIndex("timestamp", "timestamp", { unique: false });
+      }
+    };
+  });
+}
+async function initRoutingDB() {
+  await openDB();
+}
+async function saveRouteEntry(entry) {
+  await withStore(ROUTING_TABLE_STORE, "readwrite", (store) => store.put(entry));
+}
+async function saveRouteEntries(entries) {
+  await openDB().then((database) => {
+    return new Promise((resolve, reject) => {
+      const tx = database.transaction(ROUTING_TABLE_STORE, "readwrite");
+      const store = tx.objectStore(ROUTING_TABLE_STORE);
+      for (const entry of entries) {
+        store.put(entry);
+      }
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  });
+}
+async function deleteRouteEntry(target) {
+  await withStore(ROUTING_TABLE_STORE, "readwrite", (store) => store.delete(target));
+}
+async function loadRoutingTable() {
+  return withStore(ROUTING_TABLE_STORE, "readonly", (store) => store.getAll());
+}
+async function saveDirectNode(node) {
+  await withStore(DIRECT_NODES_STORE, "readwrite", (store) => store.put(node));
+}
+async function saveDirectNodes(nodes) {
+  await openDB().then((database) => {
+    return new Promise((resolve, reject) => {
+      const tx = database.transaction(DIRECT_NODES_STORE, "readwrite");
+      const store = tx.objectStore(DIRECT_NODES_STORE);
+      for (const node of nodes) {
+        store.put(node);
+      }
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  });
+}
+async function loadDirectNodes() {
+  return withStore(DIRECT_NODES_STORE, "readonly", (store) => store.getAll());
+}
+async function clearAllRoutingData() {
+  const database = await openDB();
+  await new Promise((resolve, reject) => {
+    const tx = database.transaction(ROUTING_TABLE_STORE, "readwrite");
+    const store = tx.objectStore(ROUTING_TABLE_STORE);
+    store.clear();
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+  });
+  await new Promise((resolve, reject) => {
+    const tx = database.transaction(DIRECT_NODES_STORE, "readwrite");
+    const store = tx.objectStore(DIRECT_NODES_STORE);
+    store.clear();
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+  });
+}
+
+// src/Router.ts
+var Router = class {
+  /** 路由表：target -> RouteEntry */
+  routingTable = /* @__PURE__ */ new Map();
+  /** 直连节点及延迟列表 */
+  directNodes = [];
+  /** 中继配置 */
+  relayConfig;
+  /** 回调函数集合 */
+  callbacks;
+  /** 等待路由发现响应的 pending 队列 */
+  pendingRouteQueries = /* @__PURE__ */ new Map();
+  /** 定时清理定时器 */
+  cleanupTimer = null;
+  /** 周期广播定时器 */
+  broadcastTimer = null;
   /**
-   * 本地 Peer ID，构造时确定（传入或自动生成）
+   * 创建路由管理器
+   * @param callbacks 回调函数集合
+   * @param relayConfig 中继配置（可选）
    */
-  myPeerId;
+  constructor(callbacks, relayConfig) {
+    this.callbacks = callbacks;
+    this.relayConfig = relayConfig ?? {};
+  }
   /**
-   * PeerJS 实例
+   * 初始化路由管理器（从 IndexedDB 加载数据并启动定时任务）
    */
-  peerInstance = null;
+  async init() {
+    await initRoutingDB();
+    await this.loadFromDB();
+    this.startMaintenanceTasks();
+  }
   /**
-   * 当前活跃的传入连接集合
+   * 从 IndexedDB 加载路由数据
    */
-  connections = /* @__PURE__ */ new Set();
+  async loadFromDB() {
+    try {
+      const routes = await loadRoutingTable();
+      for (const entry of routes) {
+        this.routingTable.set(entry.target, entry);
+      }
+      this.callbacks.debugLog("Routing", "loadedRoutes", routes.length);
+    } catch (e) {
+      this.callbacks.debugLog("Routing", "loadError", e);
+    }
+    try {
+      const nodes = await loadDirectNodes();
+      this.directNodes = nodes;
+      this.callbacks.debugLog("Routing", "loadedNodes", nodes.length);
+    } catch (e) {
+      this.callbacks.debugLog("Routing", "loadNodesError", e);
+    }
+  }
   /**
-   * 待处理的请求映射表（用于请求-响应匹配）
+   * 启动定时维护任务
    */
-  pendingRequests = /* @__PURE__ */ new Map();
+  startMaintenanceTasks() {
+    this.cleanupTimer = setInterval(() => {
+      this.cleanupExpiredEntries();
+    }, ROUTE_CLEANUP_INTERVAL_MS);
+    this.broadcastTimer = setInterval(() => {
+      this.broadcastRouteUpdate();
+    }, ROUTE_BROADCAST_INTERVAL_MS);
+  }
   /**
-   * 路径处理器映射表
+   * 清理过期路由条目
    */
-  simpleHandlers = /* @__PURE__ */ new Map();
+  async cleanupExpiredEntries() {
+    const now = Date.now();
+    for (const [target, entry] of this.routingTable) {
+      if (now - entry.timestamp > ROUTE_EXPIRE_AGE_MS) {
+        this.routingTable.delete(target);
+        deleteRouteEntry(target).catch(() => {
+        });
+      }
+    }
+    this.directNodes = this.directNodes.filter((node) => {
+      const isExpired = now - node.timestamp > ROUTE_EXPIRE_AGE_MS;
+      if (isExpired) {
+        return false;
+      }
+      return true;
+    });
+    this.callbacks.debugLog("Routing", "cleanup", {
+      routes: this.routingTable.size,
+      nodes: this.directNodes.length
+    });
+  }
   /**
-   * 重连定时器
+   * 持久化路由表到 IndexedDB
    */
-  reconnectTimer = null;
+  async persist() {
+    try {
+      const entries = Array.from(this.routingTable.values());
+      await saveRouteEntries(entries);
+    } catch (e) {
+      this.callbacks.debugLog("Routing", "persistError", e);
+    }
+    try {
+      await saveDirectNodes(this.directNodes);
+    } catch (e) {
+      this.callbacks.debugLog("Routing", "persistNodesError", e);
+    }
+  }
   /**
-   * 是否已销毁
+   * 销毁路由管理器（清理定时器）
    */
-  isDestroyed = false;
+  destroy() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+    if (this.broadcastTimer) {
+      clearInterval(this.broadcastTimer);
+      this.broadcastTimer = null;
+    }
+    this.pendingRouteQueries.forEach((pending) => {
+      clearTimeout(pending.timer);
+    });
+    this.pendingRouteQueries.clear();
+  }
   /**
-   * 是否开启调试模式
+   * 记录成功的直连通信
+   * @param nodeId 节点 ID
+   * @param latency 延迟（毫秒）
    */
-  isDebug;
+  recordDirectNode(nodeId, latency) {
+    const myPeerId = this.callbacks.getMyPeerId();
+    if (nodeId === myPeerId) return;
+    const existing = this.directNodes.find((n) => n.nodeId === nodeId);
+    const timestamp = Date.now();
+    if (existing) {
+      existing.latency = latency;
+      existing.timestamp = timestamp;
+    } else {
+      const maxRelayNodes = this.relayConfig.maxRelayNodes ?? MAX_DIRECT_NODES;
+      this.directNodes.push({ nodeId, latency, timestamp });
+      if (this.directNodes.length > maxRelayNodes) {
+        this.directNodes.sort((a, b) => a.latency - b.latency);
+        this.directNodes.shift();
+      }
+    }
+    this.callbacks.debugLog("Routing", "directNode", { nodeId, latency });
+  }
   /**
-   * 服务器配置
+   * 获取直连节点列表（按延迟升序）
+   * @returns 直连节点列表
    */
-  serverConfig;
+  getDirectNodes() {
+    return [...this.directNodes].sort((a, b) => a.latency - b.latency);
+  }
   /**
-   * 当前活跃的通话
+   * 检查是否可以直连目标节点
+   * @param targetId 目标节点 ID
+   * @returns 是否可以直连
    */
-  activeCall = null;
+  canReachDirectly(targetId) {
+    return this.directNodes.some((n) => n.nodeId === targetId);
+  }
+  /**
+   * 获取到直连节点的延迟
+   * @param nodeId 节点 ID
+   * @returns 延迟（毫秒），如果不存在返回 null
+   */
+  getDirectLatency(nodeId) {
+    const node = this.directNodes.find((n) => n.nodeId === nodeId);
+    return node ? node.latency : null;
+  }
+  /**
+   * 移除失效的路由（通信失败时调用）
+   * @param nodeId 失效的节点 ID
+   */
+  removeRoute(nodeId) {
+    let removed = false;
+    for (const [target, entry] of this.routingTable) {
+      const originalLength = entry.nextHops.length;
+      entry.nextHops = entry.nextHops.filter((h) => h.nodeId !== nodeId);
+      if (entry.nextHops.length === 0) {
+        this.routingTable.delete(target);
+        deleteRouteEntry(target).catch(() => {
+        });
+        removed = true;
+      } else if (entry.nextHops.length < originalLength) {
+        entry.timestamp = Date.now();
+        saveRouteEntry(entry).catch(() => {
+        });
+        removed = true;
+      }
+    }
+    const nodeIndex = this.directNodes.findIndex((n) => n.nodeId === nodeId);
+    if (nodeIndex !== -1) {
+      this.directNodes.splice(nodeIndex, 1);
+      removed = true;
+    }
+    if (removed) {
+      this.callbacks.debugLog("Routing", "routeRemoved", nodeId);
+    }
+  }
+  /**
+   * 检查路由表是否为空
+   * @returns 是否为空
+   */
+  isRoutingTableEmpty() {
+    return this.routingTable.size === 0;
+  }
+  /**
+   * 记录成功通信的节点（兼容旧接口）
+   * @param nodeId 节点 ID
+   */
+  recordSuccessfulNode(nodeId) {
+    const myPeerId = this.callbacks.getMyPeerId();
+    if (nodeId === myPeerId) return;
+    const existing = this.directNodes.find((n) => n.nodeId === nodeId);
+    if (!existing) {
+      const maxRelayNodes = this.relayConfig.maxRelayNodes ?? 5;
+      this.directNodes.push({ nodeId, latency: 100, timestamp: Date.now() });
+      if (this.directNodes.length > maxRelayNodes) {
+        this.directNodes.sort((a, b) => a.latency - b.latency);
+        this.directNodes.shift();
+      }
+    }
+  }
+  /**
+   * 广播路由更新
+   * 向所有直连节点发送路由更新消息，告知它们本节点可达的节点列表
+   */
+  async broadcastRouteUpdate() {
+    const myPeerId = this.callbacks.getMyPeerId();
+    const reachableNodes = this.getReachableNodes();
+    for (const node of this.directNodes) {
+      try {
+        await this.sendRouteUpdate(node.nodeId, reachableNodes);
+      } catch {
+      }
+    }
+  }
+  /**
+   * 获取本节点可达的节点列表
+   * @returns 可达节点数组（直连节点 + 自己）
+   */
+  getReachableNodes() {
+    const myPeerId = this.callbacks.getMyPeerId();
+    const directNodeIds = this.directNodes.map((n) => n.nodeId);
+    return [.../* @__PURE__ */ new Set([...directNodeIds, myPeerId])];
+  }
   /**
-   * 来电监听器集合
+   * 发送路由更新到指定节点
+   * @param targetId 目标节点 ID
+   * @param reachableNodes 可达的节点列表
    */
+  async sendRouteUpdate(targetId, reachableNodes) {
+    const myPeerId = this.callbacks.getMyPeerId();
+    const message = {
+      type: "route-update",
+      id: `${myPeerId}-route-${Date.now()}`,
+      originalTarget: targetId,
+      relayPath: [],
+      forwardPath: [],
+      ttl: DEFAULT_TTL,
+      routeUpdate: { reachableNodes }
+    };
+    await this.callbacks.sendRelayMessage(targetId, message);
+  }
+  /**
+   * 处理收到的路由更新
+   * 合并对端发来的可达节点信息到本地路由表
+   * @param fromPeerId 发送路由更新的节点 ID
+   * @param message 路由更新消息
+   */
+  handleRouteUpdate(fromPeerId, message) {
+    if (!message.routeUpdate) return;
+    const myPeerId = this.callbacks.getMyPeerId();
+    const { reachableNodes } = message.routeUpdate;
+    const timestamp = Date.now();
+    const viaLatency = this.getDirectLatency(fromPeerId) ?? 100;
+    for (const target of reachableNodes) {
+      if (target === myPeerId) continue;
+      let entry = this.routingTable.get(target);
+      const totalLatency = viaLatency + 100;
+      if (!entry) {
+        entry = {
+          target,
+          nextHops: [],
+          hops: 1,
+          timestamp
+        };
+        this.routingTable.set(target, entry);
+      }
+      const existingHop = entry.nextHops.find((h) => h.nodeId === fromPeerId);
+      if (existingHop) {
+        existingHop.latency = totalLatency;
+      } else {
+        entry.nextHops.push({ nodeId: fromPeerId, latency: totalLatency });
+      }
+      entry.nextHops.sort((a, b) => a.latency - b.latency);
+      entry.hops = Math.min(entry.hops, 1);
+      entry.timestamp = timestamp;
+      this.callbacks.debugLog("Routing", "update", { target, nextHop: fromPeerId, latency: totalLatency });
+    }
+  }
+  /**
+   * 执行路由发现广播
+   * 当直连和路由表都失败时，向所有直连节点广播询问谁能连通目标
+   * @param targetId 目标节点 ID
+   * @returns 路由条目（如果发现）
+   */
+  async discoverRoute(targetId) {
+    const myPeerId = this.callbacks.getMyPeerId();
+    const directNodes = this.getDirectNodes();
+    if (directNodes.length === 0) {
+      this.callbacks.debugLog("Routing", "discoverRoute", "no direct nodes");
+      return null;
+    }
+    this.callbacks.debugLog("Routing", "discoverRoute", { targetId, directNodes: directNodes.length });
+    const queryId = `${myPeerId}-query-${Date.now()}`;
+    const routeEntry = await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingRouteQueries.delete(queryId);
+        resolve(null);
+      }, CONNECTION_TIMEOUT_MS);
+      this.pendingRouteQueries.set(queryId, { resolve, reject, timer });
+      const message = {
+        type: "route-query",
+        id: queryId,
+        originalTarget: targetId,
+        relayPath: [myPeerId],
+        forwardPath: [],
+        ttl: DEFAULT_TTL,
+        routeQuery: {
+          queryOrigin: myPeerId,
+          targetNode: targetId,
+          queryPath: [myPeerId]
+        }
+      };
+      for (const node of directNodes) {
+        this.callbacks.sendRelayMessage(node.nodeId, message).catch(() => {
+        });
+      }
+    });
+    return routeEntry;
+  }
+  /**
+   * 处理路由查询消息
+   * @param fromPeerId 发送查询的节点
+   * @param message 路由查询消息
+   */
+  handleRouteQuery(fromPeerId, message) {
+    if (!message.routeQuery) return;
+    const myPeerId = this.callbacks.getMyPeerId();
+    const { queryOrigin, targetNode, queryPath } = message.routeQuery;
+    if (targetNode === myPeerId) {
+      const latency = this.getDirectLatency(fromPeerId) ?? 100;
+      const response = {
+        type: "route-response",
+        id: `${myPeerId}-resp-${Date.now()}`,
+        originalTarget: queryOrigin,
+        relayPath: [],
+        forwardPath: [],
+        ttl: DEFAULT_TTL,
+        routeResponse: {
+          queryOrigin,
+          responder: myPeerId,
+          targetNode,
+          latency
+        }
+      };
+      this.callbacks.sendRelayMessage(fromPeerId, response);
+      return;
+    }
+    if (queryPath.includes(myPeerId)) {
+      return;
+    }
+    const currentTTL = message.ttl ?? DEFAULT_TTL;
+    if (currentTTL <= 0) {
+      this.callbacks.debugLog("Routing", "ttlExpired", { type: "route-query", id: message.id });
+      return;
+    }
+    const nextHop = this.findNextHopToTarget(targetNode);
+    if (nextHop) {
+      const latency = (this.getDirectLatency(fromPeerId) ?? 100) + nextHop.latency;
+      const response = {
+        type: "route-response",
+        id: `${myPeerId}-resp-${Date.now()}`,
+        originalTarget: queryOrigin,
+        relayPath: [],
+        forwardPath: [],
+        ttl: DEFAULT_TTL,
+        routeResponse: {
+          queryOrigin,
+          responder: myPeerId,
+          targetNode,
+          latency
+        }
+      };
+      this.callbacks.sendRelayMessage(fromPeerId, response);
+      return;
+    }
+    const newPath = [...queryPath, myPeerId];
+    const forwardMessage = {
+      ...message,
+      relayPath: newPath,
+      ttl: currentTTL - 1,
+      routeQuery: {
+        ...message.routeQuery,
+        queryPath: newPath
+      }
+    };
+    for (const node of this.directNodes) {
+      if (node.nodeId !== fromPeerId) {
+        this.callbacks.sendRelayMessage(node.nodeId, forwardMessage).catch(() => {
+        });
+      }
+    }
+  }
+  /**
+   * 处理路由查询响应
+   * @param fromPeerId 响应者节点
+   * @param message 路由响应消息
+   */
+  handleRouteResponse(fromPeerId, message) {
+    if (!message.routeResponse) return;
+    const { queryOrigin, targetNode, latency } = message.routeResponse;
+    const myPeerId = this.callbacks.getMyPeerId();
+    if (queryOrigin !== myPeerId) return;
+    const pending = Array.from(this.pendingRouteQueries.values())[0];
+    if (!pending) return;
+    let entry = this.routingTable.get(targetNode);
+    const timestamp = Date.now();
+    if (!entry) {
+      entry = {
+        target: targetNode,
+        nextHops: [],
+        hops: 1,
+        timestamp
+      };
+      this.routingTable.set(targetNode, entry);
+    }
+    const existingHop = entry.nextHops.find((h) => h.nodeId === fromPeerId);
+    if (existingHop) {
+      existingHop.latency = latency;
+    } else {
+      entry.nextHops.push({ nodeId: fromPeerId, latency });
+    }
+    entry.nextHops.sort((a, b) => a.latency - b.latency);
+    entry.timestamp = timestamp;
+    this.callbacks.debugLog("Routing", "discovered", { targetNode, nextHop: fromPeerId, latency });
+    clearTimeout(pending.timer);
+    pending.resolve(entry);
+  }
+  /**
+   * 查找到目标节点的下一跳
+   * @param targetId 目标节点 ID
+   * @returns 下一跳信息，如果没有则返回 null
+   */
+  findNextHopToTarget(targetId) {
+    const entry = this.routingTable.get(targetId);
+    if (!entry || entry.nextHops.length === 0) return null;
+    return entry.nextHops[0];
+  }
+  /**
+   * 获取到目标节点的所有下一跳（按延迟升序）
+   * @param targetId 目标节点 ID
+   * @returns 下一跳列表
+   */
+  getNextHopsToTarget(targetId) {
+    const entry = this.routingTable.get(targetId);
+    return entry ? [...entry.nextHops] : [];
+  }
+  /**
+   * 获取路由表
+   * @returns 路由表对象
+   */
+  getRoutingTable() {
+    const result = {};
+    this.routingTable.forEach((entry, target) => {
+      result[target] = { ...entry, nextHops: [...entry.nextHops] };
+    });
+    return result;
+  }
+  /**
+   * 获取已知节点列表（兼容旧接口）
+   * @returns 节点 ID 数组
+   */
+  getKnownNodes() {
+    return this.directNodes.map((n) => n.nodeId);
+  }
+};
+
+// src/MessageHandler.ts
+var MessageHandler = class {
+  /** 回调函数集合 */
+  callbacks;
+  /**
+   * 创建消息处理器
+   * @param callbacks 回调函数集合
+   */
+  constructor(callbacks) {
+    this.callbacks = callbacks;
+  }
+  /**
+   * 处理收到的请求
+   * 根据是否有中继消息上下文判断是直连请求还是中继请求
+   * @param from 发送者 Peer ID
+   * @param request 请求数据
+   * @param relayMessage 中继消息上下文（可选，有则为中继请求）
+   * @returns 响应数据
+   */
+  async handleRequest(from, request, relayMessage) {
+    if (relayMessage) {
+      return this.handleRelayRequest(from, request, relayMessage);
+    }
+    return this.handleDirectRequest(from, request);
+  }
+  /**
+   * 处理直连请求
+   * @param from 发送者 Peer ID
+   * @param request 请求数据
+   * @returns 响应数据
+   */
+  async handleDirectRequest(from, request) {
+    const result = await this.processHandler(request.path, from, request.data);
+    if (this.isErrorResponse(result)) {
+      return result;
+    }
+    return { status: 200, data: result };
+  }
+  /**
+   * 处理中继请求
+   * @param from 发送者 Peer ID
+   * @param request 请求数据
+   * @param relayMessage 中继消息上下文
+   * @returns 响应数据
+   */
+  async handleRelayRequest(from, request, relayMessage) {
+    const myPeerId = this.callbacks.getMyPeerId();
+    const { originalTarget, relayPath, forwardPath } = relayMessage;
+    if (myPeerId === originalTarget) {
+      const result = await this.processHandler(request.path, from, request.data);
+      if (this.isErrorResponse(result)) {
+        return result;
+      }
+      return { status: 200, data: result };
+    }
+    const currentTTL = relayMessage.ttl ?? DEFAULT_TTL;
+    if (currentTTL <= 0) {
+      this.callbacks.debugLog("MessageHandler", "ttlExpired", { type: "relay-request", id: relayMessage.id });
+      return {
+        status: 502,
+        data: { error: "TTL expired - message dropped to prevent routing loop" }
+      };
+    }
+    if (forwardPath.length > 0) {
+      const nextHop = forwardPath[0];
+      const remainingPath = forwardPath.slice(1);
+      try {
+        const response = await this.forwardRelay(nextHop, {
+          type: "relay-request",
+          id: relayMessage.id,
+          originalTarget,
+          relayPath: [...relayPath, myPeerId],
+          forwardPath: remainingPath,
+          ttl: currentTTL - 1,
+          request
+        });
+        return response;
+      } catch (err) {
+        return {
+          status: 500,
+          data: { error: `Forward failed: ${err instanceof Error ? err.message : "Unknown error"}` }
+        };
+      }
+    }
+    try {
+      const data = await this.forwardToTarget(originalTarget, request, relayMessage);
+      return { status: 200, data };
+    } catch (err) {
+      return {
+        status: 500,
+        data: { error: `Forward to target failed: ${err instanceof Error ? err.message : "Unknown error"}` }
+      };
+    }
+  }
+  /**
+   * 调用注册的处理器
+   * @param path 请求路径
+   * @param from 发送者 Peer ID
+   * @param data 请求数据
+   * @returns 处理器返回的数据，或 404 错误
+   */
+  async processHandler(path, from, data) {
+    const handlers = this.callbacks.getSimpleHandlers();
+    const simpleHandler = handlers.get(path);
+    if (simpleHandler) {
+      return await simpleHandler(from, data);
+    }
+    return { status: 404, data: { error: `Path not found: ${path}` } };
+  }
+  /**
+   * 判断结果是否为错误响应
+   */
+  isErrorResponse(result) {
+    return typeof result === "object" && result !== null && "status" in result && "data" in result;
+  }
+  /**
+   * 创建连接并发送中继消息的通用方法
+   * @param targetId 目标节点 ID
+   * @param message 要发送的消息
+   * @param extractResponse 从响应消息中提取数据的函数
+   * @returns Promise<Response>
+   */
+  createConnectionAndSend(targetId, message, extractResponse) {
+    return new Promise((resolve, reject) => {
+      this.callbacks.debugLog("MessageHandler", "createConnectionAndSend", { targetId });
+      this.callbacks.waitForReady().then(() => {
+        const peerInstance = this.callbacks.getPeerInstance();
+        if (!peerInstance) {
+          reject(new Error("Peer instance not available"));
+          return;
+        }
+        const conn = peerInstance.connect(targetId, { reliable: true });
+        const timeout = setTimeout(() => {
+          conn.close();
+          reject(new Error(`Connection timeout: ${targetId}`));
+        }, CONNECTION_TIMEOUT_MS);
+        conn.on("open", () => {
+          this.callbacks.debugLog("Conn", "open", targetId);
+          conn.send(message);
+        });
+        conn.on("data", (responseData) => {
+          const response = responseData;
+          const extracted = extractResponse(response);
+          if (extracted) {
+            clearTimeout(timeout);
+            conn.close();
+            resolve(extracted);
+          }
+        });
+        conn.on("error", (err) => {
+          this.callbacks.debugLog("Conn", "error", { peer: targetId, error: err });
+          clearTimeout(timeout);
+          reject(err);
+        });
+        conn.on("close", () => {
+          this.callbacks.debugLog("Conn", "close", targetId);
+          clearTimeout(timeout);
+          reject(new Error("Connection closed"));
+        });
+      }).catch(reject);
+    });
+  }
+  /**
+   * 转发中继请求到下一个节点
+   * @param nextHop 下一跳节点 ID
+   * @param message 要转发的消息
+   * @returns 响应数据
+   */
+  async forwardRelay(nextHop, message) {
+    return this.createConnectionAndSend(
+      nextHop,
+      message,
+      (response) => {
+        if (response.type === "relay-response" && response.response) {
+          return response.response;
+        }
+        return null;
+      }
+    );
+  }
+  /**
+   * 转发到最终目标节点（当没有更多中继节点时使用）
+   * @param targetId 目标节点 ID
+   * @param request 请求数据
+   * @param originalMessage 原始中继消息
+   * @returns 响应数据
+   */
+  async forwardToTarget(targetId, request, originalMessage) {
+    const myPeerId = this.callbacks.getMyPeerId();
+    const currentTTL = originalMessage.ttl ?? DEFAULT_TTL;
+    const message = {
+      type: "relay-request",
+      id: originalMessage.id,
+      originalTarget: originalMessage.originalTarget,
+      relayPath: [...originalMessage.relayPath, myPeerId],
+      forwardPath: [],
+      ttl: currentTTL - 1,
+      request
+    };
+    const response = await this.createConnectionAndSend(
+      targetId,
+      message,
+      (resp) => {
+        if (resp.type === "relay-response" && resp.response) {
+          return resp.response;
+        }
+        return null;
+      }
+    );
+    return response.data;
+  }
+};
+
+// src/PeerJsWrapper.ts
+var VERSION = "1.2.0";
+console.log(`[sx-peerjs-http-util] v${VERSION}`);
+function generateUUID() {
+  return crypto.randomUUID();
+}
+var PeerJsWrapper = class _PeerJsWrapper {
+  /** 本地 Peer ID */
+  myPeerId;
+  /** PeerJS 实例 */
+  peerInstance = null;
+  /** 当前活跃的传入连接集合 */
+  connections = /* @__PURE__ */ new Set();
+  /** 待处理的请求映射表（用于请求-响应匹配） */
+  pendingRequests = /* @__PURE__ */ new Map();
+  /** 路径处理器映射表 */
+  simpleHandlers = /* @__PURE__ */ new Map();
+  /** 重连定时器 */
+  reconnectTimer = null;
+  /** 是否已销毁 */
+  isDestroyed = false;
+  /** 是否开启调试模式 */
+  isDebug;
+  /** 服务器配置 */
+  serverConfig;
+  /** 当前活跃的通话 */
+  activeCall = null;
+  /** 来电监听器集合 */
   incomingCallListeners = /* @__PURE__ */ new Set();
+  /** 路由管理器 */
+  router;
+  /** 消息处理器 */
+  messageHandler;
   /**
    * 创建 PeerJsWrapper 实例
    * @param peerId 可选的 Peer ID，如果不提供则自动生成 UUID
    * @param isDebug 是否开启调试模式，开启后会打印事件日志
    * @param server 可选的信令服务器配置，不提供则使用 PeerJS 公共服务器
+   * @param relayConfig 可选的中继配置
    */
-  constructor(peerId, isDebug, server) {
+  constructor(peerId, isDebug, server, relayConfig) {
     this.myPeerId = peerId || generateUUID();
     this.isDebug = isDebug ?? false;
     this.serverConfig = server;
+    const callbacks = {
+      getMyPeerId: () => this.myPeerId,
+      getPeerInstance: () => this.peerInstance,
+      debugLog: this.debugLog.bind(this),
+      sendRelayMessage: (targetId, message) => this.sendRelayMessage(targetId, message)
+    };
+    this.router = new Router(callbacks, relayConfig);
+    this.router.init();
+    this.messageHandler = new MessageHandler({
+      ...callbacks,
+      waitForReady: () => this.waitForReady(),
+      getSimpleHandlers: () => this.simpleHandlers,
+      onRouteUpdate: (fromPeerId, message) => this.router.handleRouteUpdate(fromPeerId, message)
+    });
     this.connect();
   }
   /**
-   * 调试日志输出
-   * @param obj 对象名
-   * @param event 事件名
-   * @param data 事件数据
+   * 创建实例并等待就绪（语法糖）
+   * @param peerId 可选的 Peer ID
+   * @param isDebug 是否开启调试模式
+   * @param server 可选的信令服务器配置
+   * @param relayConfig 可选的中继配置
+   * @returns Promise<PeerJsWrapper>
    */
+  static async create(peerId, isDebug, server, relayConfig) {
+    const wrapper = new _PeerJsWrapper(peerId, isDebug, server, relayConfig);
+    await wrapper.whenReady();
+    return wrapper;
+  }
   debugLog(obj, event, data) {
     if (this.isDebug) {
-      const dataStr = data !== void 0 ? typeof data === "object" ? JSON.stringify(data) : String(data) : "";
-      console.log(`${obj} ${event} ${dataStr}`);
+      console.log(obj, event, data);
     }
   }
-  /**
-   * 连接到 PeerJS 服务器
-   */
   connect() {
     if (this.isDestroyed) return;
     this.peerInstance = this.serverConfig ? new Peer(this.myPeerId, { ...this.serverConfig }) : new Peer(this.myPeerId);
     this.setupPeerEventHandlers();
   }
-  /**
-   * 设置 Peer 实例的事件处理器
-   */
   setupPeerEventHandlers() {
     if (!this.peerInstance) return;
     this.peerInstance.on("open", (id) => {
@@ -205,20 +1082,14 @@ var PeerJsWrapper = class {
     });
     this.setupIncomingConnectionHandler();
   }
-  /**
-   * 安排重连
-   */
   scheduleReconnect() {
     if (this.isDestroyed) return;
     if (this.reconnectTimer) return;
     this.reconnectTimer = setTimeout(() => {
       this.reconnectTimer = null;
       this.reconnect();
-    }, 1e3);
+    }, RECONNECT_DELAY_MS);
   }
-  /**
-   * 执行重连
-   */
   reconnect() {
     if (this.isDestroyed) return;
     this.debugLog("PeerJsWrapper", "reconnect");
@@ -231,23 +1102,12 @@ var PeerJsWrapper = class {
     }
     this.connect();
   }
-  /**
-   * 获取当前 Peer ID
-   * @returns string 当前 Peer ID
-   */
   getPeerId() {
     return this.myPeerId;
   }
-  /**
-   * 等待 Peer 连接就绪（连接到信令服务器）
-   * @returns Promise<void> 当连接成功时 resolve
-   */
   whenReady() {
     return this.waitForReady();
   }
-  /**
-   * 等待 Peer 连接就绪
-   */
   waitForReady() {
     return new Promise((resolve, reject) => {
       if (!this.peerInstance) {
@@ -272,87 +1132,363 @@ var PeerJsWrapper = class {
       this.peerInstance.on("error", onError);
     });
   }
+  getRoutingTable() {
+    return this.router.getRoutingTable();
+  }
+  getKnownNodes() {
+    return this.router.getKnownNodes();
+  }
   /**
-   * 发送请求到指定 Peer
-   * @param peerId 对端设备 ID
+   * 发送中继消息的辅助方法
+   * @param targetId 目标节点 ID
+   * @param message 中继消息
+   */
+  sendRelayMessage(targetId, message) {
+    return new Promise((resolve, reject) => {
+      if (!this.peerInstance) {
+        reject(new Error("Peer instance not available"));
+        return;
+      }
+      const conn = this.peerInstance.connect(targetId, { reliable: true });
+      const timeout = setTimeout(() => {
+        conn.close();
+        reject(new Error(`Send to ${targetId} timeout`));
+      }, SEND_TIMEOUT_MS);
+      conn.on("open", () => {
+        conn.send(message);
+        clearTimeout(timeout);
+        conn.close();
+        resolve();
+      });
+      conn.on("error", () => {
+        clearTimeout(timeout);
+        reject(new Error(`Send to ${targetId} failed`));
+      });
+      conn.on("close", () => {
+        clearTimeout(timeout);
+        resolve();
+      });
+    });
+  }
+  /**
+   * 尝试直连目标节点
+   * @param targetId 目标节点 ID
    * @param path 请求路径
    * @param data 请求数据
-   * @returns Promise<unknown> 返回响应数据（自动拆箱，只返回 data 部分）
+   * @param requestId 请求 ID
+   * @returns Promise<unknown> - 响应数据
    */
-  send(peerId, path, data) {
+  tryDirectConnect(targetId, path, data, requestId) {
     return new Promise((resolve, reject) => {
-      this.debugLog("PeerJsWrapper", "send", { peerId, path, data });
+      if (!this.peerInstance) {
+        reject(new Error("Peer instance not available"));
+        return;
+      }
+      const startTime = Date.now();
+      const conn = this.peerInstance.connect(targetId, { reliable: true });
+      let resolved = false;
+      const timeout = setTimeout(() => {
+        if (!resolved) {
+          resolved = true;
+          conn.close();
+          reject(new Error(`Request timeout: ${targetId}${path}`));
+        }
+      }, CONNECTION_TIMEOUT_MS);
+      conn.on("open", () => {
+        const latency = Date.now() - startTime;
+        this.debugLog("Conn", "open", { peer: targetId, latency });
+        const request = { path, data };
+        const message = {
+          type: "request",
+          id: requestId,
+          request
+        };
+        conn.send(message);
+      });
+      conn.on("data", (responseData) => {
+        this.debugLog("Conn", "data", { peer: targetId, data: responseData });
+        const message = responseData;
+        if (message.type === "response" && message.id === requestId) {
+          if (!resolved) {
+            resolved = true;
+            clearTimeout(timeout);
+            const response = message.response;
+            if (response.status < 200 || response.status >= 300) {
+              conn.close();
+              reject(new Error(`Request failed: ${response.status} ${JSON.stringify(response.data)}`));
+            } else {
+              const latency = Date.now() - startTime;
+              this.router.recordDirectNode(targetId, latency);
+              this.router.broadcastRouteUpdate();
+              resolve(response.data);
+            }
+          }
+        }
+      });
+      conn.on("error", (err) => {
+        if (!resolved) {
+          resolved = true;
+          clearTimeout(timeout);
+          this.debugLog("Conn", "error", { peer: targetId, error: err });
+          reject(err);
+        }
+      });
+      conn.on("close", () => {
+        if (!resolved) {
+          resolved = true;
+          clearTimeout(timeout);
+          this.debugLog("Conn", "close", targetId);
+          reject(new Error("Connection closed"));
+        }
+      });
+    });
+  }
+  /**
+   * 通过中继节点转发请求
+   * @param nextHopId 下一跳节点 ID
+   * @param targetId 原始目标节点 ID
+   * @param path 请求路径
+   * @param data 请求数据
+   * @returns Promise<unknown> - 响应数据
+   */
+  relayVia(nextHopId, targetId, path, data) {
+    return new Promise((resolve, reject) => {
+      this.debugLog("PeerJsWrapper", "relayVia", { targetId, nextHop: nextHopId });
       this.waitForReady().then(() => {
         if (!this.peerInstance) {
           reject(new Error("Peer instance not available"));
           return;
         }
-        const conn = this.peerInstance.connect(peerId, {
-          reliable: true
-        });
+        const conn = this.peerInstance.connect(nextHopId, { reliable: true });
+        const startTime = Date.now();
         const timeout = setTimeout(() => {
           conn.close();
-          this.pendingRequests.delete(requestId);
-          reject(new Error(`Request timeout: ${peerId}${path}`));
-        }, 3e4);
-        const requestId = `${this.myPeerId}-${Date.now()}-${Math.random()}`;
-        this.pendingRequests.set(requestId, { resolve, reject, timeout });
+          reject(new Error(`Relay timeout: ${nextHopId}${path}`));
+        }, CONNECTION_TIMEOUT_MS);
         conn.on("open", () => {
-          this.debugLog("Conn", "open", peerId);
+          this.debugLog("Conn", "open", nextHopId);
           const request = { path, data };
           const message = {
-            type: "request",
-            id: requestId,
+            type: "relay-request",
+            id: `${this.myPeerId}-${Date.now()}-${Math.random()}`,
+            originalTarget: targetId,
+            relayPath: [this.myPeerId],
+            forwardPath: [],
+            ttl: DEFAULT_TTL,
             request
           };
           conn.send(message);
         });
         conn.on("data", (responseData) => {
-          this.debugLog("Conn", "data", { peer: peerId, data: responseData });
           const message = responseData;
-          if (message.type === "response" && message.id === requestId) {
-            const pending = this.pendingRequests.get(requestId);
-            if (pending) {
-              clearTimeout(pending.timeout);
-              this.pendingRequests.delete(requestId);
-              const response = message.response;
+          if (message.type === "relay-response") {
+            clearTimeout(timeout);
+            conn.close();
+            const response = message.response;
+            if (response) {
               if (response.status < 200 || response.status >= 300) {
-                pending.reject(
-                  new Error(`Request failed: ${response.status} ${JSON.stringify(response.data)}`)
-                );
+                reject(new Error(`Relay failed: ${response.status} ${JSON.stringify(response.data)}`));
               } else {
-                pending.resolve(response.data);
+                const latency = Date.now() - startTime;
+                this.router.recordDirectNode(nextHopId, latency);
+                this.router.broadcastRouteUpdate();
+                resolve(response.data);
               }
             }
-            conn.close();
+          } else if (message.type === "route-update") {
+            this.router.handleRouteUpdate(nextHopId, message);
+          } else if (message.type === "route-query") {
+            this.router.handleRouteQuery(nextHopId, message);
+          } else if (message.type === "route-response") {
+            this.router.handleRouteResponse(nextHopId, message);
           }
         });
         conn.on("error", (err) => {
-          this.debugLog("Conn", "error", { peer: peerId, error: err });
-          const pending = this.pendingRequests.get(requestId);
-          if (pending) {
-            clearTimeout(pending.timeout);
-            this.pendingRequests.delete(requestId);
-            pending.reject(err);
-          }
+          this.debugLog("Conn", "error", { peer: nextHopId, error: err });
+          clearTimeout(timeout);
+          reject(err);
         });
         conn.on("close", () => {
-          this.debugLog("Conn", "close", peerId);
-          const pending = this.pendingRequests.get(requestId);
-          if (pending) {
-            clearTimeout(pending.timeout);
-            this.pendingRequests.delete(requestId);
-            pending.reject(new Error("Connection closed"));
-          }
+          this.debugLog("Conn", "close", nextHopId);
+          clearTimeout(timeout);
+          reject(new Error("Relay connection closed"));
         });
-      }).catch((err) => {
-        reject(err);
-      });
+      }).catch(reject);
+    });
+  }
+  /**
+   * 自动路由发送
+   * 
+   * 1. 查路由表 → 有路由 → 尝试中继 → 全部失败 → 降级直连 → 失败 → 结束
+   * 2. 路由表无目标 → 直连 → 失败 → 结束
+   * @param peerId 目标节点 ID
+   * @param path 请求路径
+   * @param data 请求数据
+   * @returns Promise<unknown> - 响应数据
+   */
+  send(peerId, path, data) {
+    const requestId = `${this.myPeerId}-${Date.now()}-${Math.random()}`;
+    return new Promise((resolve, reject) => {
+      this.debugLog("PeerJsWrapper", "send", { peerId, path, data });
+      const nextHops = this.router.getNextHopsToTarget(peerId);
+      if (nextHops.length > 0) {
+        this.tryRelayChain(peerId, path, data, nextHops, 0).then(resolve).catch((relayErr) => {
+          this.debugLog("PeerJsWrapper", "relayFailed", { peerId, error: relayErr.message });
+          this.fallbackToDirect(peerId, path, data, requestId).then(resolve).catch(reject);
+        });
+      } else {
+        this.tryDirectConnect(peerId, path, data, requestId).then(resolve).catch((directErr) => {
+          this.debugLog("PeerJsWrapper", "directFailed", { peerId, error: directErr.message });
+          this.handleSendError(peerId, directErr).then(resolve).catch(reject);
+        });
+      }
+    });
+  }
+  /**
+   * 处理发送错误
+   * @param peerId 目标节点 ID
+   * @param error 错误对象
+   * @returns Promise
+   */
+  async handleSendError(peerId, error) {
+    const errorMsg = error.message;
+    const isHttpError = errorMsg.includes("Request failed:") || errorMsg.includes("404") || errorMsg.includes("500");
+    const isConnectionError = errorMsg.includes("timeout") || errorMsg.includes("Connection closed") || errorMsg.includes("Peer instance not available");
+    if (isHttpError) {
+      throw error;
+    }
+    if (!isConnectionError) {
+      throw error;
+    }
+    this.router.removeRoute(peerId);
+    this.debugLog("PeerJsWrapper", "routeRemoved", peerId);
+    if (!this.router.isRoutingTableEmpty()) {
+      return this.performRouteDiscovery(peerId, "", void 0, "");
+    }
+    throw new Error(`Cannot reach ${peerId}: no route found and routing table is empty`);
+  }
+  /**
+   * 降级到直连尝试
+   * @param peerId 目标节点 ID
+   * @param path 请求路径
+   * @param data 请求数据
+   * @param requestId 请求 ID
+   * @returns Promise
+   */
+  async fallbackToDirect(peerId, path, data, requestId) {
+    this.debugLog("PeerJsWrapper", "fallbackToDirect", peerId);
+    return this.tryDirectConnect(peerId, path, data, requestId).catch((directErr) => {
+      this.debugLog("PeerJsWrapper", "directFailed", { peerId, error: directErr.message });
+      this.handleSendError(peerId, directErr);
     });
   }
   /**
-   * 设置传入连接处理器
+   * 尝试通过中继链转发
+   * @param targetId 目标节点 ID
+   * @param path 请求路径
+   * @param data 请求数据
+   * @param nextHops 下一跳列表
+   * @param index 当前尝试的下一跳索引
+   * @returns Promise<unknown>
    */
+  tryRelayChain(targetId, path, data, nextHops, index) {
+    if (index >= nextHops.length) {
+      return Promise.reject(new Error("All relay nodes failed"));
+    }
+    const nextHop = nextHops[index];
+    this.debugLog("PeerJsWrapper", "tryRelay", { targetId, nextHop: nextHop.nodeId, latency: nextHop.latency });
+    return this.relayVia(nextHop.nodeId, targetId, path, data).catch(() => {
+      return this.tryRelayChain(targetId, path, data, nextHops, index + 1);
+    });
+  }
+  /**
+   * 执行路由发现
+   * @param targetId 目标节点 ID
+   * @param path 请求路径
+   * @param data 请求数据
+   * @param requestId 请求 ID
+   * @returns Promise<unknown>
+   */
+  async performRouteDiscovery(targetId, path, data, requestId) {
+    this.debugLog("PeerJsWrapper", "routeDiscovery", { targetId });
+    const routeEntry = await this.router.discoverRoute(targetId);
+    if (!routeEntry || routeEntry.nextHops.length === 0) {
+      throw new Error(`Cannot reach ${targetId}: no route found`);
+    }
+    this.debugLog("PeerJsWrapper", "routeFound", { targetId, nextHops: routeEntry.nextHops });
+    return this.tryRelayChain(targetId, path, data, routeEntry.nextHops, 0);
+  }
+  /**
+   * 中继发送（内部方法，不对外暴露）
+   * @param targetId 目标节点 ID
+   * @param path 请求路径
+   * @param data 请求数据
+   * @param relayNodes 手动指定的中继节点（可选，不指定则自动路由）
+   * @returns Promise<unknown>
+   */
+  relaySend(targetId, path, data, relayNodes) {
+    if (!relayNodes || relayNodes.length === 0) {
+      return this.send(targetId, path, data);
+    }
+    const [firstRelay, ...remainingRelays] = relayNodes;
+    return new Promise((resolve, reject) => {
+      this.debugLog("PeerJsWrapper", "relaySend", { targetId, firstRelay, remainingRelays });
+      this.waitForReady().then(() => {
+        if (!this.peerInstance) {
+          reject(new Error("Peer instance not available"));
+          return;
+        }
+        const conn = this.peerInstance.connect(firstRelay, { reliable: true });
+        const timeout = setTimeout(() => {
+          conn.close();
+          reject(new Error(`Relay timeout: ${firstRelay}${path}`));
+        }, CONNECTION_TIMEOUT_MS);
+        conn.on("open", () => {
+          this.debugLog("Conn", "open", firstRelay);
+          const request = { path, data };
+          const message = {
+            type: "relay-request",
+            id: `${this.myPeerId}-${Date.now()}-${Math.random()}`,
+            originalTarget: targetId,
+            relayPath: [],
+            forwardPath: remainingRelays,
+            ttl: DEFAULT_TTL,
+            request
+          };
+          conn.send(message);
+        });
+        conn.on("data", (responseData) => {
+          const message = responseData;
+          if (message.type === "relay-response") {
+            clearTimeout(timeout);
+            conn.close();
+            const response = message.response;
+            if (response) {
+              if (response.status < 200 || response.status >= 300) {
+                reject(new Error(`Relay failed: ${response.status} ${JSON.stringify(response.data)}`));
+              } else {
+                this.router.recordSuccessfulNode(firstRelay);
+                this.router.broadcastRouteUpdate();
+                resolve(response.data);
+              }
+            }
+          } else if (message.type === "route-update") {
+            this.router.handleRouteUpdate(firstRelay, message);
+          }
+        });
+        conn.on("error", (err) => {
+          this.debugLog("Conn", "error", { peer: firstRelay, error: err });
+          clearTimeout(timeout);
+          reject(err);
+        });
+        conn.on("close", () => {
+          this.debugLog("Conn", "close", firstRelay);
+          clearTimeout(timeout);
+          reject(new Error("Relay connection closed"));
+        });
+      }).catch(reject);
+    });
+  }
   setupIncomingConnectionHandler() {
     if (!this.peerInstance) return;
     this.peerInstance.on("connection", (conn) => {
@@ -364,26 +1500,60 @@ var PeerJsWrapper = class {
       conn.on("data", async (data) => {
         this.debugLog("Conn", "data", { peer: conn.peer, data });
         const message = data;
-        if (message.type === "request" && message.request) {
-          try {
-            const response = await this.handleRequest(conn.peer, message.request);
-            const responseMessage = {
-              type: "response",
-              id: message.id,
-              response
-            };
-            conn.send(responseMessage);
-          } catch (error) {
-            const errorResponse = {
-              type: "response",
-              id: message.id,
-              response: {
-                status: 500,
-                data: { error: error instanceof Error ? error.message : "Unknown error" }
-              }
-            };
-            conn.send(errorResponse);
+        if (message.type === "request") {
+          const internalMsg = message;
+          if (internalMsg.request) {
+            try {
+              const response = await this.messageHandler.handleRequest(conn.peer, internalMsg.request);
+              const responseMessage = {
+                type: "response",
+                id: internalMsg.id,
+                response
+              };
+              conn.send(responseMessage);
+            } catch (error) {
+              const errorResponse = {
+                type: "response",
+                id: internalMsg.id,
+                response: {
+                  status: 500,
+                  data: { error: error instanceof Error ? error.message : "Unknown error" }
+                }
+              };
+              conn.send(errorResponse);
+            }
           }
+        } else if (message.type === "relay-request") {
+          const relayMsg = message;
+          if (relayMsg.request) {
+            try {
+              const response = await this.messageHandler.handleRequest(conn.peer, relayMsg.request, relayMsg);
+              const responseMessage = {
+                type: "relay-response",
+                id: relayMsg.id,
+                originalTarget: relayMsg.originalTarget,
+                relayPath: relayMsg.relayPath,
+                forwardPath: [],
+                response
+              };
+              conn.send(responseMessage);
+            } catch (error) {
+              const errorResponse = {
+                type: "relay-response",
+                id: relayMsg.id,
+                originalTarget: relayMsg.originalTarget,
+                relayPath: relayMsg.relayPath,
+                forwardPath: [],
+                response: {
+                  status: 500,
+                  data: { error: error instanceof Error ? error.message : "Unknown error" }
+                }
+              };
+              conn.send(errorResponse);
+            }
+          }
+        } else if (message.type === "route-update") {
+          this.router.handleRouteUpdate(conn.peer, message);
         }
       });
       conn.on("close", () => {
@@ -396,13 +1566,6 @@ var PeerJsWrapper = class {
       });
     });
   }
-  // ============== 语音/视频通话相关方法 ==============
-  /**
-   * 发起语音/视频通话
-   * @param peerId 对端设备 ID
-   * @param options 通话选项
-   * @returns Promise<CallSession> 通话会话对象
-   */
   call(peerId, options) {
     return new Promise((resolve, reject) => {
       this.debugLog("PeerJsWrapper", "call", { peerId, options });
@@ -467,30 +1630,15 @@ var PeerJsWrapper = class {
       }).catch(reject);
     });
   }
-  /**
-   * 注册来电监听器
-   * @param listener 来电回调函数
-   */
   onIncomingCall(listener) {
     this.incomingCallListeners.add(listener);
   }
-  /**
-   * 移除来电监听器
-   * @param listener 来电回调函数
-   */
   offIncomingCall(listener) {
     this.incomingCallListeners.delete(listener);
   }
-  /**
-   * 获取当前活跃的通话
-   * @returns CallSession | null 当前通话会话，无通话时返回 null
-   */
   getActiveCall() {
     return this.activeCall;
   }
-  /**
-   * 设置 MediaConnection 事件处理器
-   */
   setupMediaConnectionHandlers(session, mediaConnection) {
     mediaConnection.on("stream", (remoteStream) => {
       this.debugLog("MediaConnection", "stream", { peer: mediaConnection.peer });
@@ -508,17 +1656,11 @@ var PeerJsWrapper = class {
       session.setState("ended", err.message || "Media error");
     });
   }
-  /**
-   * 清理通话资源
-   */
   cleanupCall(session) {
     if (this.activeCall === session) {
       this.activeCall = null;
     }
   }
-  /**
-   * 处理来电
-   */
   handleIncomingCall(mediaConnection) {
     this.debugLog("Peer", "call", { from: mediaConnection.peer, metadata: mediaConnection.metadata });
     const metadata = mediaConnection.metadata;
@@ -568,40 +1710,12 @@ var PeerJsWrapper = class {
       }
     });
   }
-  /**
-   * 注册简化处理器（直接返回数据，自动装箱）
-   * @param path 请求路径
-   * @param handler 处理器函数，接收请求数据，直接返回响应数据
-   */
   registerHandler(path, handler) {
     this.simpleHandlers.set(path, handler);
   }
-  /**
-   * 注销简化处理器
-   * @param path 请求路径
-   */
   unregisterHandler(path) {
     this.simpleHandlers.delete(path);
   }
-  /**
-   * 内部请求处理方法
-   * @param from 发送者的 Peer ID
-   * @param request 请求数据
-   */
-  async handleRequest(from, request) {
-    const simpleHandler = this.simpleHandlers.get(request.path);
-    if (simpleHandler) {
-      const data = await simpleHandler(from, request.data);
-      return { status: 200, data };
-    }
-    return {
-      status: 404,
-      data: { error: `Path not found: ${request.path}` }
-    };
-  }
-  /**
-   * 关闭所有连接并销毁 Peer 实例
-   */
   destroy() {
     this.isDestroyed = true;
     if (this.reconnectTimer) {
@@ -627,10 +1741,23 @@ var PeerJsWrapper = class {
       this.peerInstance.destroy();
       this.peerInstance = null;
     }
+    if (this.router) {
+      this.router.persist();
+      this.router.destroy();
+    }
   }
 };
 export {
   PeerJsWrapper,
-  VERSION
+  VERSION,
+  clearAllRoutingData,
+  deleteRouteEntry,
+  initRoutingDB,
+  loadDirectNodes,
+  loadRoutingTable,
+  saveDirectNode,
+  saveDirectNodes,
+  saveRouteEntries,
+  saveRouteEntry
 };
 //# sourceMappingURL=index.esm.js.map