egos-transfer 0.2.14 → 0.2.16

package/dist/connection-manager.d.ts

@@ -4,8 +4,6 @@ export interface ConnectionManagerDeps {
     getPeer: () => Peer | undefined;
     peerId: string;
     ping: (peerId: string) => Promise<boolean>;
-    /** 连接关闭时回调，由 PeerTransfer 处理未完成的请求结算 */
-    onConnClosed: (conn: DataConnection) => void;
 }
 /**
  * DataConnection 连接池管理器
@@ -30,13 +28,9 @@ export declare class ConnectionManager {
      * @param conn - 已打开的 DataConnection
      * @param onData - 数据事件回调（由 PeerTransfer 提供，路由消息）
      */
-    setup(conn: DataConnection & {
-        timestamp?: number;
-    }, onData: (message: any) => void): DataConnection;
+    setup(conn: DataConnection, onData: (message: any) => void): DataConnection;
     remove(peerId: string, connectionId?: string): void;
-    isValid(conn?: DataConnection & {
-        timestamp?: number;
-    }): boolean;
+    isValid(conn?: DataConnection): boolean;
     private handleConnClosed;
     startHealthCheck(): void;
     stopHealthCheck(): void;

package/dist/connection-manager.js

@@ -13,6 +13,8 @@ exports.ConnectionManager = void 0;
 const HEALTH_CHECK_INTERVAL = 15000;
 /** 连接最大存活时间：超过 15 分钟的连接在 get 时自动丢弃，强制重建 */
 const MAX_CONNECTION_AGE = 15 * 60 * 1000;
+/** 建立中连接的最大等待时间：仍未 open 视为僵死 pending，由健康检查清理 */
+const PENDING_CONNECTION_TIMEOUT = 30000;
 /**
  * DataConnection 连接池管理器
  * - 管理 DataConnection 的生命周期（注册/移除/有效性检查）
@@ -33,6 +35,11 @@ class ConnectionManager {
         if (!conn) {
             return;
         }
+        // 建立中（未 open）：等待其完成，不当场移除——remove 会主动 close，
+        // 相当于掐死一次进行中的 WebRTC 握手
+        if (!conn.open) {
+            return;
+        }
         if (this.isValid(conn)) {
             return conn;
         }
@@ -62,7 +69,14 @@ class ConnectionManager {
      * @param onData - 数据事件回调（由 PeerTransfer 提供，路由消息）
      */
     setup(conn, onData) {
-        conn.timestamp = Date.now();
+        var _a, _b, _c;
+        const cur = this.get(conn.peer);
+        if (this.isValid(cur)) {
+            return cur;
+        }
+        // 复用 metadata.time 作为连接时间戳（发起方 connect 时已写入），
+        // 入站连接未携带时补上，供 isValid 的过期判定与 pending 清理使用
+        conn.metadata = Object.assign(Object.assign({}, ((_a = conn.metadata) !== null && _a !== void 0 ? _a : {})), { time: (_c = (_b = conn.metadata) === null || _b === void 0 ? void 0 : _b.time) !== null && _c !== void 0 ? _c : Date.now() });
         this.pool.set(conn.peer, conn);
         conn.on('data', onData);
         conn.on('close', () => this.handleConnClosed(conn));
@@ -76,53 +90,45 @@ class ConnectionManager {
                 }
             };
             pc.addEventListener('connectionstatechange', onStateChange);
