sx-peerjs-http-util 1.1.0 → 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
@@ -4798,16 +4807,146 @@ var PeerJsHttpUtil = (() => {
     }
   };
 
-  // src/Routing.ts
-  var RoutingManager = 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();
-    /** 已知的成功通信节点列表 */
-    knownNodes = [];
+    /** 直连节点及延迟列表 */
+    directNodes = [];
     /** 中继配置 */
     relayConfig;
     /** 回调函数集合 */
     callbacks;
+    /** 等待路由发现响应的 pending 队列 */
+    pendingRouteQueries = /* @__PURE__ */ new Map();
+    /** 定时清理定时器 */
+    cleanupTimer = null;
+    /** 周期广播定时器 */
+    broadcastTimer = null;
     /**
      * 创建路由管理器
      * @param callbacks 回调函数集合
@@ -4818,76 +4957,243 @@ var PeerJsHttpUtil = (() => {
       this.relayConfig = relayConfig ?? {};
     }
     /**
-     * 记录成功的通信节点
-     * 将成功通信的节点添加到已知节点列表
+     * 初始化路由管理器（从 IndexedDB 加载数据并启动定时任务）
+     */
+    async init() {
+      await initRoutingDB();
+      await this.loadFromDB();
+      this.startMaintenanceTasks();
+    }
+    /**
+     * 从 IndexedDB 加载路由数据
+     */
+    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);
+      }
+    }
+    /**
+     * 启动定时维护任务
+     */
+    startMaintenanceTasks() {
+      this.cleanupTimer = setInterval(() => {
+        this.cleanupExpiredEntries();
+      }, ROUTE_CLEANUP_INTERVAL_MS);
+      this.broadcastTimer = setInterval(() => {
+        this.broadcastRouteUpdate();
+      }, ROUTE_BROADCAST_INTERVAL_MS);
+    }
+    /**
+     * 清理过期路由条目
+     */
+    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
+     */
+    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);
+      }
+    }
+    /**
+     * 销毁路由管理器（清理定时器）
+     */
+    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 延迟（毫秒）
+     */
+    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 直连节点列表
+     */
+    getDirectNodes() {
+      return [...this.directNodes].sort((a, b) => a.latency - b.latency);
+    }
+    /**
+     * 检查是否可以直连目标节点
+     * @param targetId 目标节点 ID
+     * @returns 是否可以直连
+     */
+    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;
-      if (!this.knownNodes.includes(nodeId)) {
+      const existing = this.directNodes.find((n) => n.nodeId === nodeId);
+      if (!existing) {
         const maxRelayNodes = this.relayConfig.maxRelayNodes ?? 5;
-        this.knownNodes.push(nodeId);
-        if (this.knownNodes.length > maxRelayNodes) {
-          this.knownNodes.shift();
+        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();
         }
-        this.callbacks.debugLog("Routing", "newNode", nodeId);
       }
     }
     /**
      * 广播路由更新
-     * 向所有已知节点发送路由更新消息，告知它们本节点可达的节点列表
+     * 向所有直连节点发送路由更新消息，告知它们本节点可达的节点列表
      */
     async broadcastRouteUpdate() {
       const myPeerId = this.callbacks.getMyPeerId();
-      const reachableNodes = [...this.knownNodes, myPeerId];
-      for (const nodeId of this.knownNodes) {
+      const reachableNodes = this.getReachableNodes();
+      for (const node of this.directNodes) {
         try {
-          await this.sendRouteUpdate(nodeId, reachableNodes);
+          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 peerInstance = this.callbacks.getPeerInstance();
       const myPeerId = this.callbacks.getMyPeerId();
-      if (!peerInstance) {
-        throw new Error("Peer instance not available");
-      }
-      return new Promise((resolve, reject) => {
-        const conn = peerInstance.connect(targetId, { reliable: true });
-        const timeout = setTimeout(() => {
-          conn.close();
-          reject(new Error("Route update timeout"));
-        }, 5e3);
-        conn.on("open", () => {
-          const message = {
-            type: "route-update",
-            id: `${myPeerId}-route-${Date.now()}`,
-            originalTarget: targetId,
-            relayPath: [],
-            forwardPath: [],
-            routeUpdate: { reachableNodes }
-          };
-          conn.send(message);
-          clearTimeout(timeout);
-          conn.close();
-          resolve();
-        });
-        conn.on("error", () => {
-          clearTimeout(timeout);
-          reject(new Error("Route update failed"));
-        });
-        conn.on("close", () => {
-          clearTimeout(timeout);
-          resolve();
-        });
-      });
+      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);
     }
     /**
      * 处理收到的路由更新
@@ -4900,39 +5206,217 @@ var PeerJsHttpUtil = (() => {
       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;
-        const existing = this.routingTable.get(target);
-        const hops = 1 + (fromPeerId === myPeerId ? 0 : 1);
-        if (!existing || hops < existing.hops || timestamp > existing.timestamp) {
-          this.routingTable.set(target, {
+        let entry = this.routingTable.get(target);
+        const totalLatency = viaLatency + 100;
+        if (!entry) {
+          entry = {
             target,
-            nextHop: fromPeerId,
-            hops,
-            via: fromPeerId,
+            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(() => {
           });
-          this.callbacks.debugLog("Routing", "update", { target, nextHop: fromPeerId, hops });
         }
       }
     }
     /**
-     * 获取路由表（用于调试和显示）
+     * 处理路由查询响应
+     * @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;
+        result[target] = { ...entry, nextHops: [...entry.nextHops] };
       });
       return result;
     }
     /**
-     * 获取已知节点列表
-     * @returns 已知节点 ID 数组
+     * 获取已知节点列表（兼容旧接口）
+     * @returns 节点 ID 数组
      */
     getKnownNodes() {
-      return [...this.knownNodes];
+      return this.directNodes.map((n) => n.nodeId);
     }
   };
 
@@ -4991,6 +5475,14 @@ var PeerJsHttpUtil = (() => {
         }
         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);
@@ -5001,6 +5493,7 @@ var PeerJsHttpUtil = (() => {
             originalTarget,
             relayPath: [...relayPath, myPeerId],
             forwardPath: remainingPath,
+            ttl: currentTTL - 1,
             request
           });
           return response;
@@ -5043,54 +5536,70 @@ var PeerJsHttpUtil = (() => {
       return typeof result === "object" && result !== null && "status" in result && "data" in result;
     }
     /**
-     * 转发中继请求到下一个节点
-     * @param nextHop 下一跳节点 ID
-     * @param message 要转发的消息
-     * @returns 响应数据
+     * 创建连接并发送中继消息的通用方法
+     * @param targetId 目标节点 ID
+     * @param message 要发送的消息
+     * @param extractResponse 从响应消息中提取数据的函数
+     * @returns Promise<Response>
      */
-    async forwardRelay(nextHop, message) {
+    createConnectionAndSend(targetId, message, extractResponse) {
       return new Promise((resolve, reject) => {
-        this.callbacks.debugLog("MessageHandler", "forwardRelay", { nextHop });
+        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(nextHop, { reliable: true });
+          const conn = peerInstance.connect(targetId, { reliable: true });
           const timeout = setTimeout(() => {
             conn.close();
-            reject(new Error(`Forward timeout: ${nextHop}`));
-          }, 3e4);
+            reject(new Error(`Connection timeout: ${targetId}`));
+          }, CONNECTION_TIMEOUT_MS);
           conn.on("open", () => {
-            this.callbacks.debugLog("Conn", "open", nextHop);
+            this.callbacks.debugLog("Conn", "open", targetId);
             conn.send(message);
           });
           conn.on("data", (responseData) => {
             const response = responseData;
-            if (response.type === "relay-response") {
+            const extracted = extractResponse(response);
+            if (extracted) {
               clearTimeout(timeout);
               conn.close();
-              if (response.response) {
-                resolve(response.response);
-              } else {
-                reject(new Error("Invalid relay response"));
-              }
+              resolve(extracted);
             }
           });
           conn.on("error", (err) => {
-            this.callbacks.debugLog("Conn", "error", { peer: nextHop, error: err });
+            this.callbacks.debugLog("Conn", "error", { peer: targetId, error: err });
             clearTimeout(timeout);
             reject(err);
           });
           conn.on("close", () => {
-            this.callbacks.debugLog("Conn", "close", nextHop);
+            this.callbacks.debugLog("Conn", "close", targetId);
             clearTimeout(timeout);
-            reject(new Error("Forward connection closed"));
+            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
@@ -5100,65 +5609,37 @@ var PeerJsHttpUtil = (() => {
      */
     async forwardToTarget(targetId, request, originalMessage) {
       const myPeerId = this.callbacks.getMyPeerId();
-      return new Promise((resolve, reject) => {
-        this.callbacks.debugLog("MessageHandler", "forwardToTarget", { targetId });
-        this.callbacks.waitForReady().then(() => {
-          const peerInstance = this.callbacks.getPeerInstance();
-          if (!peerInstance) {
-            reject(new Error("Peer instance not available"));
-            return;
+      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;
           }
-          const conn = peerInstance.connect(targetId, { reliable: true });
-          const timeout = setTimeout(() => {
-            conn.close();
-            reject(new Error(`Forward to target timeout: ${targetId}`));
-          }, 3e4);
-          conn.on("open", () => {
-            this.callbacks.debugLog("Conn", "open", targetId);
-            const message = {
-              type: "relay-request",
-              id: originalMessage.id,
-              originalTarget: originalMessage.originalTarget,
-              relayPath: [...originalMessage.relayPath, myPeerId],
-              forwardPath: [],
-              request
-            };
-            conn.send(message);
-          });
-          conn.on("data", (responseData) => {
-            const response = responseData;
-            if (response.type === "relay-response") {
-              clearTimeout(timeout);
-              conn.close();
-              if (response.response) {
-                resolve(response.response.data);
-              } else {
-                reject(new Error("Invalid relay response"));
-              }
-            }
-          });
-          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("Forward connection closed"));
-          });
-        }).catch(reject);
-      });
+          return null;
+        }
+      );
+      return response.data;
     }
   };
 
   // src/PeerJsWrapper.ts
-  var VERSION = "1.1.0";
+  var VERSION = "1.2.0";
   console.log(`[sx-peerjs-http-util] v${VERSION}`);
   function generateUUID() {
     return crypto.randomUUID();
   }
-  var PeerJsWrapper = class {
+  var PeerJsWrapper = class _PeerJsWrapper {
     /** 本地 Peer ID */
     myPeerId;
     /** PeerJS 实例 */
@@ -5182,7 +5663,7 @@ var PeerJsHttpUtil = (() => {
     /** 来电监听器集合 */
     incomingCallListeners = /* @__PURE__ */ new Set();
     /** 路由管理器 */
-    routingManager;
+    router;
     /** 消息处理器 */
     messageHandler;
     /**
@@ -5199,17 +5680,32 @@ var PeerJsHttpUtil = (() => {
       const callbacks = {
         getMyPeerId: () => this.myPeerId,
         getPeerInstance: () => this.peerInstance,
-        debugLog: this.debugLog.bind(this)
+        debugLog: this.debugLog.bind(this),
+        sendRelayMessage: (targetId, message) => this.sendRelayMessage(targetId, message)
       };
-      this.routingManager = new RoutingManager(callbacks, relayConfig);
+      this.router = new Router(callbacks, relayConfig);
+      this.router.init();
       this.messageHandler = new MessageHandler({
         ...callbacks,
         waitForReady: () => this.waitForReady(),
         getSimpleHandlers: () => this.simpleHandlers,
-        onRouteUpdate: (fromPeerId, message) => this.routingManager.handleRouteUpdate(fromPeerId, message)
+        onRouteUpdate: (fromPeerId, message) => this.router.handleRouteUpdate(fromPeerId, message)
       });
       this.connect();
     }
+    /**
+     * 创建实例并等待就绪（语法糖）
+     * @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) {
         console.log(obj, event, data);
@@ -5253,7 +5749,7 @@ var PeerJsHttpUtil = (() => {
       this.reconnectTimer = setTimeout(() => {
         this.reconnectTimer = null;
         this.reconnect();
-      }, 1e3);
+      }, RECONNECT_DELAY_MS);
     }
     reconnect() {
       if (this.isDestroyed) return;
@@ -5297,32 +5793,149 @@ var PeerJsHttpUtil = (() => {
         this.peerInstance.on("error", onError);
       });
     }
-    relaySend(targetId, path, data, relayNodes) {
-      if (relayNodes.length === 0) {
-        return this.send(targetId, path, data);
-      }
-      const [firstRelay, ...remainingRelays] = relayNodes;
+    getRoutingTable() {
+      return this.router.getRoutingTable();
+    }
+    getKnownNodes() {
+      return this.router.getKnownNodes();
+    }
+    /**
+     * 发送中继消息的辅助方法
+     * @param targetId 目标节点 ID
+     * @param message 中继消息
+     */
+    sendRelayMessage(targetId, message) {
       return new Promise((resolve, reject) => {
-        this.debugLog("PeerJsWrapper", "relaySend", { targetId, firstRelay, remainingRelays });
+        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 请求数据
+     * @param requestId 请求 ID
+     * @returns Promise<unknown> - 响应数据
+     */
+    tryDirectConnect(targetId, path, data, requestId) {
+      return new Promise((resolve, reject) => {
+        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(firstRelay, { reliable: true });
+          const conn = this.peerInstance.connect(nextHopId, { reliable: true });
+          const startTime = Date.now();
           const timeout = setTimeout(() => {
             conn.close();
-            reject(new Error(`Relay timeout: ${firstRelay}${path}`));
-          }, 3e4);
+            reject(new Error(`Relay timeout: ${nextHopId}${path}`));
+          }, CONNECTION_TIMEOUT_MS);
           conn.on("open", () => {
-            this.debugLog("Conn", "open", firstRelay);
+            this.debugLog("Conn", "open", nextHopId);
             const request = { path, data };
             const message = {
               type: "relay-request",
               id: `${this.myPeerId}-${Date.now()}-${Math.random()}`,
               originalTarget: targetId,
-              relayPath: [],
-              forwardPath: remainingRelays,
+              relayPath: [this.myPeerId],
+              forwardPath: [],
+              ttl: DEFAULT_TTL,
               request
             };
             conn.send(message);
@@ -5337,102 +5950,204 @@ var PeerJsHttpUtil = (() => {
                 if (response.status < 200 || response.status >= 300) {
                   reject(new Error(`Relay failed: ${response.status} ${JSON.stringify(response.data)}`));
                 } else {
-                  this.routingManager.recordSuccessfulNode(firstRelay);
-                  this.routingManager.broadcastRouteUpdate();
+                  const latency = Date.now() - startTime;
+                  this.router.recordDirectNode(nextHopId, latency);
+                  this.router.broadcastRouteUpdate();
                   resolve(response.data);
                 }
               }
             } else if (message.type === "route-update") {
-              this.routingManager.handleRouteUpdate(firstRelay, message);
+              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: firstRelay, error: err });
+            this.debugLog("Conn", "error", { peer: nextHopId, error: err });
             clearTimeout(timeout);
             reject(err);
           });
           conn.on("close", () => {
-            this.debugLog("Conn", "close", firstRelay);
+            this.debugLog("Conn", "close", nextHopId);
             clearTimeout(timeout);
             reject(new Error("Relay connection closed"));
           });
         }).catch(reject);
       });
     }
-    getRoutingTable() {
-      return this.routingManager.getRoutingTable();
-    }
-    getKnownNodes() {
-      return this.routingManager.getKnownNodes();
-    }
+    /**
+     * 自动路由发送
+     * 
+     * 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(peerId, { reliable: true });
+          const conn = this.peerInstance.connect(firstRelay, { reliable: true });
           const timeout = setTimeout(() => {
             conn.close();
-            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: ${firstRelay}${path}`));
+          }, CONNECTION_TIMEOUT_MS);
           conn.on("open", () => {
-            this.debugLog("Conn", "open", peerId);
+            this.debugLog("Conn", "open", firstRelay);
             const request = { path, data };
             const message = {
-              type: "request",
-              id: requestId,
+              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) => {
-            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 {
-                  this.routingManager.recordSuccessfulNode(peerId);
-                  this.routingManager.broadcastRouteUpdate();
-                  pending.resolve(response.data);
+                  this.router.recordSuccessfulNode(firstRelay);
+                  this.router.broadcastRouteUpdate();
+                  resolve(response.data);
                 }
               }
-              conn.close();
+            } else if (message.type === "route-update") {
+              this.router.handleRouteUpdate(firstRelay, 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: firstRelay, 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", firstRelay);
+            clearTimeout(timeout);
+            reject(new Error("Relay connection closed"));
           });
-        }).catch((err) => {
-          reject(err);
-        });
+        }).catch(reject);
       });
     }
     setupIncomingConnectionHandler() {
@@ -5499,7 +6214,7 @@ var PeerJsHttpUtil = (() => {
               }
             }
           } else if (message.type === "route-update") {
-            this.routingManager.handleRouteUpdate(conn.peer, message);
+            this.router.handleRouteUpdate(conn.peer, message);
           }
         });
         conn.on("close", () => {
@@ -5687,6 +6402,10 @@ var PeerJsHttpUtil = (() => {
         this.peerInstance.destroy();
         this.peerInstance = null;
       }
+      if (this.router) {
+        this.router.persist();
+        this.router.destroy();
+      }
     }
   };
   return __toCommonJS(index_exports);