@pixelhue/event-controller-sdk 0.0.1 → 0.0.14

package/dist/index.d.ts

@@ -14,4 +14,3 @@ export { QueueOverflowStrategy } from './packages/tcp/types.js';
 export { SUPPORTED_MODELS, DEFAULT_TCP_PORT, DEFAULT_ENABLE_HEARTBEAT, DEFAULT_AUTO_RECONNECT, DEFAULT_HEARTBEAT_INTERVAL, DEFAULT_RECONNECT_INTERVAL, DEFAULT_HEARTBEAT_TIMEOUT, DEFAULT_MAX_RECONNECT_INTERVAL, DEFAULT_ENABLE_EXPONENTIAL_BACKOFF, DEFAULT_MDNS_QUERY_INTERVAL, DEFAULT_MAX_RECONNECT_ATTEMPTS, } from './packages/tcp/constants.js';
 export { parseHost, parsePort } from './packages/tcp/utils.js';
 export type { ProtocolParseResult } from './packages/tcp/protocolHandler.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -15,4 +15,3 @@ export { QueueOverflowStrategy } from './packages/tcp/types.js';
 export { SUPPORTED_MODELS, DEFAULT_TCP_PORT, DEFAULT_ENABLE_HEARTBEAT, DEFAULT_AUTO_RECONNECT, DEFAULT_HEARTBEAT_INTERVAL, DEFAULT_RECONNECT_INTERVAL, DEFAULT_HEARTBEAT_TIMEOUT, DEFAULT_MAX_RECONNECT_INTERVAL, DEFAULT_ENABLE_EXPONENTIAL_BACKOFF, DEFAULT_MDNS_QUERY_INTERVAL, DEFAULT_MAX_RECONNECT_ATTEMPTS, } from './packages/tcp/constants.js';
 // 工具函数导出
 export { parseHost, parsePort } from './packages/tcp/utils.js';
-//# sourceMappingURL=index.js.map

package/dist/packages/tcp/ConnectManager.d.ts

@@ -1,6 +1,6 @@
 import { EventEmitter } from 'eventemitter3';
-import type { ConnectionManagerEvents, SocketConnectOptions } from './types.js';
 import { SocketWrapper } from './SocketWrapper.js';
+import type { ConnectionManagerEvents, SocketConnectOptions } from './types.js';
 /**
  * MINI连接管理器
  */
@@ -63,4 +63,3 @@ export declare class MiniConnectionManager extends EventEmitter<ConnectionManage
      */
     destroy(): Promise<void>;
 }
-//# sourceMappingURL=ConnectManager.d.ts.map

package/dist/packages/tcp/ConnectManager.js