-            // 将清理函数挂到 conn 上，remove 时一并移除
-            conn.__cm_stateChangeCleanup = () => {
-                pc.removeEventListener('connectionstatechange', onStateChange);
-            };
         }
         return conn;
     }
     remove(peerId, connectionId) {
-        var _a, _b, _c, _d, _e;
         const conn = this.pool.get(peerId);
         if (conn) {
             if (connectionId && conn.connectionId !== connectionId)
                 return;
             this.pool.delete(peerId);
             // 先 close 触发 close 事件（handleConnClosed 会结算 in-flight 请求），
-            // 再清理监听器与 PeerJS 内部引用，避免僵尸连接堆积导致无法建立新连接
             conn.close();
-            (_b = (_a = conn).__cm_stateChangeCleanup) === null || _b === void 0 ? void 0 : _b.call(_a);
-            conn.removeAllListeners();
-            (_c = this.deps.getPeer()) === null || _c === void 0 ? void 0 : _c._removeConnection(conn);
-        }
-        else {
-            // 清理 Peer 内部残留的 connection 引用
-            const connections = ((_d = this.deps.getPeer()) === null || _d === void 0 ? void 0 : _d.connections) || {};
-            for (const c of connections[peerId] || []) {
-                c.removeAllListeners();
-                c.close();
-                (_e = this.deps.getPeer()) === null || _e === void 0 ? void 0 : _e._removeConnection(c);
-            }
+            // 再清理监听器与 PeerJS 内部引用，避免僵尸连接堆积导致无法建立新连接
+            // (conn as any).__cm_stateChangeCleanup?.();
+            // conn.removeAllListeners();
+            // this.deps.getPeer()?._removeConnection(conn);
         }
     }
     isValid(conn) {
+        var _a;
         if (!(conn === null || conn === void 0 ? void 0 : conn.open) || !(conn === null || conn === void 0 ? void 0 : conn.peerConnection)) {
             return false;
         }
         // 检查连接是否过期
-        if (conn.timestamp && Date.now() - conn.timestamp > MAX_CONNECTION_AGE) {
+        const createdAt = (_a = conn.metadata) === null || _a === void 0 ? void 0 : _a.time;
+        if (createdAt && Date.now() - createdAt > MAX_CONNECTION_AGE) {
             return false;
         }
-        return ['connected', 'completed'].includes(conn.peerConnection.connectionState);
+        // DC open 即可收发。RTCPeerConnection.connectionState 的迁移可能滞后于
+        // DC open（新连接常仍为 connecting），若据此判无效会在 get() 中把健康连接
+        // remove 掉，导致 ping 失败、连接被误杀。PC 终态（failed/closed）由
+        // connectionstatechange 监听负责清理，无需在此重复判定
+        return true;
     }
     handleConnClosed(conn) {
-        var _a;
-        this.pool.delete(conn.peer);
-        // 同步移除 PeerJS 内部引用，避免僵尸连接堆积
-        (_a = this.deps.getPeer()) === null || _a === void 0 ? void 0 : _a._removeConnection(conn);
-        this.deps.onConnClosed(conn);
+        // 仅当池中登记的仍是该连接时才删除：连接被新连接替换后，
+        // 旧连接迟到的 close/error 不得清掉新连接的池项
+        if (this.pool.get(conn.peer) === conn) {
+            this.pool.delete(conn.peer);
+        }
     }
     // ── Health check ─────────────────────────────────────────────────
     startHealthCheck() {
@@ -141,14 +147,25 @@ class ConnectionManager {
     }
     checkAllConnections() {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             const peers = this.getAllPeers();
             for (const peerId of peers) {
                 const conn = this.pool.get(peerId);
                 if (!conn)
                     continue;
+                // 建立中（未 open）：setup 在 DC open 前就入池，健康检查若此刻判定会误杀刚建立的连接；
+                // 留出宽限期，仅清理超过 PENDING_CONNECTION_TIMEOUT 仍未 open 的僵死 pending
+                if (!conn.open) {
+                    const createdAt = (_a = conn.metadata) === null || _a === void 0 ? void 0 : _a.time;
+                    if (createdAt && Date.now() - createdAt > PENDING_CONNECTION_TIMEOUT) {
+                        this.remove(peerId, conn.connectionId);
+                    }
+                    continue;
+                }
                 const alive = yield this.pingConnection(conn);
                 if (!alive) {
-                    this.remove(peerId);
+                    // 带上 connectionId：await ping 期间该 peerId 可能已被新连接替换，避免误关新连接
+                    this.remove(peerId, conn.connectionId);
                 }
             }
         });

package/dist/constant.d.ts

@@ -1,7 +1,7 @@
 export declare const REQUEST_TIMEOUT = 18000;
 export declare const HEARTBEAT_INTERVAL = 12000;
 export declare const TRANSFER_TIMEOUT = 300000;
-export declare const PING_TIMEOUT = 5000;
+export declare const PING_TIMEOUT = 15000;
 export declare const CONNECTION_TIMEOUT = 6000;
 export declare const LOCKER_TIMEOUT = 15000;
 export declare const RECONNECT_TIMEOUT = 5000;

package/dist/constant.js

@@ -4,7 +4,7 @@ exports.UNAUTHORIZED = exports.CONNECTION_DUPLICATED = exports.CONNECTION_LIMIT_
 exports.REQUEST_TIMEOUT = 18000;
 exports.HEARTBEAT_INTERVAL = 12000;
 exports.TRANSFER_TIMEOUT = 300000;
-exports.PING_TIMEOUT = 5000;
+exports.PING_TIMEOUT = 15000;
 exports.CONNECTION_TIMEOUT = 6000;
 exports.LOCKER_TIMEOUT = 15000;
 exports.RECONNECT_TIMEOUT = 5000;

package/dist/handler.js

@@ -41,6 +41,7 @@ class Handler {
                     }
                     catch (err) {
                         console.log('onMessage@error', err);
+                        yield transfer.responseFail(conn, message, err.message);
                     }
                 }),
             });

