sx-peerjs-http-util 1.1.0 → 1.2.0

package/dist/index.esm.js

@@ -146,16 +146,146 @@ var CallSessionImpl = class {
   }
 };
 
-// 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 回调函数集合
@@ -166,76 +296,243 @@ var RoutingManager = class {
     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);
   }
   /**
    * 处理收到的路由更新
@@ -248,39 +545,217 @@ var RoutingManager = class {
     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);
   }
 };
 
@@ -339,6 +814,14 @@ var MessageHandler = class {
       }
       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);
@@ -349,6 +832,7 @@ var MessageHandler = class {
           originalTarget,
           relayPath: [...relayPath, myPeerId],
           forwardPath: remainingPath,
+          ttl: currentTTL - 1,
           request
         });
         return response;
@@ -391,54 +875,70 @@ var MessageHandler = class {
     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
@@ -448,65 +948,37 @@ var MessageHandler = class {
    */
   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 实例 */
@@ -530,7 +1002,7 @@ var PeerJsWrapper = class {
   /** 来电监听器集合 */
   incomingCallListeners = /* @__PURE__ */ new Set();
   /** 路由管理器 */
-  routingManager;
+  router;
   /** 消息处理器 */
   messageHandler;
   /**
@@ -547,17 +1019,32 @@ var PeerJsWrapper = class {
     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);
@@ -601,7 +1088,7 @@ var PeerJsWrapper = class {
     this.reconnectTimer = setTimeout(() => {
       this.reconnectTimer = null;
       this.reconnect();
-    }, 1e3);
+    }, RECONNECT_DELAY_MS);
   }
   reconnect() {
     if (this.isDestroyed) return;
@@ -645,32 +1132,149 @@ var PeerJsWrapper = class {
       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);
@@ -685,102 +1289,204 @@ var PeerJsWrapper = class {
               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() {
@@ -847,7 +1553,7 @@ var PeerJsWrapper = class {
             }
           }
         } else if (message.type === "route-update") {
-          this.routingManager.handleRouteUpdate(conn.peer, message);
+          this.router.handleRouteUpdate(conn.peer, message);
         }
       });
       conn.on("close", () => {
@@ -1035,10 +1741,23 @@ var PeerJsWrapper = class {
       this.peerInstance.destroy();
       this.peerInstance = null;
     }
+    if (this.router) {
+      this.router.persist();
+      this.router.destroy();
+    }
   }
 };
 export {
   PeerJsWrapper,
-  VERSION
+  VERSION,
+  clearAllRoutingData,
+  deleteRouteEntry,
+  initRoutingDB,
+  loadDirectNodes,
+  loadRoutingTable,
+  saveDirectNode,
+  saveDirectNodes,
+  saveRouteEntries,
+  saveRouteEntry
 };
 //# sourceMappingURL=index.esm.js.map