@@ -71,7 +71,7 @@ export class MiniConnectionManager extends EventEmitter {
         const connectionId = this.getConnectionId(address, port);
         const socketWrapper = this.connections.get(connectionId);
         if (socketWrapper) {
-            await socketWrapper.disconnect();
+            socketWrapper.disconnect();
             this.connections.delete(connectionId);
             // 触发断开事件，传递 SocketWrapper
             this.emit('disconnected', socketWrapper);
@@ -169,8 +169,7 @@ export class MiniConnectionManager extends EventEmitter {
      */
     async destroy() {
         this.isShuttingDown = true;
-        await this.disconnectAll();
+        this.disconnectAll();
         this.removeAllListeners();
     }
 }
-//# sourceMappingURL=ConnectManager.js.map

package/dist/packages/tcp/QueueManager.d.ts

@@ -38,4 +38,3 @@ export declare class QueueManager {
      */
     clear(): void;
 }
-//# sourceMappingURL=QueueManager.d.ts.map

package/dist/packages/tcp/QueueManager.js

@@ -40,18 +40,13 @@ export class QueueManager {
     addToQueue(requestId, data, processor, onError, cachedParseResult) {
         this.queue
             .add(async () => {
-            try {
-                // 处理队列项
-                await processor(requestId, data, cachedParseResult);
-                // 去重标记
-                this.processedRequestIds.add(requestId);
-                // 限制去重集合大小，防止内存泄漏
-                if (this.processedRequestIds.size > this.queueOptions.maxLength * 2) {
-                    this.processedRequestIds.clear();
-                }
-            }
-            catch (error) {
-                throw error; // 重新抛出，让 p-queue 处理
+            // 处理队列项
+            await processor(requestId, data, cachedParseResult);
+            // 去重标记
+            this.processedRequestIds.add(requestId);
+            // 限制去重集合大小，防止内存泄漏
+            if (this.processedRequestIds.size > this.queueOptions.maxLength * 2) {
+                this.processedRequestIds.clear();
             }
         })
             .catch((error) => {
@@ -79,11 +74,12 @@ export class QueueManager {
             case QueueOverflowStrategy.DROP_NEWEST:
                 // 丢弃最新数据
                 break;
-            case QueueOverflowStrategy.REJECT:
+            case QueueOverflowStrategy.REJECT: {
                 // 拒绝新数据并触发错误
                 const error = new Error(`Queue overflow: max length ${this.queueOptions.maxLength} reached`);
                 onError(error, requestId);
                 break;
+            }
             case QueueOverflowStrategy.DROP_OLDEST:
             default:
                 // p-queue 不支持直接丢弃最旧的任务
@@ -99,4 +95,3 @@ export class QueueManager {
         this.processedRequestIds.clear();
     }
 }
-//# sourceMappingURL=QueueManager.js.map

package/dist/packages/tcp/SocketWrapper.d.ts

@@ -1,6 +1,6 @@
 import { EventEmitter } from 'events';
-import type { ISocketWrapper, SocketConnectOptions, QueueOptions, ProtocolSendPayload } from './types.js';
 import { TcpWrapper } from './tcpWrapper.js';
+import type { ISocketWrapper, ProtocolSendPayload, QueueOptions, SocketConnectOptions } from './types.js';
 /**
  * SocketWrapper - TCP Socket 最小传输封装
  *
@@ -36,7 +36,7 @@ export declare class SocketWrapper extends EventEmitter implements ISocketWrappe
     constructor(queueOptions?: Partial<QueueOptions>);
     /**
      * 检查是否是心跳数据（ping/pong）
-     * 使用 Buffer 直接比较，避免字符串转换开销
+     * 使用 TcpWrapper 的 heartbeatResponseChecker 统一检查
      */
     private isHeartbeatData;
     /**
@@ -44,6 +44,17 @@ export declare class SocketWrapper extends EventEmitter implements ISocketWrappe
      * @param data 接收到的数据
      */
     private handleReceiveData;
+    /**
+     * 移除缓冲区开头的心跳数据（处理粘包情况：心跳数据 + 协议数据）
+     * @returns 如果移除了心跳数据返回 true，否则返回 false
+     */
+    private removeHeartbeatPrefix;
+    /**
+     * 处理提取出的协议包
+     * @param packets 有效协议包列表
+     * @param invalidPackets 无效协议包列表
+     */
+    private processExtractedPackets;
     /**
      * 处理协议数据（使用半包粘包处理）
      * 使用循环替代递归，避免栈溢出风险
@@ -103,4 +114,3 @@ export declare class SocketWrapper extends EventEmitter implements ISocketWrappe
      */
     getTcpWrapper(): TcpWrapper;
 }
-//# sourceMappingURL=SocketWrapper.d.ts.map

package/dist/packages/tcp/SocketWrapper.js

@@ -1,14 +1,12 @@
 // ALL_CODE_LINE: 329
 // AI_CODE_LINE: 53
 import { EventEmitter } from 'events';
-import { TcpWrapper } from './tcpWrapper.js';
-import { QueueManager, DEFAULT_QUEUE_OPTIONS } from './QueueManager.js';
 import { ProtocolHandler } from './protocolHandler.js';
+import { DEFAULT_QUEUE_OPTIONS, QueueManager } from './QueueManager.js';
+import { TcpWrapper } from './tcpWrapper.js';
 /**
- * 心跳数据常量（预定义 Buffer，避免重复转换）
+ * 心跳数据长度常量
  */
-const HEARTBEAT_PING = Buffer.from('ping', 'utf8');
-const HEARTBEAT_PONG = Buffer.from('pong', 'utf8');
 const HEARTBEAT_LENGTH = 4;
 /**
  * SocketWrapper - TCP Socket 最小传输封装
@@ -76,13 +74,11 @@ export class SocketWrapper extends EventEmitter {
     }
     /**
      * 检查是否是心跳数据（ping/pong）
-     * 使用 Buffer 直接比较，避免字符串转换开销
+     * 使用 TcpWrapper 的 heartbeatResponseChecker 统一检查
      */
     isHeartbeatData(buffer) {
-        if (buffer.length !== HEARTBEAT_LENGTH) {
-            return false;
-        }
-        return buffer.equals(HEARTBEAT_PING) || buffer.equals(HEARTBEAT_PONG);
+        const heartbeatResponseChecker = this.tcpWrapper.getHeartbeatResponseChecker();
+        return heartbeatResponseChecker(buffer);
     }
     /**
      * 接收数据处理
@@ -103,6 +99,38 @@ export class SocketWrapper extends EventEmitter {
         // 处理协议数据
         this.handleProtocolData();
     }
+    /**
+     * 移除缓冲区开头的心跳数据（处理粘包情况：心跳数据 + 协议数据）
+     * @returns 如果移除了心跳数据返回 true，否则返回 false
+     */
+    removeHeartbeatPrefix() {
+        if (!this.receiveBuffer || this.receiveBuffer.length < HEARTBEAT_LENGTH) {
+            return false;
+        }
+        const first4Bytes = this.receiveBuffer.slice(0, HEARTBEAT_LENGTH);
+        if (!this.isHeartbeatData(first4Bytes)) {
+            return false;
+        }
+        // 移除前 4 字节的心跳数据
+        this.receiveBuffer =
+            this.receiveBuffer.length > HEARTBEAT_LENGTH ? this.receiveBuffer.slice(HEARTBEAT_LENGTH) : null;
+        return true;
+    }
+    /**
+     * 处理提取出的协议包
+     * @param packets 有效协议包列表
+     * @param invalidPackets 无效协议包列表
+     */
+    processExtractedPackets(packets, invalidPackets) {
+        // 处理校验失败的废包
+        if (invalidPackets.length > 0) {
+            this.emit('error', new Error(`Invalid packets detected: ${invalidPackets.length} packets dropped`));
+        }
+        // 处理每个有效完整包
+        for (const packet of packets) {
+            this.processPacket(packet);
+        }
+    }
     /**
      * 处理协议数据（使用半包粘包处理）
      * 使用循环替代递归，避免栈溢出风险
@@ -110,34 +138,42 @@ export class SocketWrapper extends EventEmitter {
     handleProtocolData() {
         if (!this.receiveBuffer)
             return;
+        // 保护机制：跟踪 remaining 长度未变化的次数 防止异常数据导致死循环
+        const MAX_STAGNANT_LOOPS = 10; // 最大停滞循环次数
+        let stagnantCount = 0;
+        let lastRemainingLength = 0;
         // 循环处理，直到没有更多数据需要处理
         while (this.receiveBuffer) {
             // 检查并过滤心跳数据（处理粘包情况：心跳数据 + 协议数据）
-            if (this.receiveBuffer.length >= HEARTBEAT_LENGTH) {
-                const first4Bytes = this.receiveBuffer.slice(0, HEARTBEAT_LENGTH);
-                if (this.isHeartbeatData(first4Bytes)) {
-                    // 移除前 4 字节的心跳数据，继续处理剩余数据
-                    this.receiveBuffer =
-                        this.receiveBuffer.length > HEARTBEAT_LENGTH ? this.receiveBuffer.slice(HEARTBEAT_LENGTH) : null;
-                    continue; // 继续循环处理剩余数据
-                }
+            if (this.removeHeartbeatPrefix()) {
+                continue; // 继续循环处理剩余数据
             }
             // 提取所有完整协议包（自动校验）
             const { packets, remaining, invalidPackets } = this.protocolHandler.extractAllCompletePackets(this.receiveBuffer);
-            // 处理校验失败的废包
-            if (invalidPackets.length > 0) {
-                this.emit('error', new Error(`Invalid packets detected: ${invalidPackets.length} packets dropped`));
-            }
-            // 处理每个有效完整包
-            for (const packet of packets) {
-                this.processPacket(packet);
-            }
+            // 处理提取出的协议包
+            this.processExtractedPackets(packets, invalidPackets);
             // 更新接收缓冲区为剩余数据（半包数据保留）
             this.receiveBuffer = remaining;
             // 如果没有剩余数据，退出循环
             if (!remaining || remaining.length === 0) {
                 break;
             }
+            // 保护机制：检查 remaining 长度是否一直没变化
+            if (remaining.length > 0) {
+                if (remaining.length === lastRemainingLength) {
+                    // 长度没变化，增加停滞计数
+                    stagnantCount += 1;
+                    if (stagnantCount > MAX_STAGNANT_LOOPS) {
+                        this.receiveBuffer = null; // 丢弃剩余数据
+                        break;
+                    }
+                }
+                else {
+                    // 长度有变化，重置停滞计数
+                    stagnantCount = 0;
+                    lastRemainingLength = remaining.length;
+                }
+            }
         }
     }
     /**
@@ -213,6 +249,11 @@ export class SocketWrapper extends EventEmitter {
             this.emit('error', new Error('Socket is not writable'));
             return;
         }
+        // 防止发送空数据：如果数据长度为 0，记录错误并返回
+        if (!bytes || bytes.length === 0) {
+            this.emit('error', new Error('尝试发送空数据包（size === 0），可能是协议构建失败'));
+            return;
+        }
         socket.write(bytes, (err) => {
             if (err) {
                 this.emit('error', err);
@@ -242,7 +283,7 @@ export class SocketWrapper extends EventEmitter {
         if (typeof buildOptions.seqId !== 'number') {
             buildOptions.seqId = this.protocolHandler.generateSeqId();
         }
-        const buffer = this.protocolHandler.build(payload);
+        const buffer = this.protocolHandler.build(buildOptions);
         const resolvedRequestId = buildOptions.seqId;
         this.writeToSocket(buffer);
         return resolvedRequestId;
@@ -278,4 +319,3 @@ export class SocketWrapper extends EventEmitter {
         return this.tcpWrapper;
     }
 }
-//# sourceMappingURL=SocketWrapper.js.map

package/dist/packages/tcp/constants.d.ts

@@ -22,4 +22,3 @@ export declare const DEFAULT_ENABLE_EXPONENTIAL_BACKOFF = true;
 export declare const DEFAULT_MDNS_QUERY_INTERVAL = 10000;
 /** 默认最大重连次数 */
 export declare const DEFAULT_MAX_RECONNECT_ATTEMPTS = 0;
-//# sourceMappingURL=constants.d.ts.map

package/dist/packages/tcp/constants.js

@@ -24,4 +24,3 @@ export const DEFAULT_ENABLE_EXPONENTIAL_BACKOFF = true;
 export const DEFAULT_MDNS_QUERY_INTERVAL = 10000; // 10秒
 /** 默认最大重连次数 */
 export const DEFAULT_MAX_RECONNECT_ATTEMPTS = 0;
-//# sourceMappingURL=constants.js.map

package/dist/packages/tcp/discoveryService.d.ts

@@ -39,4 +39,3 @@ export declare class MiniDiscoveryService extends EventEmitter<DiscoveryEvents>
      */
     destroy(): void;
 }
-//# sourceMappingURL=discoveryService.d.ts.map

package/dist/packages/tcp/discoveryService.js

@@ -163,4 +163,3 @@ export class MiniDiscoveryService extends EventEmitter {
         this.removeAllListeners(); // 清理当前DiscoveryService（继承自EventEmitter）的所有事件监听器，避免内存泄漏
     }
 }
-//# sourceMappingURL=discoveryService.js.map

package/dist/packages/tcp/protocolHandler.d.ts

@@ -61,4 +61,3 @@ export declare class ProtocolHandler {
         invalidPackets: Buffer[];
     };
 }
-//# sourceMappingURL=protocolHandler.d.ts.map

package/dist/packages/tcp/protocolHandler.js

@@ -4,8 +4,8 @@
  * Uniform Protocol 协议处理模块
  * 封装协议解析、校验和构建功能
  */
-import { UniformProtocolParser } from '@unico/uniform-protocol-parser';
 import { UniformProtocolBuilder } from '@unico/uniform-protocol-builder';
+import { UniformProtocolParser } from '@unico/uniform-protocol-parser';
 /**
  * Uniform Protocol 协议处理器
  */
@@ -42,6 +42,7 @@ export class ProtocolHandler {
             };
         }
         catch (error) {
+            console.error('解析协议数据包时出错:', error);
             throw error;
         }
     }
@@ -93,4 +94,3 @@ export class ProtocolHandler {
         };
     }
 }