package/dist/peer-transfer.d.ts

@@ -22,8 +22,6 @@ export declare abstract class PeerTransfer {
     protected router: PeerRouter;
     protected reconnectAttempt: number;
     protected destroyed: boolean;
-    /** connectionId → Set<requestId> — settle in-flight requests on connection drop */
-    private connRequests;
     private _reconnecting;
     /** 退出标志：为 true 时禁止自动重连，直到 createPeer 被调用 */
     private _exited;
@@ -33,6 +31,8 @@ export declare abstract class PeerTransfer {
     private heartbeatTimer;
     /** 进行中的 Peer 创建：并发调用复用同一个 Promise，防止交叉 destroy/新建 */
     private creatingPeer;
+    /** 进行中的连接尝试：peerId → Promise，防止并发 connect 产生重复 DataConnection */
+    private connecting;
     /** 上次成功创建 Peer 的时间戳：节流窗口内直接复用现有实例 */
     private lastPeerCreatedAt;
     /** 创建代际：stop/clearInstance/新一轮创建时递增，使旧的进行中创建作废 */
@@ -56,7 +56,6 @@ export declare abstract class PeerTransfer {
     private createConnection;
     onConnect(conn: DataConnection): Promise<DataConnection | undefined>;
     private setupConnection;
-    private onConnClosed;
     removeConnection(peerId: string, connectionId?: string): void;
     isValidConnection(conn?: DataConnection): boolean;
     request(peerId: string, payload: PeerRequestPayload): Promise<PeerMessage>;
@@ -100,5 +99,7 @@ export declare abstract class PeerTransfer {
     private abortCreate;
     private destroyPeer;
     askReload(peerId: string): void;
+    getRouter(): PeerRouter;
+    setRouter(router: PeerRouter): void;
 }
 export {};

package/dist/peer-transfer.js

@@ -37,8 +37,6 @@ class PeerTransfer {
         this.router = new router_1.PeerRouter();
         this.reconnectAttempt = 0;
         this.destroyed = false;
-        /** connectionId → Set<requestId> — settle in-flight requests on connection drop */
-        this.connRequests = new Map();
         this._reconnecting = false;
         /** 退出标志：为 true 时禁止自动重连，直到 createPeer 被调用 */
         this._exited = false;
@@ -48,6 +46,8 @@ class PeerTransfer {
         this.heartbeatTimer = null;
         /** 进行中的 Peer 创建：并发调用复用同一个 Promise，防止交叉 destroy/新建 */
         this.creatingPeer = null;
+        /** 进行中的连接尝试：peerId → Promise，防止并发 connect 产生重复 DataConnection */
+        this.connecting = new Map();
         /** 上次成功创建 Peer 的时间戳：节流窗口内直接复用现有实例 */
         this.lastPeerCreatedAt = 0;
         /** 创建代际：stop/clearInstance/新一轮创建时递增，使旧的进行中创建作废 */
@@ -58,7 +58,6 @@ class PeerTransfer {
         this.connectionManager = new connection_manager_1.ConnectionManager({
             getPeer: () => this.peer,
             peerId: this.peerId,
-            onConnClosed: (conn) => this.onConnClosed(conn),
             ping: (peerId) => this.ping(peerId),
         });
     }
@@ -223,7 +222,17 @@ class PeerTransfer {
             if (existing) {
                 return existing;
             }
-            return this.createConnection(peerId);
+            // 并发去重：同一 peer 的连接尝试只进行一次，后续调用复用进行中的 Promise，
+            // 防止并发 request 触发多次 peer.connect() 产生重复 DataConnection
+            const inFlight = this.connecting.get(peerId);
+            if (inFlight) {
+                return inFlight;
+            }
+            const attempt = this.createConnection(peerId).finally(() => {
+                this.connecting.delete(peerId);
+            });
+            this.connecting.set(peerId, attempt);
+            return attempt;
         });
     }
     createConnection(peerId) {
@@ -271,8 +280,10 @@ class PeerTransfer {
         return __awaiter(this, void 0, void 0, function* () {
             if (!conn)
                 return;
+            // 立即入池并绑定 data 监听：DC open 前绑监听无副作用，
+            // 避免弱网下 DC 晚开时（超过 CONNECTION_TIMEOUT）成为无人监听的"聋子"连接
+            this.setupConnection(conn);
             if (conn.open) {
-                this.setupConnection(conn);
                 return conn;
             }
             return new Promise((resolve) => {
@@ -280,11 +291,12 @@ class PeerTransfer {
                     conn.off('open', onOpen);
                     conn.off('error', onError);
                     conn.off('close', onClose);
-                    resolve(this.isValidConnection(conn) ? this.setupConnection(conn) : undefined);
+                    // 超时但未关闭：连接可能仍在建立中，保留监听让其晚开后仍可处理消息
+                    resolve(conn.open || this.isValidConnection(conn) ? conn : undefined);
                 }, constant_1.CONNECTION_TIMEOUT);
                 const onOpen = () => {
                     clearTimeout(timer);
-                    resolve(this.setupConnection(conn));
+                    resolve(conn);
                 };
                 const onError = () => {
                     clearTimeout(timer);
@@ -314,13 +326,11 @@ class PeerTransfer {
             }
         });
     }
-    onConnClosed(conn) {
-        const reqIds = this.connRequests.get(conn.connectionId);
-        if (reqIds) {
-            this.connRequests.delete(conn.connectionId);
-        }
-    }
     removeConnection(peerId, connectionId) {
+        var _a;
+        if (((_a = this.peerConfig) === null || _a === void 0 ? void 0 : _a.debug) >= 2) {
+            console.log('removeConnection', peerId, connectionId);
+        }
         this.connectionManager.remove(peerId, connectionId);
     }
     isValidConnection(conn) {
@@ -329,12 +339,15 @@ class PeerTransfer {
     // ── Request / Reply ─────────────────────────────────────────────
     request(peerId, payload) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
+            var _a, _b;
             const requestId = payload.requestId || (yield this.genRequestId());
             let res;
             for (let attempt = 0; attempt <= 2; payload.route, attempt++) {
+                if (((_a = this.peerConfig) === null || _a === void 0 ? void 0 : _a.debug) >= 2) {
+                    console.info('request===>00', payload.route, requestId);
+                }
                 res = yield this.doRequestOnce(peerId, payload, requestId);
-                const code = (_a = res.error) === null || _a === void 0 ? void 0 : _a.code;
+                const code = (_b = res.error) === null || _b === void 0 ? void 0 : _b.code;
                 if (!res.error || (code !== 'CONN_CLOSED' && code !== 'CONN_FAILED')) {
                     return res;
                 }
@@ -359,14 +372,6 @@ class PeerTransfer {
                         timeout = null;
                     }
                     this.requests.delete(requestId);
-                    const reqs = this.connRequests.get(conn.connectionId);
-                    if (reqs) {
-                        reqs.delete(requestId);
-                        // connection pool cleanup
-                        if (reqs.size === 0) {
-                            this.connRequests.delete(conn.connectionId);
-                        }
-                    }
                 };
                 timeout = setTimeout(() => {
                     cleanup();
@@ -375,12 +380,6 @@ class PeerTransfer {
                     }
                     resolve(Object.assign(Object.assign({}, payload), { body: {}, error: { message: 'timeout', code: 'TIMEOUT' } }));
                 }, payload.timeout || entity_1.REQUEST_TIMEOUT);
-                let reqs = this.connRequests.get(conn.connectionId);
-                if (!reqs) {
-                    reqs = new Set();
-                    this.connRequests.set(conn.connectionId, reqs);
-                }
-                reqs.add(requestId);
                 this.requests.set(requestId, (message) => {
                     cleanup();
                     resolve(message);
@@ -395,11 +394,18 @@ class PeerTransfer {
     reply(conn, oldMessage, message) {
         return __awaiter(this, void 0, void 0, function* () {
             const data = Object.assign(Object.assign(Object.assign({}, this.inheritMessage(oldMessage)), message), { dest: conn.peer, scope: entity_1.PeerScope.RESPONSE, updatedAt: Date.now() });
-            if (!this.isValidConnection(conn)) {
-                const c = yield this.connectToPeer(conn.peer);
-                return c === null || c === void 0 ? void 0 : c.send(data);
+            // 以 DataChannel open 为准发送：新建连接的 RTCPeerConnection.connectionState
+            // 可能滞后（仍为 connecting），但 DC 已可正常收发；误判会导致响应被静默丢弃、
+            // 发送方 ping 超时进而误杀健康连接
+            if (conn.open) {
+                return conn.send(data);
             }
-            return conn.send(data);
+            const c = yield this.connectToPeer(conn.peer);
+            if (this.isValidConnection(c)) {
+                return c.send(data);
+            }
+            console.warn('reply dropped: no usable connection to', conn.peer);
+            return undefined;
         });
     }
     send(conn, message) {
@@ -520,6 +526,7 @@ class PeerTransfer {
                 yield this.router.run(conn, message);
             }
             catch (err) {
+                console.log('onRequest error', err);
                 this.responseFail(conn, message, { message: err.message, code: err.code });
             }
         });
@@ -594,7 +601,6 @@ class PeerTransfer {
         this.clearIdleTimer();
         this.clearHeartbeatTimer();
         this.requests.clear();
-        this.connRequests.clear();
         this.destroyPeer();
     }
     destroy() {
@@ -613,7 +619,6 @@ class PeerTransfer {
         this.connectionManager.stopHealthCheck();
         this.connectionManager.clean();
         this.requests.clear();
-        this.connRequests.clear();
         this.destroyPeer();
         this.reconnectAttempt = 0;
     }
@@ -622,6 +627,7 @@ class PeerTransfer {
         this.createEpoch++; // 旧创建的 isStale() 变为 true，自行 destroy 并抛错
         this.creatingPeer = null;
         this.lastPeerCreatedAt = 0; // 重置节流，createPeer 可立即再次创建
+        this.connecting.clear(); // 连接随 peer 一并销毁，进行中的尝试不再有意义
     }
     destroyPeer() {
         var _a;
@@ -637,5 +643,11 @@ class PeerTransfer {
             dst: peerId,
         });
     }
+    getRouter() {
+        return this.router;
+    }
+    setRouter(router) {
+        this.router = router;
+    }
 }
 exports.PeerTransfer = PeerTransfer;

package/dist/router.js

@@ -116,7 +116,7 @@ class PeerRouter {
                     .slice(0, route.scope)
                     .filter((item) => (0, path_to_regexp_1.match)(item.path)(path))
                     .sort((a, b) => (b.priority || 0) - (a.priority || 0));
-                const res = yield this.compose(stack)(conn, message);
+                yield this.compose(stack)(conn, message);
                 // Execute route handler with timeout
                 const routePromise = Promise.resolve(route.callback.apply(null, [conn, message]));
                 const timeoutPromise = new Promise((_, reject) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "egos-transfer",
-  "version": "0.2.14",
+  "version": "0.2.16",
   "description": "1234",
   "homepage": "https://github.com/superbogy/peer-transfer#readme",
   "bugs": {

package/src/connection-manager.ts

@@ -5,14 +5,14 @@ type ResponseCb = (args: any) => void;
 const HEALTH_CHECK_INTERVAL = 15000;
 /** 连接最大存活时间：超过 15 分钟的连接在 get 时自动丢弃，强制重建 */
 const MAX_CONNECTION_AGE = 15 * 60 * 1000;
+/** 建立中连接的最大等待时间：仍未 open 视为僵死 pending，由健康检查清理 */
+const PENDING_CONNECTION_TIMEOUT = 30000;
 
 export interface ConnectionManagerDeps {
   /** 获取当前 Peer 实例（PeerTransfer 可能异步重建） */
   getPeer: () => Peer | undefined;
   peerId: string;
   ping: (peerId: string) => Promise<boolean>;
-  /** 连接关闭时回调，由 PeerTransfer 处理未完成的请求结算 */
-  onConnClosed: (conn: DataConnection) => void;
 }
 
 /**
@@ -40,6 +40,11 @@ export class ConnectionManager {
     if (!conn) {
       return;
     }
+    // 建立中（未 open）：等待其完成，不当场移除——remove 会主动 close，
+    // 相当于掐死一次进行中的 WebRTC 握手
+    if (!conn.open) {
+      return;
+    }
     if (this.isValid(conn)) {
       return conn;
     } else {
@@ -73,11 +78,17 @@ export class ConnectionManager {
    * @param conn - 已打开的 DataConnection
    * @param onData - 数据事件回调（由 PeerTransfer 提供，路由消息）
    */
-  setup(
-    conn: DataConnection & { timestamp?: number },
-    onData: (message: any) => void,
-  ): DataConnection {
-    conn.timestamp = Date.now();
+  setup(conn: DataConnection, onData: (message: any) => void) {
+    const cur = this.get(conn.peer);
+    if (this.isValid(cur)) {
+      return cur;
+    }
+    // 复用 metadata.time 作为连接时间戳（发起方 connect 时已写入），
+    // 入站连接未携带时补上，供 isValid 的过期判定与 pending 清理使用
+    (conn as { metadata: any }).metadata = {
+      ...(conn.metadata ?? {}),
+      time: conn.metadata?.time ?? Date.now(),
+    };
     this.pool.set(conn.peer, conn);
     conn.on('data', onData);
     conn.on('close', () => this.handleConnClosed(conn));
@@ -92,10 +103,6 @@ export class ConnectionManager {
         }
       };
       pc.addEventListener('connectionstatechange', onStateChange);
-      // 将清理函数挂到 conn 上，remove 时一并移除
-      (conn as any).__cm_stateChangeCleanup = () => {
-        pc.removeEventListener('connectionstatechange', onStateChange);
-      };
     }
 
     return conn;
@@ -107,38 +114,36 @@ export class ConnectionManager {
       if (connectionId && conn.connectionId !== connectionId) return;
       this.pool.delete(peerId);
       // 先 close 触发 close 事件（handleConnClosed 会结算 in-flight 请求），
-      // 再清理监听器与 PeerJS 内部引用，避免僵尸连接堆积导致无法建立新连接
       conn.close();
-      (conn as any).__cm_stateChangeCleanup?.();
-      conn.removeAllListeners();
-      this.deps.getPeer()?._removeConnection(conn);
-    } else {
-      // 清理 Peer 内部残留的 connection 引用
-      const connections = this.deps.getPeer()?.connections || {};
-      for (const c of connections[peerId] || []) {
-        c.removeAllListeners();
-        c.close();
-        this.deps.getPeer()?._removeConnection(c);
-      }
+      // 再清理监听器与 PeerJS 内部引用，避免僵尸连接堆积导致无法建立新连接
+      // (conn as any).__cm_stateChangeCleanup?.();
+      // conn.removeAllListeners();
+      // this.deps.getPeer()?._removeConnection(conn);
     }
   }
 
-  isValid(conn?: DataConnection & { timestamp?: number }): boolean {
+  isValid(conn?: DataConnection): boolean {
     if (!conn?.open || !conn?.peerConnection) {
       return false;
     }
     // 检查连接是否过期
-    if (conn.timestamp && Date.now() - conn.timestamp > MAX_CONNECTION_AGE) {
+    const createdAt = conn.metadata?.time;
+    if (createdAt && Date.now() - createdAt > MAX_CONNECTION_AGE) {
       return false;
     }
-    return ['connected', 'completed'].includes(conn.peerConnection.connectionState);
+    // DC open 即可收发。RTCPeerConnection.connectionState 的迁移可能滞后于
+    // DC open（新连接常仍为 connecting），若据此判无效会在 get() 中把健康连接
+    // remove 掉，导致 ping 失败、连接被误杀。PC 终态（failed/closed）由
+    // connectionstatechange 监听负责清理，无需在此重复判定
+    return true;
   }
 
   private handleConnClosed(conn: DataConnection): void {
-    this.pool.delete(conn.peer);
-    // 同步移除 PeerJS 内部引用，避免僵尸连接堆积
-    this.deps.getPeer()?._removeConnection(conn);
-    this.deps.onConnClosed(conn);
+    // 仅当池中登记的仍是该连接时才删除：连接被新连接替换后，
+    // 旧连接迟到的 close/error 不得清掉新连接的池项
+    if (this.pool.get(conn.peer) === conn) {
+      this.pool.delete(conn.peer);
+    }
   }
 
   // ── Health check ─────────────────────────────────────────────────
@@ -163,9 +168,19 @@ export class ConnectionManager {
     for (const peerId of peers) {
       const conn = this.pool.get(peerId);
       if (!conn) continue;
+      // 建立中（未 open）：setup 在 DC open 前就入池，健康检查若此刻判定会误杀刚建立的连接；
+      // 留出宽限期，仅清理超过 PENDING_CONNECTION_TIMEOUT 仍未 open 的僵死 pending
+      if (!conn.open) {
+        const createdAt = conn.metadata?.time;
+        if (createdAt && Date.now() - createdAt > PENDING_CONNECTION_TIMEOUT) {
+          this.remove(peerId, conn.connectionId);
+        }
+        continue;
+      }
       const alive = await this.pingConnection(conn);
       if (!alive) {
-        this.remove(peerId);
+        // 带上 connectionId：await ping 期间该 peerId 可能已被新连接替换，避免误关新连接
+        this.remove(peerId, conn.connectionId);
       }
     }
   }

package/src/constant.ts

@@ -1,7 +1,7 @@
 export const REQUEST_TIMEOUT = 18000;
 export const HEARTBEAT_INTERVAL = 12000;
 export const TRANSFER_TIMEOUT = 300000;
-export const PING_TIMEOUT = 5000;
+export const PING_TIMEOUT = 15000;
 export const CONNECTION_TIMEOUT = 6000;
 export const LOCKER_TIMEOUT = 15000;
 export const RECONNECT_TIMEOUT = 5000;

package/src/handler.ts

@@ -68,6 +68,7 @@ export class Handler {
           await transfer.responseOk(conn, message);
         } catch (err) {
           console.log('onMessage@error', err);
+          await transfer.responseFail(conn, message, err.message);
         }
       },
     });

package/src/peer-transfer.ts

@@ -57,8 +57,6 @@ export abstract class PeerTransfer {
   protected reconnectAttempt = 0;
   protected destroyed = false;
 
-  /** connectionId → Set<requestId> — settle in-flight requests on connection drop */
-  private connRequests = new Map<string, Set<string>>();
   private _reconnecting = false;
   /** 退出标志：为 true 时禁止自动重连，直到 createPeer 被调用 */
   private _exited = false;
@@ -68,6 +66,8 @@ export abstract class PeerTransfer {
   private heartbeatTimer: ReturnType<typeof setTimeout> | null = null;
   /** 进行中的 Peer 创建：并发调用复用同一个 Promise，防止交叉 destroy/新建 */
   private creatingPeer: Promise<Peer> | null = null;
+  /** 进行中的连接尝试：peerId → Promise，防止并发 connect 产生重复 DataConnection */
+  private connecting = new Map<string, Promise<DataConnection | undefined>>();
   /** 上次成功创建 Peer 的时间戳：节流窗口内直接复用现有实例 */
   private lastPeerCreatedAt = 0;
   /** 创建代际：stop/clearInstance/新一轮创建时递增，使旧的进行中创建作废 */
@@ -80,7 +80,6 @@ export abstract class PeerTransfer {
     this.connectionManager = new ConnectionManager({
       getPeer: () => this.peer,
       peerId: this.peerId,
-      onConnClosed: (conn) => this.onConnClosed(conn),
       ping: (peerId: string) => this.ping(peerId),
     });
   }
@@ -270,7 +269,17 @@ export abstract class PeerTransfer {
       return existing;
     }
 
-    return this.createConnection(peerId);
+    // 并发去重：同一 peer 的连接尝试只进行一次，后续调用复用进行中的 Promise，
+    // 防止并发 request 触发多次 peer.connect() 产生重复 DataConnection
+    const inFlight = this.connecting.get(peerId);
+    if (inFlight) {
+      return inFlight;
+    }
+    const attempt = this.createConnection(peerId).finally(() => {
+      this.connecting.delete(peerId);
+    });
+    this.connecting.set(peerId, attempt);
+    return attempt;
   }
 
   private async createConnection(peerId: string): Promise<DataConnection | undefined> {
@@ -316,8 +325,11 @@ export abstract class PeerTransfer {
   async onConnect(conn: DataConnection): Promise<DataConnection | undefined> {
     if (!conn) return;
 
+    // 立即入池并绑定 data 监听：DC open 前绑监听无副作用，
+    // 避免弱网下 DC 晚开时（超过 CONNECTION_TIMEOUT）成为无人监听的"聋子"连接
+    this.setupConnection(conn);
+
     if (conn.open) {
-      this.setupConnection(conn);
       return conn;
     }
 
@@ -326,12 +338,13 @@ export abstract class PeerTransfer {
         conn.off('open', onOpen);
         conn.off('error', onError);
         conn.off('close', onClose);
-        resolve(this.isValidConnection(conn) ? this.setupConnection(conn) : undefined);
+        // 超时但未关闭：连接可能仍在建立中，保留监听让其晚开后仍可处理消息
+        resolve(conn.open || this.isValidConnection(conn) ? conn : undefined);
       }, CONNECTION_TIMEOUT);
 
       const onOpen = () => {
         clearTimeout(timer);
-        resolve(this.setupConnection(conn));
+        resolve(conn);
       };
 
       const onError = () => {
@@ -365,14 +378,11 @@ export abstract class PeerTransfer {
     });
   }
 
-  private onConnClosed(conn: DataConnection) {
-    const reqIds = this.connRequests.get(conn.connectionId);
-    if (reqIds) {
-      this.connRequests.delete(conn.connectionId);
+  removeConnection(peerId: string, connectionId?: string) {
+    if (this.peerConfig?.debug >= 2) {
+      console.log('removeConnection', peerId, connectionId);
     }
-  }
 
-  removeConnection(peerId: string, connectionId?: string) {
     this.connectionManager.remove(peerId, connectionId);
   }
 
@@ -386,6 +396,9 @@ export abstract class PeerTransfer {
     const requestId = payload.requestId || (await this.genRequestId());
     let res: PeerMessage;
     for (let attempt = 0; attempt <= 2; payload.route, attempt++) {
+      if (this.peerConfig?.debug >= 2) {
+        console.info('request===>00', payload.route, requestId);
+      }
       res = await this.doRequestOnce(peerId, payload, requestId);
       const code = (res.error as Record<string, any>)?.code;
       if (!res.error || (code !== 'CONN_CLOSED' && code !== 'CONN_FAILED')) {
@@ -421,14 +434,6 @@ export abstract class PeerTransfer {
           timeout = null;
         }
         this.requests.delete(requestId);
-        const reqs = this.connRequests.get(conn.connectionId);
-        if (reqs) {
-          reqs.delete(requestId);
-          // connection pool cleanup
-          if (reqs.size === 0) {
-            this.connRequests.delete(conn.connectionId);
-          }
-        }
       };
 
       timeout = setTimeout(() => {
@@ -440,13 +445,6 @@ export abstract class PeerTransfer {
         resolve({ ...payload, body: {}, error: { message: 'timeout', code: 'TIMEOUT' } } as any);
       }, payload.timeout || REQUEST_TIMEOUT);
 
-      let reqs = this.connRequests.get(conn.connectionId);
-      if (!reqs) {
-        reqs = new Set();
-        this.connRequests.set(conn.connectionId, reqs);
-      }
-      reqs.add(requestId);
-
       this.requests.set(requestId, (message: Record<string, any>) => {
         cleanup();
         resolve(message as any);
@@ -479,11 +477,18 @@ export abstract class PeerTransfer {
       scope: PeerScope.RESPONSE,
       updatedAt: Date.now(),
     };
-    if (!this.isValidConnection(conn)) {
-      const c = await this.connectToPeer(conn.peer);
-      return c?.send(data);
+    // 以 DataChannel open 为准发送：新建连接的 RTCPeerConnection.connectionState
+    // 可能滞后（仍为 connecting），但 DC 已可正常收发；误判会导致响应被静默丢弃、
+    // 发送方 ping 超时进而误杀健康连接
+    if (conn.open) {
+      return conn.send(data);
+    }
+    const c = await this.connectToPeer(conn.peer);
+    if (this.isValidConnection(c)) {
+      return c.send(data);
     }
-    return conn.send(data);
+    console.warn('reply dropped: no usable connection to', conn.peer);
+    return undefined;
   }
 
   async send(conn: DataConnection, message: PeerRequestPayload) {
@@ -613,6 +618,7 @@ export abstract class PeerTransfer {
     try {
       await this.router.run(conn, message);
     } catch (err: any) {
+      console.log('onRequest error', err);
       this.responseFail(conn, message, { message: err.message, code: err.code });
     }
   }
@@ -695,7 +701,6 @@ export abstract class PeerTransfer {
     this.clearIdleTimer();
     this.clearHeartbeatTimer();
     this.requests.clear();
-    this.connRequests.clear();
     this.destroyPeer();
   }
 
@@ -716,7 +721,6 @@ export abstract class PeerTransfer {
     this.connectionManager.stopHealthCheck();
     this.connectionManager.clean();
     this.requests.clear();
-    this.connRequests.clear();
     this.destroyPeer();
     this.reconnectAttempt = 0;
   }
@@ -726,6 +730,7 @@ export abstract class PeerTransfer {
     this.createEpoch++; // 旧创建的 isStale() 变为 true，自行 destroy 并抛错
     this.creatingPeer = null;
     this.lastPeerCreatedAt = 0; // 重置节流，createPeer 可立即再次创建
+    this.connecting.clear(); // 连接随 peer 一并销毁，进行中的尝试不再有意义
   }
 
   private destroyPeer() {
@@ -741,4 +746,12 @@ export abstract class PeerTransfer {
       dst: peerId,
     });
   }
+
+  getRouter() {
+    return this.router;
+  }
+
+  setRouter(router: PeerRouter) {
+    this.router = router;
+  }
 }

package/src/router.ts

@@ -104,7 +104,6 @@ export class PeerRouter {
   async run(conn: DataConnection, message: PeerMessage) {
     const routeKey = `${message.method}:${message.route}`;
     this.performanceMonitor.startTimer(routeKey);
-
     try {
       if (!this.routes.length) {
         return;
@@ -147,8 +146,7 @@ export class PeerRouter {
         .slice(0, route.scope)
         .filter((item) => match(item.path)(path))
         .sort((a, b) => (b.priority || 0) - (a.priority || 0));
-
-      const res = await this.compose(stack)(conn, message);
+      await this.compose(stack)(conn, message);
       // Execute route handler with timeout
       const routePromise = Promise.resolve(route.callback.apply(null, [conn, message]));
       const timeoutPromise = new Promise((_, reject) => {