sx-peerjs-http-util 1.0.6 → 1.2.0

package/dist/index.umd.js

@@ -647,7 +647,16 @@ var PeerJsHttpUtil = (() => {
   var index_exports = {};
   __export(index_exports, {
     PeerJsWrapper: () => PeerJsWrapper,
-    VERSION: () => VERSION
+    VERSION: () => VERSION,
+    clearAllRoutingData: () => clearAllRoutingData,
+    deleteRouteEntry: () => deleteRouteEntry,
+    initRoutingDB: () => initRoutingDB,
+    loadDirectNodes: () => loadDirectNodes,
+    loadRoutingTable: () => loadRoutingTable,
+    saveDirectNode: () => saveDirectNode,
+    saveDirectNodes: () => saveDirectNodes,
+    saveRouteEntries: () => saveRouteEntries,
+    saveRouteEntry: () => saveRouteEntry
   });
 
   // node_modules/peerjs-js-binarypack/dist/binarypack.mjs
@@ -4653,24 +4662,38 @@ var PeerJsHttpUtil = (() => {
     }
   };
 
-  // src/index.ts
-  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;
@@ -4678,28 +4701,43 @@ var PeerJsHttpUtil = (() => {
       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();
@@ -4710,6 +4748,10 @@ var PeerJsHttpUtil = (() => {
       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();
@@ -4720,10 +4762,15 @@ var PeerJsHttpUtil = (() => {
       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());
@@ -4732,12 +4779,19 @@ var PeerJsHttpUtil = (() => {
       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) => {
@@ -4752,86 +4806,916 @@ var PeerJsHttpUtil = (() => {
       }
     }
   };
-  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 $416260bce337df90$export$ecd1fc136c422448(this.myPeerId, { ...this.serverConfig }) : new $416260bce337df90$export$ecd1fc136c422448(this.myPeerId);
       this.setupPeerEventHandlers();
     }
-    /**
-     * 设置 Peer 实例的事件处理器
-     */
     setupPeerEventHandlers() {
       if (!this.peerInstance) return;
       this.peerInstance.on("open", (id) => {
@@ -4859,20 +5743,14 @@ var PeerJsHttpUtil = (() => {
       });
       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");
@@ -4885,23 +5763,12 @@ var PeerJsHttpUtil = (() => {
       }
       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) {
@@ -4926,87 +5793,363 @@ var PeerJsHttpUtil = (() => {
         this.peerInstance.on("error", onError);
       });
     }
+    getRoutingTable() {
+      return this.router.getRoutingTable();
+    }
+    getKnownNodes() {
+      return this.router.getKnownNodes();
+    }
+    /**
+     * 发送中继消息的辅助方法
+     * @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();
+        });
+      });
+    }
     /**
-     * 发送请求到指定 Peer
-     * @param peerId 对端设备 ID
+     * 尝试直连目标节点
+     * @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) => {
@@ -5018,26 +6161,60 @@ var PeerJsHttpUtil = (() => {
         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", () => {
@@ -5050,13 +6227,6 @@ var PeerJsHttpUtil = (() => {
         });
       });
     }
-    // ============== 语音/视频通话相关方法 ==============
-    /**
-     * 发起语音/视频通话
-     * @param peerId 对端设备 ID
-     * @param options 通话选项
-     * @returns Promise<CallSession> 通话会话对象
-     */
     call(peerId, options) {
       return new Promise((resolve, reject) => {
         this.debugLog("PeerJsWrapper", "call", { peerId, options });
@@ -5121,30 +6291,15 @@ var PeerJsHttpUtil = (() => {
         }).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 });
@@ -5162,17 +6317,11 @@ var PeerJsHttpUtil = (() => {
         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;
@@ -5222,40 +6371,12 @@ var PeerJsHttpUtil = (() => {
         }
       });
     }
-    /**
-     * 注册简化处理器（直接返回数据，自动装箱）
-     * @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) {
@@ -5281,6 +6402,10 @@ var PeerJsHttpUtil = (() => {
         this.peerInstance.destroy();
         this.peerInstance = null;
       }
+      if (this.router) {
+        this.router.persist();
+        this.router.destroy();
+      }
     }
   };
   return __toCommonJS(index_exports);