-//# sourceMappingURL=protocolHandler.js.map

package/dist/packages/tcp/tcpWrapper.d.ts

@@ -1,5 +1,5 @@
 import * as net from 'net';
-import type { SocketConnectOptions, HeartbeatResponseChecker } from './types.js';
+import type { HeartbeatResponseChecker, SocketConnectOptions } from './types.js';
 /**
  * tcp连接管理器
  * 负责处理 TCP 连接、重连、超时检测等
@@ -33,7 +33,7 @@ export declare class TcpWrapper {
     private pendingHeartbeat;
     /** 连续心跳超时次数 */
     private heartbeatTimeoutCount;
-    /** 心跳响应识别函数 */
+    /** 心跳响应识别函数（同时检查 ping 和 pong） */
     private heartbeatResponseChecker;
     /** 最大重连次数，0 表示无限制 */
     private maxReconnectAttempts;
@@ -65,7 +65,6 @@ export declare class TcpWrapper {
     private onError?;
     /** 连接关闭回调（手动断开或重连失败时触发） */
     private onClose?;
-    constructor();
     /**
      * 设置 Socket 事件监听
      */
@@ -110,6 +109,27 @@ export declare class TcpWrapper {
      * 设置连接超时
      */
     private setConnectTimeout;
+    /**
+     * 握手超时处理入口
+     * 提取为独立方法以降低 setConnectTimeout 的复杂度
+     */
+    private handleHandshakeTimeout;
+    /**
+     * 是否还有剩余的握手重试次数
+     */
+    private hasRemainingHandshakeAttempts;
+    /**
+     * 执行握手重试流程：销毁当前 socket、计算重试间隔并尝试重新连接
+     */
+    private retryHandshakeConnection;
+    /**
+     * 安排一次新的握手重连尝试
+     */
+    private scheduleHandshakeReconnect;
+    /**
+     * 握手多次超时后的失败处理
+     */
+    private handleHandshakeFailure;
     /**
      * 清除连接超时定时器
      */
@@ -152,6 +172,10 @@ export declare class TcpWrapper {
      * 设置心跳响应识别函数
      */
     setHeartbeatResponseChecker(checker: HeartbeatResponseChecker): void;
+    /**
+     * 获取心跳响应识别函数
+     */
+    getHeartbeatResponseChecker(): HeartbeatResponseChecker;
     /**
      * 获取当前连接地址
      */
@@ -165,4 +189,3 @@ export declare class TcpWrapper {
      */
     getReconnectAttempts(): number;
 }
-//# sourceMappingURL=tcpWrapper.d.ts.map

package/dist/packages/tcp/tcpWrapper.js

@@ -1,7 +1,7 @@
 // ALL_CODE_LINE: 450
 // AI_CODE_LINE: 40
 import * as net from 'net';
-import { DEFAULT_AUTO_RECONNECT, DEFAULT_RECONNECT_INTERVAL, DEFAULT_HEARTBEAT_INTERVAL, DEFAULT_HEARTBEAT_TIMEOUT, DEFAULT_MAX_RECONNECT_INTERVAL, DEFAULT_ENABLE_EXPONENTIAL_BACKOFF, DEFAULT_MAX_RECONNECT_ATTEMPTS, } from './constants.js';
+import { DEFAULT_AUTO_RECONNECT, DEFAULT_ENABLE_EXPONENTIAL_BACKOFF, DEFAULT_HEARTBEAT_INTERVAL, DEFAULT_HEARTBEAT_TIMEOUT, DEFAULT_MAX_RECONNECT_ATTEMPTS, DEFAULT_MAX_RECONNECT_INTERVAL, DEFAULT_RECONNECT_INTERVAL, } from './constants.js';
 /**
  * tcp连接管理器
  * 负责处理 TCP 连接、重连、超时检测等
@@ -35,8 +35,13 @@ export class TcpWrapper {
     pendingHeartbeat = false;
     /** 连续心跳超时次数 */
     heartbeatTimeoutCount = 0;
-    /** 心跳响应识别函数 */
+    /** 心跳响应识别函数（同时检查 ping 和 pong） */
     heartbeatResponseChecker = (data) => {
+        // 检查 ping（发送的心跳）
+        if (data.length === 4 && data.toString('utf8') === 'ping') {
+            return true;
+        }
+        // 检查 pong（心跳响应）
         // data 是 Buffer 对象，需要转换为字符串比较
         // 心跳响应可能是 "pong"（4字节）或 "pong\n"（5字节，带换行符）
         if (data.length === 4) {
@@ -90,7 +95,6 @@ export class TcpWrapper {
     onError;
     /** 连接关闭回调（手动断开或重连失败时触发） */
     onClose;
-    constructor() { }
     /**
      * 设置 Socket 事件监听
      */
@@ -103,6 +107,8 @@ export class TcpWrapper {
             if (this.connectStartTime > 0) {
                 this.connectStartTime = 0; // 重置时间戳
             }
+            // 禁用 Nagle 算法，确保小包立即发送（不延迟合并）
+            this.socket?.setNoDelay(true);
             // 连接成功，重置所有计数器
             this.reconnectAttempts = 0;
             this.heartbeatTimeoutCount = 0;
@@ -121,7 +127,7 @@ export class TcpWrapper {
             }
             this.onData?.(data);
         });
-        this.socket.on('close', (_hadError) => {
+        this.socket.on('close', () => {
             this.clearConnectTimeout();
             this.stopHeartbeat();
             this.cleanup();
@@ -206,7 +212,8 @@ export class TcpWrapper {
             return;
         }
         // 增加重连计数
-        this.reconnectAttempts++;
+        this.reconnectAttempts += 1;
+        // 此时已经通过上面的检查，确保 address、port、connectOptions 都不为 null
         try {
             this.connect(this.address, this.port, this.connectOptions);
         }
@@ -252,7 +259,7 @@ export class TcpWrapper {
             this.clearHeartbeatTimeout();
             this.heartbeatTimeout = setTimeout(() => {
                 if (this.pendingHeartbeat) {
-                    this.heartbeatTimeoutCount++;
+                    this.heartbeatTimeoutCount += 1;
                     // 只有连续2次心跳超时才清理socket
                     if (this.heartbeatTimeoutCount >= 2) {
                         this.connectionActive = false;
@@ -286,48 +293,88 @@ export class TcpWrapper {
     setConnectTimeout() {
         this.clearConnectTimeout();
         this.connectTimeout = setTimeout(() => {
-            if (this.socket && !this.socket.destroyed) {
-                this.handshakeTimeoutAttempts++;
-                // 如果未达到最大尝试次数，重试连接
-                if (this.handshakeTimeoutAttempts < this.maxHandshakeTimeoutAttempts) {
-                    // 清理当前socket
-                    this.socket.destroy();
-                    this.socket = null;
-                    // 计算重试延迟（使用指数退避）
-                    const retryDelay = this.calculateHandshakeRetryInterval();
-                    // 重新尝试连接
-                    if (this.address && this.port && this.connectOptions) {
-                        setTimeout(() => {
-                            if (this.connectionActive && !this.isConnected()) {
-                                try {
-                                    // 重新创建连接
-                                    this.socket = net.createConnection({
-                                        host: this.address,
-                                        port: this.port,
-                                        keepAlive: true,
-                                        keepAliveInitialDelay: 1000,
-                                    });
-                                    // 重新设置超时和事件
-                                    this.setConnectTimeout();
-                                    this.setupSocketEvents();
-                                }
-                                catch (error) {
-                                    this.onError?.(error);
-                                }
-                            }
-                        }, retryDelay);
-                    }
-                }
-                else {
-                    // 超过最大尝试次数，断开连接
-                    this.connectionActive = false;
-                    this.socket.destroy();
-                    this.onError?.(new Error(`Connection timeout after ${this.maxHandshakeTimeoutAttempts} attempts`));
-                    this.onClose?.();
-                }
-            }
+            this.handleHandshakeTimeout();
         }, 1000);
     }
+    /**
+     * 握手超时处理入口
+     * 提取为独立方法以降低 setConnectTimeout 的复杂度
+     */
+    handleHandshakeTimeout() {
+        // socket 已销毁或不存在时无需处理
+        if (!this.socket || this.socket.destroyed) {
+            return;
+        }
+        this.handshakeTimeoutAttempts += 1;
+        if (this.hasRemainingHandshakeAttempts()) {
+            this.retryHandshakeConnection();
+        }
+        else {
+            this.handleHandshakeFailure();
+        }
+    }
+    /**
+     * 是否还有剩余的握手重试次数
+     */
+    hasRemainingHandshakeAttempts() {
+        return this.handshakeTimeoutAttempts < this.maxHandshakeTimeoutAttempts;
+    }
+    /**
+     * 执行握手重试流程：销毁当前 socket、计算重试间隔并尝试重新连接
+     */
+    retryHandshakeConnection() {
+        // 清理当前 socket
+        this.socket?.destroy();
+        this.socket = null;
+        // 计算重试延迟（使用指数退避）
+        const retryDelay = this.calculateHandshakeRetryInterval();
+        // 保存连接信息到局部变量，避免在异步回调中使用可变的实例属性
+        const address = this.address;
+        const port = this.port;
+        const connectOptions = this.connectOptions;
+        if (!address || !port || !connectOptions) {
+            return;
+        }
+        this.scheduleHandshakeReconnect(address, port, retryDelay);
+    }
+    /**
+     * 安排一次新的握手重连尝试
+     */
+    scheduleHandshakeReconnect(address, port, retryDelay) {
+        setTimeout(() => {
+            if (!this.connectionActive || this.isConnected()) {
+                return;
+            }
+            try {
+                this.socket = new net.Socket({
+                    readableHighWaterMark: 1024 * 1024, // 1024KB 读取缓冲区
+                    writableHighWaterMark: 1024 * 1024, // 1024KB 写入缓冲区
+                });
+                // 连接到服务器
+                this.socket.connect({
+                    host: address,
+                    port,
+                    keepAlive: true,
+                    keepAliveInitialDelay: 1000,
+                });
+                // 重新设置超时和事件
+                this.setConnectTimeout();
+                this.setupSocketEvents();
+            }
+            catch (error) {
+                this.onError?.(error);
+            }
+        }, retryDelay);
+    }
+    /**
+     * 握手多次超时后的失败处理
+     */
+    handleHandshakeFailure() {
+        this.connectionActive = false;
+        this.socket?.destroy();
+        this.onError?.(new Error(`Connection timeout after ${this.maxHandshakeTimeoutAttempts} attempts`));
+        this.onClose?.();
+    }
     /**
      * 清除连接超时定时器
      */
@@ -396,12 +443,16 @@ export class TcpWrapper {
         }
         // 记录连接开始时间（用于计算握手时间）
         this.connectStartTime = Date.now();
-        // 创建 TCP 连接
-        this.socket = net.createConnection({
+        this.socket = new net.Socket({
+            readableHighWaterMark: 1024 * 1024, // 1024KB 读取缓冲区
+            writableHighWaterMark: 1024 * 1024, // 1024KB 写入缓冲区
+        });
+        // 连接到服务器
+        this.socket.connect({
             host,
             port,
             keepAlive: true,
-            keepAliveInitialDelay: 1000, // TCP keepalive 初始延迟时间（毫秒）
+            keepAliveInitialDelay: 1000,
         });
         // 设置连接超时（ 1000ms）
         this.setConnectTimeout();
@@ -450,6 +501,12 @@ export class TcpWrapper {
     setHeartbeatResponseChecker(checker) {
         this.heartbeatResponseChecker = checker || ((data) => data.toString() === 'pong');
     }
+    /**
+     * 获取心跳响应识别函数
+     */
+    getHeartbeatResponseChecker() {
+        return this.heartbeatResponseChecker;
+    }
     /**
      * 获取当前连接地址
      */
@@ -469,4 +526,3 @@ export class TcpWrapper {
         return this.reconnectAttempts;
     }
 }
-//# sourceMappingURL=tcpWrapper.js.map

package/dist/packages/tcp/types.d.ts

@@ -229,4 +229,3 @@ export interface DiscoveryServiceOptions {
     /** 服务协议 */
     protocol?: string;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/packages/tcp/types.js

@@ -10,4 +10,3 @@ export var QueueOverflowStrategy;
     /** 拒绝新数据并触发错误 */
     QueueOverflowStrategy["REJECT"] = "reject";
 })(QueueOverflowStrategy || (QueueOverflowStrategy = {}));
-//# sourceMappingURL=types.js.map

package/dist/packages/tcp/utils.d.ts

@@ -11,4 +11,3 @@ export declare function parseHost(url: string): string | null;
  * @param url 连接地址
  */
 export declare function parsePort(url: string): number | null;
-//# sourceMappingURL=utils.d.ts.map

package/dist/packages/tcp/utils.js

@@ -44,4 +44,3 @@ export function parsePort(url) {
         return null;
     }
 }
-//# sourceMappingURL=utils.js.map