stelar-time-real 3.2.1 → 3.3.1

package/src/client.js

@@ -1,19 +1,10 @@
-/**
- * @stelar-time-real Client
- *
- * Dual-environment: Browser (native WebSocket) + Node.js (manual WS or TCP binary).
- * No external dependencies.
- */
+/** @stelar-time-real Client — Browser WS / Node WS / binary TCP */
 import { FrameParser, encodeJsonFrame, encodeBinaryFrame, encodeAckReqFrame, encodePingFrame, encodePongFrame, encodeJoinFrame, encodeLeaveFrame, FRAME_JSON, FRAME_BINARY, FRAME_PING, FRAME_PONG, FRAME_ACK_RES, FRAME_CONNECT, validateEventName, DEFAULT_MAX_FRAME_SIZE, } from './protocol.js';
-import { WSFrameParser, generateWSKey, createWSTextFrameMasked, createWSBinaryFrameMasked, createWSCloseFrameMasked, createWSPongFrameMasked, OP_TEXT, OP_BINARY, OP_CLOSE, OP_PING, OP_PONG, } from './websocket.js';
+import { WSFrameParser, generateWSKey, createWSTextFrameMasked, createWSBinaryFrameMasked, createWSCloseFrameMasked, createWSPongFrameMasked, OP_TEXT, OP_BINARY, OP_CLOSE, OP_PING, OP_PONG, clientWantsCompression, } from './websocket.js';
 import { Logger, NULL_LOGGER } from './logger.js';
 const isNode = typeof process !== 'undefined' && process.versions?.node != null;
-/* Lazy-load Node.js modules so browser builds don't fail */
-let _http = null;
-let _net = null;
-let _tls = null;
-let _https = null;
-async function loadNodeModules() {
+let _http, _net, _tls, _https;
+async function loadModules() {
     if (!_http) {
         _http = await import('http');
         _net = await import('net');
@@ -21,693 +12,529 @@ async function loadNodeModules() {
         _https = await import('https');
     }
 }
-class MessageQueue {
-    constructor(maxSize = 100) {
-        this.queue = [];
-        this.maxSize = maxSize;
-    }
-    push(msg) {
-        if (this.queue.length >= this.maxSize) {
-            this.queue.shift();
-        }
-        this.queue.push(msg);
-        return true;
-    }
-    drain() {
-        const msgs = this.queue;
-        this.queue = [];
-        return msgs;
-    }
-    get length() {
-        return this.queue.length;
-    }
-    clear() {
-        this.queue = [];
+class MsgQueue {
+    constructor(max = 100) {
+        this.max = max;
+        this.q = [];
+    }
+    push(m) { if (this.q.length >= this.max)
+        this.q.shift(); this.q.push(m); return true; }
+    drain() { const m = this.q; this.q = []; return m; }
+    get length() { return this.q.length; }
+    clear() { this.q = []; }
+}
+/** WS binary framing: [4B headerLen BE][header JSON][binary payload] — length-prefixed, not null-delimited */
+function encodeWSBinary(event, data) {
+    const hdr = Buffer.from(JSON.stringify({ event }), 'utf8');
+    const payload = new Uint8Array(data);
+    const frame = Buffer.alloc(4 + hdr.length + payload.length);
+    frame.writeUInt32BE(hdr.length, 0);
+    hdr.copy(frame, 4);
+    frame.set(payload, 4 + hdr.length);
+    return frame;
+}
+function parseWSBinary(payload) {
+    if (payload.length < 4)
+        return null;
+    const hdrLen = payload.readUInt32BE(0);
+    if (hdrLen > payload.length - 4)
+        return null;
+    try {
+        const hdr = JSON.parse(payload.subarray(4, 4 + hdrLen).toString('utf8'));
+        const buf = payload.subarray(4 + hdrLen);
+        return { event: hdr.event, buffer: buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength) };
+    }
+    catch {
+        return null;
     }
 }
 class StelarClient {
-    constructor(urlOrPort = 'localhost:3000', options = {}) {
+    constructor(urlOrPort = 'localhost:3000', o = {}) {
         this.events = new Map();
-        this._wildcardHandler = null;
+        this._wild = null;
         this._acks = new Map();
         this._state = 'disconnected';
-        this._reconnectAttempts = 0;
-        this._hbTimer = null;
-        this._isManualClose = false;
+        this._reconnAttempts = 0;
+        this._hb = null;
+        this._manualClose = false;
         this.id = null;
-        this._reconnectTimer = null;
-        this._messagesSent = 0;
-        this._messagesReceived = 0;
-        this._connectTime = 0;
-        this._lastError = null;
+        this._reconnTimer = null;
+        this._ackCounter = 0;
+        this._sent = 0;
+        this._recv = 0;
+        this._connTime = 0;
+        this._lastErr = null;
         this._ws = null;
-        this._nodeSocket = null;
+        this._nodeSock = null;
         this._wsParser = null;
-        this._tcpSocket = null;
+        this._tcpSock = null;
         this._tcpParser = null;
-        if (typeof urlOrPort === 'number') {
+        this._compress = false;
+        this._serverCompress = false;
+        this._writePaused = false;
+        this._writeQueue = [];
+        if (typeof urlOrPort === 'number')
             this.url = `ws://localhost:${urlOrPort}`;
-        }
-        else if (urlOrPort.includes('://')) {
+        else if (urlOrPort.includes('://'))
             this.url = urlOrPort.startsWith('http') ? 'ws' + urlOrPort.slice(4) : urlOrPort;
-        }
-        else {
+        else
             this.url = `ws://${urlOrPort}`;
-        }
-        this.options = {
-            reconnection: options.reconnection !== false,
-            reconnectionAttempts: options.reconnectionAttempts || 10,
-            reconnectionDelay: options.reconnectionDelay || 1000,
-            maxReconnectionDelay: options.maxReconnectionDelay || 30000,
-            heartbeatInterval: options.heartbeatInterval || 30000,
-            ackTimeout: options.ackTimeout || 5000,
-            mode: options.mode || 'ws',
-            maxPayloadSize: options.maxPayloadSize || 10 * 1024 * 1024,
-            maxFrameSize: options.maxFrameSize || DEFAULT_MAX_FRAME_SIZE,
-            messageQueueSize: options.messageQueueSize || 100,
-            logger: options.logger !== undefined ? options.logger : 'warn',
-            tls: options.tls || false,
-            rejectUnauthorized: options.rejectUnauthorized !== false,
-            headers: options.headers || {},
-            customReconnectDelay: options.customReconnectDelay,
-            hooks: options.hooks || {},
+        this.opts = {
+            reconnection: o.reconnection !== false, reconnectionAttempts: o.reconnectionAttempts || 10,
+            reconnectionDelay: o.reconnectionDelay || 1000, maxReconnectionDelay: o.maxReconnectionDelay || 30000,
+            heartbeatInterval: o.heartbeatInterval || 30000, ackTimeout: o.ackTimeout || 5000,
+            mode: o.mode || 'ws', maxPayloadSize: o.maxPayloadSize || 10 * 1024 * 1024,
+            maxFrameSize: o.maxFrameSize || DEFAULT_MAX_FRAME_SIZE, messageQueueSize: o.messageQueueSize || 100,
+            logger: o.logger !== undefined ? o.logger : 'warn', tls: o.tls || false,
+            rejectUnauthorized: o.rejectUnauthorized !== false, headers: o.headers || {},
+            compression: o.compression || false,
+            customReconnectDelay: o.customReconnectDelay, hooks: o.hooks || {},
         };
-        this._messageQueue = new MessageQueue(this.options.messageQueueSize);
-        if (this.options.logger === false) {
-            this.log = NULL_LOGGER;
-        }
-        else if (this.options.logger instanceof Logger) {
-            this.log = this.options.logger;
-        }
-        else {
-            this.log = new Logger({
-                level: this.options.logger || 'warn',
-                prefix: 'stelar:client',
-            });
-        }
+        this._mq = new MsgQueue(this.opts.messageQueueSize);
+        this.log = o.logger === false ? NULL_LOGGER : o.logger instanceof Logger ? o.logger : new Logger({ level: o.logger || 'warn', prefix: 'stelar:client' });
     }
     getState() { return this._state; }
     getId() { return this.id; }
     getUrl() { return this.url; }
-    getMessagesSent() { return this._messagesSent; }
-    getMessagesReceived() { return this._messagesReceived; }
-    getLastError() { return this._lastError; }
-    getQueueSize() { return this._messageQueue.length; }
-    getConnectTime() { return this._connectTime; }
-    setUrl(url) {
-        this.url = url;
+    getMessagesSent() { return this._sent; }
+    getMessagesReceived() { return this._recv; }
+    getLastError() { return this._lastErr; }
+    getQueueSize() { return this._mq.length; }
+    getConnectTime() { return this._connTime; }
+    setUrl(u) { this.url = u; return this; }
+    updateOptions(o) {
+        for (const k of ['reconnection', 'reconnectionAttempts', 'reconnectionDelay', 'maxReconnectionDelay', 'heartbeatInterval', 'ackTimeout', 'maxPayloadSize', 'maxFrameSize', 'messageQueueSize', 'headers', 'compression'])
+            if (o[k] !== undefined)
+                this.opts[k] = o[k];
+        if (o.customReconnectDelay !== undefined)
+            this.opts.customReconnectDelay = o.customReconnectDelay;
+        if (o.hooks !== undefined)
+            this.opts.hooks = { ...this.opts.hooks, ...o.hooks };
         return this;
     }
-    /** Update client options at runtime. Changes take effect immediately. */
-    updateOptions(options) {
-        if (options.reconnection !== undefined)
-            this.options.reconnection = options.reconnection;
-        if (options.reconnectionAttempts !== undefined)
-            this.options.reconnectionAttempts = options.reconnectionAttempts;
-        if (options.reconnectionDelay !== undefined)
-            this.options.reconnectionDelay = options.reconnectionDelay;
-        if (options.maxReconnectionDelay !== undefined)
-            this.options.maxReconnectionDelay = options.maxReconnectionDelay;
-        if (options.heartbeatInterval !== undefined)
-            this.options.heartbeatInterval = options.heartbeatInterval;
-        if (options.ackTimeout !== undefined)
-            this.options.ackTimeout = options.ackTimeout;
-        if (options.maxPayloadSize !== undefined)
-            this.options.maxPayloadSize = options.maxPayloadSize;
-        if (options.maxFrameSize !== undefined)
-            this.options.maxFrameSize = options.maxFrameSize;
-        if (options.messageQueueSize !== undefined)
-            this.options.messageQueueSize = options.messageQueueSize;
-        if (options.headers !== undefined)
-            this.options.headers = options.headers;
-        if (options.customReconnectDelay !== undefined)
-            this.options.customReconnectDelay = options.customReconnectDelay;
-        if (options.hooks !== undefined)
-            this.options.hooks = { ...this.options.hooks, ...options.hooks };
-        return this;
-    }
-    /** Read-only snapshot of current client options. */
     getOptions() {
         return Object.freeze({
-            reconnection: this.options.reconnection,
-            reconnectionAttempts: this.options.reconnectionAttempts,
-            reconnectionDelay: this.options.reconnectionDelay,
-            maxReconnectionDelay: this.options.maxReconnectionDelay,
-            heartbeatInterval: this.options.heartbeatInterval,
-            ackTimeout: this.options.ackTimeout,
-            mode: this.options.mode,
-            maxPayloadSize: this.options.maxPayloadSize,
-            messageQueueSize: this.options.messageQueueSize,
-            hasCustomReconnectDelay: !!this.options.customReconnectDelay,
-            hooks: Object.keys(this.options.hooks),
+            reconnection: this.opts.reconnection, reconnectionAttempts: this.opts.reconnectionAttempts,
+            reconnectionDelay: this.opts.reconnectionDelay, maxReconnectionDelay: this.opts.maxReconnectionDelay,
+            heartbeatInterval: this.opts.heartbeatInterval, ackTimeout: this.opts.ackTimeout, mode: this.opts.mode,
+            maxPayloadSize: this.opts.maxPayloadSize, messageQueueSize: this.opts.messageQueueSize,
+            compression: this.opts.compression,
+            hasCustomReconnectDelay: !!this.opts.customReconnectDelay, hooks: Object.keys(this.opts.hooks),
         });
     }
-    on(event, handler) {
-        this.events.set(event, handler);
-        return this;
-    }
-    off(event, handler) {
-        if (this.events.get(event) === handler) {
-            this.events.delete(event);
-        }
-        return this;
-    }
-    once(event, handler) {
-        const wrapped = (data) => {
-            this.off(event, wrapped);
-            handler(data);
-        };
-        this.on(event, wrapped);
-        return this;
-    }
-    onAll(handler) {
-        this._wildcardHandler = handler;
-        return this;
-    }
-    onAck(name, handler) {
-        this._acks.set(name, { handler, timer: null });
-        return this;
-    }
-    removeAllListeners(event) {
-        if (event) {
-            this.events.delete(event);
-        }
-        else {
-            this.events.clear();
-        }
-        return this;
-    }
+    on(ev, h) { this.events.set(ev, h); return this; }
+    off(ev, h) { if (this.events.get(ev) === h)
+        this.events.delete(ev); return this; }
+    once(ev, h) { const w = (d) => { this.off(ev, w); h(d); }; this.on(ev, w); return this; }
+    onAll(h) { this._wild = h; return this; }
+    onAck(name, h) { this._acks.set(name, { handler: h, timer: null }); return this; }
+    removeAllListeners(ev) { ev ? this.events.delete(ev) : this.events.clear(); return this; }
     emit(event, data, opts = {}) {
         try {
             if (event)
                 validateEventName(event);
         }
         catch {
-            this.log.warn('Invalid event name', { event });
+            this.log.warn('Invalid event', { event });
             return this;
         }
-        if (this.options.hooks.onBeforeEmit) {
-            const result = this.options.hooks.onBeforeEmit({ event, data });
-            if (result === false)
-                return this;
-        }
+        if (this.opts.hooks.onBeforeEmit?.({ event, data }) === false)
+            return this;
         try {
-            const serialized = JSON.stringify(data);
-            if (serialized.length > this.options.maxPayloadSize) {
-                this.log.warn('Payload exceeds max size', { event, size: serialized.length });
+            const s = JSON.stringify(data);
+            if (s.length > this.opts.maxPayloadSize) {
+                this.log.warn('Payload too large', { event });
                 return this;
             }
         }
         catch {
-            this.log.warn('Failed to serialize data', { event });
             return this;
         }
         if (this._state !== 'connected') {
-            if (this.options.reconnection) {
-                this._messageQueue.push({ event, data, opts, timestamp: Date.now() });
-                this.log.debug('Message queued', { event, queueSize: this._messageQueue.length });
-                if (this.options.hooks.onMessageQueued) {
-                    this.options.hooks.onMessageQueued({ event, data, queueSize: this._messageQueue.length });
-                }
+            if (this.opts.reconnection) {
+                this._mq.push({ event, data, opts, ts: Date.now() });
+                this.opts.hooks.onMessageQueued?.({ event, data, queueSize: this._mq.length });
             }
             return this;
         }
         try {
-            if (this.options.mode === 'tcp' && this._tcpSocket && !this._tcpSocket.destroyed) {
-                if (opts.ack) {
-                    this._tcpSocket.write(encodeAckReqFrame(opts.ack, { event, data }, this.options.maxFrameSize));
-                }
+            const send = (wsPayload, tcpPayload) => {
+                if (this.opts.mode === 'tcp' && this._tcpSock && !this._tcpSock.destroyed)
+                    this._writeTCP(tcpPayload());
+                else if (this._nodeSock && !this._nodeSock.destroyed)
+                    this._writeNodeWS(wsPayload());
+                else if (this._ws && this._ws.readyState === WebSocket.OPEN)
+                    this._ws.send(JSON.stringify({ event, data, ...(opts.ack ? { _ackName: opts.ack } : {}), ...(opts._correlationId ? { _correlationId: opts._correlationId } : {}) }));
                 else {
-                    this._tcpSocket.write(encodeJsonFrame(event, data, this.options.maxFrameSize));
+                    this._mq.push({ event, data, opts, ts: Date.now() });
+                    return;
                 }
-            }
-            else if (this._nodeSocket && !this._nodeSocket.destroyed) {
-                const payload = { event, data };
-                if (opts.ack)
-                    payload._ackName = opts.ack;
-                this._nodeSocket.write(createWSTextFrameMasked(JSON.stringify(payload)));
-            }
-            else if (this._ws && this._ws.readyState === WebSocket.OPEN) {
-                const payload = { event, data };
-                if (opts.ack)
-                    payload._ackName = opts.ack;
-                this._ws.send(JSON.stringify(payload));
+                this._sent++;
+            };
+            if (opts.ack) {
+                send(() => { const p = { event, data, _ackName: opts.ack }; if (opts._correlationId)
+                    p._correlationId = opts._correlationId; return createWSTextFrameMasked(JSON.stringify(p), this._compress); }, () => { const d = { event, data }; if (opts._correlationId)
+                    d._correlationId = opts._correlationId; return encodeAckReqFrame(opts.ack, d, this.opts.maxFrameSize); });
             }
             else {
-                this._messageQueue.push({ event, data, opts, timestamp: Date.now() });
-                return this;
+                send(() => { const p = { event, data }; if (opts._correlationId)
+                    p._correlationId = opts._correlationId; return createWSTextFrameMasked(JSON.stringify(p), this._compress); }, () => encodeJsonFrame(event, data, this.opts.maxFrameSize));
             }
-            this._messagesSent++;
         }
-        catch (err) {
-            this.log.error('Emit error', { event, error: String(err) });
-            if (this.options.hooks.onError) {
-                this.options.hooks.onError({ error: err instanceof Error ? err : new Error(String(err)), context: 'emit' });
-            }
-            this._messageQueue.push({ event, data, opts, timestamp: Date.now() });
+        catch (e) {
+            this.log.error('Emit error', { event, error: String(e) });
+            this.opts.hooks.onError?.({ error: e instanceof Error ? e : new Error(String(e)), context: 'emit' });
+            this._mq.push({ event, data, opts, ts: Date.now() });
         }
         return this;
     }
     emitBinary(event, data) {
-        if (data.byteLength > this.options.maxPayloadSize) {
-            this.log.warn('Binary payload exceeds max size', { event, size: data.byteLength });
+        if (data.byteLength > this.opts.maxPayloadSize) {
+            this.log.warn('Binary too large', { event });
             return this;
         }
-        if (this.options.hooks.onBeforeEmit) {
-            const result = this.options.hooks.onBeforeEmit({ event, data });
-            if (result === false)
-                return this;
-        }
+        if (this.opts.hooks.onBeforeEmit?.({ event, data }) === false)
+            return this;
         if (this._state !== 'connected')
             return this;
         try {
-            if (this.options.mode === 'tcp' && this._tcpSocket && !this._tcpSocket.destroyed) {
-                this._tcpSocket.write(encodeBinaryFrame(event, new Uint8Array(data), this.options.maxFrameSize));
+            const safeCopy = Buffer.from(new Uint8Array(data));
+            if (this.opts.mode === 'tcp' && this._tcpSock && !this._tcpSock.destroyed) {
+                this._writeTCP(encodeBinaryFrame(event, safeCopy, this.opts.maxFrameSize));
             }
-            else if (this._nodeSocket && !this._nodeSocket.destroyed) {
-                const header = JSON.stringify({ event });
-                const headerBytes = Buffer.from(header, 'utf8');
-                const combined = Buffer.alloc(headerBytes.length + 1 + data.byteLength);
-                headerBytes.copy(combined, 0);
-                combined[headerBytes.length] = 0;
-                combined.set(new Uint8Array(data), headerBytes.length + 1);
-                this._nodeSocket.write(createWSBinaryFrameMasked(combined));
+            else if (this._nodeSock && !this._nodeSock.destroyed) {
+                this._writeNodeWS(createWSBinaryFrameMasked(encodeWSBinary(event, safeCopy)));
             }
             else if (this._ws && this._ws.readyState === WebSocket.OPEN) {
-                const header = JSON.stringify({ event });
-                const headerBytes = new TextEncoder().encode(header);
-                const combined = new Uint8Array(headerBytes.length + 1 + data.byteLength);
-                combined.set(headerBytes, 0);
-                combined[headerBytes.length] = 0;
-                combined.set(new Uint8Array(data), headerBytes.length + 1);
-                this._ws.send(combined);
+                const frame = encodeWSBinary(event, safeCopy);
+                this._ws.send(frame);
             }
-            this._messagesSent++;
+            this._sent++;
         }
-        catch (err) {
-            this.log.error('Binary emit error', { event, error: String(err) });
-            if (this.options.hooks.onError) {
-                this.options.hooks.onError({ error: err instanceof Error ? err : new Error(String(err)), context: 'emitBinary' });
-            }
+        catch (e) {
+            this.log.error('Binary emit error', { event, error: String(e) });
         }
         return this;
     }
-    sendFile(file) {
-        return this.emitBinary('file', file);
-    }
-    sendImage(blob) {
-        return this.emitBinary('image', blob);
-    }
-    /** Send a request and wait for an ACK response. Rejects on timeout. */
+    sendFile(f) { return this.emitBinary('file', f); }
+    sendImage(b) { return this.emitBinary('image', b); }
     request(event, data, ackName) {
         return new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                this._acks.delete(ackName);
-                reject(new Error(`ACK '${ackName}' timeout after ${this.options.ackTimeout}ms`));
-            }, this.options.ackTimeout);
-            timeout.unref();
-            const handler = (responseData) => {
-                clearTimeout(timeout);
-                this._acks.delete(ackName);
-                resolve(responseData);
-            };
-            this._acks.set(ackName, { handler, timer: timeout });
-            this.emit(event, data, { ack: ackName });
+            const corrId = `${ackName}#${++this._ackCounter}`;
+            const t = setTimeout(() => { this._acks.delete(corrId); reject(new Error(`ACK '${ackName}' timeout`)); }, this.opts.ackTimeout);
+            t.unref();
+            this._acks.set(corrId, { handler: (d) => { clearTimeout(t); this._acks.delete(corrId); resolve(d); }, timer: t });
+            this.emit(event, data, { ack: ackName, _correlationId: corrId });
         });
     }
     joinRoom(room) {
-        if (this.options.mode === 'tcp' && this._tcpSocket && !this._tcpSocket.destroyed) {
+        if (this.opts.mode === 'tcp' && this._tcpSock && !this._tcpSock.destroyed)
             try {
-                this._tcpSocket.write(encodeJoinFrame(room, this.options.maxFrameSize));
+                this._tcpSock.write(encodeJoinFrame(room, this.opts.maxFrameSize));
             }
             catch { }
-        }
-        else {
+        else
             this.emit('join-room', room);
-        }
         return this;
     }
     leaveRoom(room) {
-        if (this.options.mode === 'tcp' && this._tcpSocket && !this._tcpSocket.destroyed) {
+        if (this.opts.mode === 'tcp' && this._tcpSock && !this._tcpSock.destroyed)
             try {
-                this._tcpSocket.write(encodeLeaveFrame(room));
+                this._tcpSock.write(encodeLeaveFrame(room));
             }
             catch { }
-        }
-        else {
+        else
             this.emit('leave-room', room);
+        return this;
+    }
+    connect(cb) {
+        if (this._state === 'connected' || this._state === 'connecting')
+            return this;
+        if (this._state === 'reconnecting' && this._reconnTimer) {
+            clearTimeout(this._reconnTimer);
+            this._reconnTimer = null;
+        }
+        this._manualClose = false;
+        this._setState('connecting');
+        if (this.opts.mode === 'tcp' && isNode)
+            this._connectTCP();
+        else if (isNode)
+            this._connectNodeWS();
+        else
+            this._connectBrowser();
+        if (cb) {
+            const check = setInterval(() => { if (this._state === 'connected') {
+                clearInterval(check);
+                cb();
+            } }, 50);
+            const safety = setTimeout(() => clearInterval(check), this.opts.ackTimeout);
+            safety.unref();
         }
         return this;
     }
-    startHeartbeat() {
-        this.stopHeartbeat();
-        this._hbTimer = setInterval(() => {
-            if (this.options.mode === 'tcp' && this._tcpSocket && !this._tcpSocket.destroyed) {
-                try {
-                    this._tcpSocket.write(encodePingFrame());
-                }
-                catch { }
+    disconnect() {
+        this._manualClose = true;
+        if (this._tcpSock && !this._tcpSock.destroyed)
+            try {
+                this._tcpSock.destroy();
             }
-            else if (this._nodeSocket && !this._nodeSocket.destroyed) {
-                try {
-                    this._nodeSocket.write(createWSTextFrameMasked(JSON.stringify({ event: 'pong', data: Date.now() })));
-                }
-                catch { }
+            catch { }
+        if (this._nodeSock && !this._nodeSock.destroyed) {
+            try {
+                this._nodeSock.write(createWSCloseFrameMasked());
             }
-            else if (this._ws && this._ws.readyState === WebSocket.OPEN) {
-                this._ws.send(JSON.stringify({ event: 'pong', data: Date.now() }));
+            catch { }
+            try {
+                this._nodeSock.end();
             }
-        }, this.options.heartbeatInterval);
-        if (this._hbTimer && typeof this._hbTimer === 'object' && 'unref' in this._hbTimer) {
-            this._hbTimer.unref();
+            catch { }
         }
+        if (this._ws)
+            try {
+                this._ws.close();
+            }
+            catch { }
+        this._fullCleanup();
+        this._setState('disconnected');
+        return this;
     }
-    stopHeartbeat() {
-        if (this._hbTimer) {
-            clearInterval(this._hbTimer);
-            this._hbTimer = null;
+    isConnected() { return this._state === 'connected'; }
+    /* ── Private ── */
+    _setState(s) {
+        const prev = this._state;
+        this._state = s;
+        if (prev !== s) {
+            this.log.debug('State', { from: prev, to: s });
+            this.opts.hooks.onStateChange?.({ from: prev, to: s });
         }
     }
-    _getReconnectDelay() {
-        const base = this.options.reconnectionDelay;
-        const max = this.options.maxReconnectionDelay;
-        if (this.options.hooks.onReconnectDelay) {
-            const defaultDelay = Math.min(base * Math.pow(1.5, this._reconnectAttempts - 1), max);
-            const customDelay = this.options.hooks.onReconnectDelay({ attempt: this._reconnectAttempts, defaultDelay });
-            if (typeof customDelay === 'number')
-                return customDelay;
-        }
-        if (this.options.customReconnectDelay) {
-            return this.options.customReconnectDelay(this._reconnectAttempts, base, max);
-        }
-        const delay = Math.min(base * Math.pow(1.5, this._reconnectAttempts - 1), max);
-        const jitter = delay * 0.2 * Math.random();
-        return Math.floor(delay + jitter);
-    }
-    _drainQueue() {
-        if (this._messageQueue.length === 0)
+    _startHB() {
+        this._stopHB();
+        this._hb = setInterval(() => {
+            if (this.opts.mode === 'tcp' && this._tcpSock && !this._tcpSock.destroyed)
+                try {
+                    this._tcpSock.write(encodePingFrame());
+                }
+                catch { }
+            else if (this._nodeSock && !this._nodeSock.destroyed)
+                try {
+                    this._nodeSock.write(createWSTextFrameMasked(JSON.stringify({ event: 'pong', data: Date.now() }), this._compress));
+                }
+                catch { }
+            else if (this._ws && this._ws.readyState === WebSocket.OPEN)
+                this._ws.send(JSON.stringify({ event: 'pong', data: Date.now() }));
+        }, this.opts.heartbeatInterval);
+        this._hb?.unref?.();
+    }
+    _stopHB() { if (this._hb) {
+        clearInterval(this._hb);
+        this._hb = null;
+    } }
+    _getDelay() {
+        const base = this.opts.reconnectionDelay, max = this.opts.maxReconnectionDelay;
+        const def = Math.min(base * Math.pow(1.5, this._reconnAttempts - 1), max);
+        const custom = this.opts.hooks.onReconnectDelay?.({ attempt: this._reconnAttempts, defaultDelay: def });
+        if (typeof custom === 'number')
+            return custom;
+        if (this.opts.customReconnectDelay)
+            return this.opts.customReconnectDelay(this._reconnAttempts, base, max);
+        return Math.floor(def + def * 0.2 * Math.random());
+    }
+    _drain() {
+        if (!this._mq.length)
             return;
-        const messages = this._messageQueue.drain();
-        this.log.info('Draining message queue', { count: messages.length });
-        for (const msg of messages) {
+        const msgs = this._mq.drain();
+        this.log.info('Draining queue', { count: msgs.length });
+        for (const m of msgs) {
             try {
-                if (this.options.mode === 'tcp' && this._tcpSocket && !this._tcpSocket.destroyed) {
-                    if (msg.opts.ack) {
-                        this._tcpSocket.write(encodeAckReqFrame(msg.opts.ack, { event: msg.event, data: msg.data }, this.options.maxFrameSize));
-                    }
-                    else {
-                        this._tcpSocket.write(encodeJsonFrame(msg.event, msg.data, this.options.maxFrameSize));
-                    }
+                const p = { event: m.event, data: m.data };
+                if (m.opts.ack)
+                    p._ackName = m.opts.ack;
+                if (m.opts._correlationId)
+                    p._correlationId = m.opts._correlationId;
+                if (this.opts.mode === 'tcp' && this._tcpSock && !this._tcpSock.destroyed) {
+                    this._tcpSock.write(m.opts.ack ? encodeAckReqFrame(m.opts.ack, p, this.opts.maxFrameSize) : encodeJsonFrame(m.event, m.data, this.opts.maxFrameSize));
                 }
-                else if (this._nodeSocket && !this._nodeSocket.destroyed) {
-                    const payload = { event: msg.event, data: msg.data };
-                    if (msg.opts.ack)
-                        payload._ackName = msg.opts.ack;
-                    this._nodeSocket.write(createWSTextFrameMasked(JSON.stringify(payload)));
+                else if (this._nodeSock && !this._nodeSock.destroyed) {
+                    this._nodeSock.write(createWSTextFrameMasked(JSON.stringify(p), this._compress));
                 }
                 else if (this._ws && this._ws.readyState === WebSocket.OPEN) {
-                    const payload = { event: msg.event, data: msg.data };
-                    if (msg.opts.ack)
-                        payload._ackName = msg.opts.ack;
-                    this._ws.send(JSON.stringify(payload));
+                    this._ws.send(JSON.stringify(p));
                 }
-                this._messagesSent++;
+                this._sent++;
             }
-            catch (err) {
-                this.log.error('Queue drain error', { event: msg.event, error: String(err) });
-            }
-        }
-        if (this.options.hooks.onQueueDrained) {
-            this.options.hooks.onQueueDrained({ count: messages.length });
-        }
-    }
-    _setState(state) {
-        const prev = this._state;
-        this._state = state;
-        if (prev !== state) {
-            this.log.debug('State changed', { from: prev, to: state });
-            if (this.options.hooks.onStateChange) {
-                this.options.hooks.onStateChange({ from: prev, to: state });
+            catch (e) {
+                this.log.error('Drain error', { event: m.event, error: String(e) });
             }
         }
+        this.opts.hooks.onQueueDrained?.({ count: msgs.length });
     }
-    _cleanupAcks() {
-        for (const [, entry] of this._acks) {
-            if (entry.timer)
-                clearTimeout(entry.timer);
-        }
-        this._acks.clear();
-    }
+    _cleanupAcks() { for (const [, e] of this._acks)
+        if (e.timer)
+            clearTimeout(e.timer); this._acks.clear(); }
     _fullCleanup() {
-        this.stopHeartbeat();
+        this._stopHB();
         this._cleanupAcks();
-        if (this._reconnectTimer) {
-            clearTimeout(this._reconnectTimer);
-            this._reconnectTimer = null;
+        if (this._reconnTimer) {
+            clearTimeout(this._reconnTimer);
+            this._reconnTimer = null;
         }
-        this._nodeSocket = null;
+        this._nodeSock = null;
         this._wsParser = null;
-        this._tcpSocket = null;
+        this._tcpSock = null;
         this._tcpParser = null;
         this._ws = null;
+        this._writePaused = false;
+        this._writeQueue = [];
     }
-    connect(callback) {
-        if (this._state === 'connected' || this._state === 'connecting') {
-            return this;
-        }
-        if (this._state === 'reconnecting' && this._reconnectTimer) {
-            clearTimeout(this._reconnectTimer);
-            this._reconnectTimer = null;
-        }
-        this._isManualClose = false;
-        this._setState('connecting');
-        if (this.options.mode === 'tcp' && isNode) {
-            this._connectTCP();
-        }
-        else if (isNode) {
-            this._connectNodeWS();
-        }
-        else {
-            this._connectBrowser();
+    _tryReconnect(fn) {
+        if (this._manualClose || !this.opts.reconnection)
+            return;
+        if (this._reconnAttempts >= this.opts.reconnectionAttempts) {
+            this.log.warn('Max reconnect attempts');
+            this.events.get('reconnect_failed')?.(undefined);
+            return;
         }
-        if (callback) {
-            const check = setInterval(() => {
-                if (this._state === 'connected') {
-                    clearInterval(check);
-                    callback();
-                }
-            }, 50);
-            const safetyTimeout = setTimeout(() => clearInterval(check), this.options.ackTimeout);
-            safetyTimeout.unref();
+        this._reconnAttempts++;
+        this._setState('reconnecting');
+        const delay = this._getDelay();
+        this.log.info('Reconnecting', { attempt: this._reconnAttempts, delay });
+        this.events.get('reconnecting')?.(this._reconnAttempts);
+        this._reconnTimer = setTimeout(() => { this._reconnTimer = null; if (!this._manualClose)
+            fn(); }, delay);
+    }
+    _onConnected() {
+        this._setState('connected');
+        this._reconnAttempts = 0;
+        this._connTime = Date.now();
+        this.events.get('connect')?.(undefined);
+        this._startHB();
+        this._drain();
+    }
+    /* ── Backpressure-aware writes ── */
+    _writeTCP(buf) {
+        if (!this._tcpSock || this._tcpSock.destroyed)
+            return;
+        if (this._writePaused) {
+            this._writeQueue.push(buf);
+            return;
         }
-        return this;
+        const ok = this._tcpSock.write(buf);
+        if (!ok)
+            this._writePaused = true;
     }
-    disconnect() {
-        this._isManualClose = true;
-        if (this._tcpSocket && !this._tcpSocket.destroyed) {
-            try {
-                this._tcpSocket.destroy();
-            }
-            catch { }
-        }
-        if (this._nodeSocket && !this._nodeSocket.destroyed) {
-            try {
-                this._nodeSocket.write(createWSCloseFrameMasked());
-            }
-            catch { }
-            try {
-                this._nodeSocket.end();
-            }
-            catch { }
+    _writeNodeWS(buf) {
+        if (!this._nodeSock || this._nodeSock.destroyed)
+            return;
+        if (this._writePaused) {
+            this._writeQueue.push(buf);
+            return;
         }
-        if (this._ws) {
-            try {
-                this._ws.close();
+        const ok = this._nodeSock.write(buf);
+        if (!ok)
+            this._writePaused = true;
+    }
+    _flushQueue() {
+        this._writePaused = false;
+        while (this._writeQueue.length) {
+            const buf = this._writeQueue.shift();
+            const sock = this.opts.mode === 'tcp' ? this._tcpSock : this._nodeSock;
+            if (sock && !sock.destroyed) {
+                const ok = sock.write(buf);
+                if (!ok) {
+                    this._writePaused = true;
+                    break;
+                }
             }
-            catch { }
         }
-        this._fullCleanup();
-        this._setState('disconnected');
-        return this;
-    }
-    isConnected() {
-        return this._state === 'connected';
     }
+    /* ── Browser WS ── */
     _connectBrowser() {
         try {
             const ws = new WebSocket(this.url);
             ws.binaryType = 'arraybuffer';
-            ws.onopen = () => {
-                this._setState('connected');
-                this._reconnectAttempts = 0;
-                this._connectTime = Date.now();
-                this.log.info('Browser WS connected');
-                const handler = this.events.get('connect');
-                if (handler)
-                    handler(undefined);
-                this.startHeartbeat();
-                this._drainQueue();
-            };
-            ws.onmessage = (e) => {
-                this._messagesReceived++;
-                this._handleBrowserMessage(e);
-            };
-            ws.onclose = (e) => {
-                this._setState('disconnected');
-                this._fullCleanup();
-                const handler = this.events.get('disconnect');
-                if (handler)
-                    handler({ code: e.code, reason: e.reason });
-                this._tryReconnect(() => this._connectBrowser());
-            };
-            ws.onerror = () => {
-                this._lastError = new Error('WebSocket error');
-                const handler = this.events.get('error');
-                if (handler)
-                    handler(this._lastError);
-                if (this.options.hooks.onError) {
-                    this.options.hooks.onError({ error: this._lastError, context: 'browser-ws' });
-                }
-            };
+            ws.onopen = () => this._onConnected();
+            ws.onmessage = (e) => { this._recv++; this._handleBrowserMsg(e); };
+            ws.onclose = (e) => { this._setState('disconnected'); this._fullCleanup(); this.events.get('disconnect')?.({ code: e.code, reason: e.reason }); this._tryReconnect(() => this._connectBrowser()); };
+            ws.onerror = () => { this._lastErr = new Error('WebSocket error'); this.events.get('error')?.(this._lastErr); this.opts.hooks.onError?.({ error: this._lastErr, context: 'browser-ws' }); };
             this._ws = ws;
         }
-        catch (err) {
-            this._lastError = err instanceof Error ? err : new Error(String(err));
+        catch (e) {
+            this._lastErr = e instanceof Error ? e : new Error(String(e));
             this._setState('disconnected');
             this._tryReconnect(() => this._connectBrowser());
         }
     }
-    _handleBrowserMessage(e) {
+    _handleBrowserMsg(e) {
         try {
             if (e.data instanceof ArrayBuffer) {
-                const view = new Uint8Array(e.data);
-                let headerEnd = -1;
-                for (let i = 0; i < view.length; i++) {
-                    if (view[i] === 0) {
-                        headerEnd = i;
-                        break;
-                    }
-                }
-                if (headerEnd === -1)
+                const buf = Buffer.from(e.data);
+                const parsed = parseWSBinary(buf);
+                if (!parsed)
                     return;
-                const headerStr = new TextDecoder().decode(view.slice(0, headerEnd));
-                const header = JSON.parse(headerStr);
-                const buffer = view.slice(headerEnd + 1).buffer;
-                if (this.options.hooks.onMessage) {
-                    this.options.hooks.onMessage({ event: header.event, data: buffer, isBinary: true });
-                }
-                const handler = this.events.get(header.event);
-                if (handler)
-                    handler(buffer);
-                if (this._wildcardHandler) {
-                    this._wildcardHandler({ event: header.event, data: buffer, isBinary: true, buffer });
-                }
+                this.opts.hooks.onMessage?.({ event: parsed.event, data: parsed.buffer, isBinary: true });
+                this.events.get(parsed.event)?.(parsed.buffer);
+                this._wild?.({ event: parsed.event, data: parsed.buffer, isBinary: true, buffer: parsed.buffer });
                 return;
             }
-            const msg = JSON.parse(e.data);
-            const { event, data, _isAck } = msg;
+            const msg = JSON.parse(e.data), { event, data, _isAck } = msg;
             if (event === 'ping')
                 return;
-            if (this.options.hooks.onMessage) {
-                this.options.hooks.onMessage({ event, data, isBinary: false });
-            }
-            if (_isAck && this._acks.has(event)) {
-                const entry = this._acks.get(event);
-                if (entry.timer)
-                    clearTimeout(entry.timer);
-                this._acks.delete(event);
-                entry.handler(data);
-                return;
+            this.opts.hooks.onMessage?.({ event, data, isBinary: false });
+            if (_isAck) {
+                const key = msg._correlationId || event;
+                if (this._acks.has(key)) {
+                    const entry = this._acks.get(key);
+                    if (entry.timer)
+                        clearTimeout(entry.timer);
+                    this._acks.delete(key);
+                    entry.handler(data);
+                    return;
+                }
             }
-            const handler = this.events.get(event);
-            if (handler)
-                handler(data);
-            if (this._wildcardHandler)
-                this._wildcardHandler({ event, data });
+            this.events.get(event)?.(data);
+            this._wild?.({ event, data });
         }
         catch { }
     }
+    /* ── Node WS ── */
     async _connectNodeWS() {
         try {
-            await loadNodeModules();
+            await loadModules();
             if (!_http)
                 return;
-            const parsed = new URL(this.url);
-            const isSecure = parsed.protocol === 'wss:' || this.options.tls;
+            const parsed = new URL(this.url), secure = parsed.protocol === 'wss:' || this.opts.tls;
             const key = generateWSKey();
-            const requestHeaders = {
-                'Upgrade': 'websocket',
-                'Connection': 'Upgrade',
-                'Sec-WebSocket-Key': key,
-                'Sec-WebSocket-Version': '13',
-                ...this.options.headers,
-            };
-            const reqModule = isSecure && _https ? _https : _http;
-            const req = reqModule.request({
-                hostname: parsed.hostname,
-                port: parseInt(parsed.port) || (isSecure ? 443 : 80),
-                path: parsed.pathname + parsed.search,
-                method: 'GET',
-                headers: requestHeaders,
-                rejectUnauthorized: this.options.rejectUnauthorized,
-            });
-            req.setTimeout(this.options.ackTimeout, () => {
-                req.destroy(new Error('Connection timeout'));
-            });
-            req.on('upgrade', (_res, socket, head) => {
-                this._nodeSocket = socket;
-                this._wsParser = new WSFrameParser(this.options.maxFrameSize);
-                if (head.length > 0) {
-                    this._processNodeWSData(head);
-                }
-                socket.on('data', (data) => {
-                    this._processNodeWSData(data);
-                });
-                socket.on('close', () => {
-                    this._setState('disconnected');
-                    this._fullCleanup();
-                    const handler = this.events.get('disconnect');
-                    if (handler)
-                        handler(undefined);
-                    this._tryReconnect(() => this._connectNodeWS());
-                });
-                socket.on('error', (err) => {
-                    this._lastError = err;
-                    const handler = this.events.get('error');
-                    if (handler)
-                        handler(err);
-                    if (this.options.hooks.onError) {
-                        this.options.hooks.onError({ error: err, context: 'node-ws' });
-                    }
-                });
-                socket.on('drain', () => {
-                    socket.resume();
-                });
-                this._setState('connected');
-                this._reconnectAttempts = 0;
-                this._connectTime = Date.now();
-                this.log.info('Node.js WS connected', { secure: isSecure });
-                const connectHandler = this.events.get('connect');
-                if (connectHandler)
-                    connectHandler(undefined);
-                this.startHeartbeat();
-                this._drainQueue();
-            });
-            req.on('error', (err) => {
-                this._lastError = err;
-                const handler = this.events.get('error');
-                if (handler)
-                    handler(err);
-                this._tryReconnect(() => this._connectNodeWS());
+            const hdrs = { Upgrade: 'websocket', Connection: 'Upgrade', 'Sec-WebSocket-Key': key, 'Sec-WebSocket-Version': '13', ...this.opts.headers };
+            if (this.opts.compression)
+                hdrs['Sec-WebSocket-Extensions'] = 'permessage-deflate; client_no_context_takeover; server_no_context_takeover';
+            const mod = secure && _https ? _https : _http;
+            const req = mod.request({ hostname: parsed.hostname, port: parseInt(parsed.port) || (secure ? 443 : 80), path: parsed.pathname + parsed.search, method: 'GET', headers: hdrs, rejectUnauthorized: this.opts.rejectUnauthorized });
+            req.setTimeout(this.opts.ackTimeout, () => req.destroy(new Error('Timeout')));
+            req.on('upgrade', (res, socket, head) => {
+                const extHeader = res.headers['sec-websocket-extensions'];
+                this._serverCompress = this.opts.compression && !!extHeader && clientWantsCompression(extHeader);
+                this._compress = this._serverCompress;
+                this._nodeSock = socket;
+                this._wsParser = new WSFrameParser(this.opts.maxFrameSize);
+                if (head.length > 0)
+                    this._processNodeWS(head);
+                socket.on('data', (d) => this._processNodeWS(d));
+                socket.on('close', () => { this._setState('disconnected'); this._fullCleanup(); this.events.get('disconnect')?.(undefined); this._tryReconnect(() => this._connectNodeWS()); });
+                socket.on('error', (e) => { this._lastErr = e; this.events.get('error')?.(e); this.opts.hooks.onError?.({ error: e, context: 'node-ws' }); });
+                socket.on('drain', () => this._flushQueue());
+                this.log.info('Node WS connected', { secure, compressed: this._compress });
+                this._onConnected();
             });
+            req.on('error', (e) => { this._lastErr = e; this.events.get('error')?.(e); this._tryReconnect(() => this._connectNodeWS()); });
             req.end();
         }
-        catch (err) {
-            this._lastError = err instanceof Error ? err : new Error(String(err));
+        catch (e) {
+            this._lastErr = e instanceof Error ? e : new Error(String(e));
             this._tryReconnect(() => this._connectNodeWS());
         }
     }
-    _processNodeWSData(data) {
+    _processNodeWS(data) {
         if (!this._wsParser)
             return;
         let frames;
@@ -715,175 +542,106 @@ class StelarClient {
             frames = this._wsParser.feed(data);
         }
         catch {
-            this.log.error('WS frame parse error');
+            this.log.error('WS parse error');
             return;
         }
-        for (const frame of frames) {
-            this._messagesReceived++;
-            this._handleNodeWSFrame(frame);
+        for (const f of frames) {
+            this._recv++;
+            this._handleNodeFrame(f);
         }
     }
-    _handleNodeWSFrame(frame) {
-        const { opcode, payload } = frame;
-        if (opcode === OP_PING) {
-            if (this._nodeSocket && !this._nodeSocket.destroyed) {
+    _handleNodeFrame(f) {
+        if (f.opcode === OP_PING) {
+            if (this._nodeSock && !this._nodeSock.destroyed)
                 try {
-                    this._nodeSocket.write(createWSPongFrameMasked());
+                    this._nodeSock.write(createWSPongFrameMasked());
                 }
                 catch { }
-            }
             return;
         }
-        if (opcode === OP_PONG)
+        if (f.opcode === OP_PONG)
             return;
-        if (opcode === OP_CLOSE) {
-            if (this._nodeSocket && !this._nodeSocket.destroyed) {
+        if (f.opcode === OP_CLOSE) {
+            if (this._nodeSock && !this._nodeSock.destroyed)
                 try {
-                    this._nodeSocket.end();
+                    this._nodeSock.end();
                 }
                 catch { }
-            }
             return;
         }
-        if (opcode === OP_TEXT) {
+        if (f.opcode === OP_TEXT) {
             try {
-                const msg = JSON.parse(payload.toString('utf8'));
-                const { event, data, _isAck } = msg;
+                const msg = JSON.parse(f.payload.toString('utf8')), { event, data, _isAck } = msg;
                 if (event === 'ping')
                     return;
-                if (this.options.hooks.onMessage) {
-                    this.options.hooks.onMessage({ event, data, isBinary: false });
-                }
-                if (_isAck && this._acks.has(event)) {
-                    const entry = this._acks.get(event);
-                    if (entry.timer)
-                        clearTimeout(entry.timer);
-                    this._acks.delete(event);
-                    entry.handler(data);
-                    return;
+                this.opts.hooks.onMessage?.({ event, data, isBinary: false });
+                if (_isAck) {
+                    const key = msg._correlationId || event;
+                    if (this._acks.has(key)) {
+                        const e = this._acks.get(key);
+                        if (e.timer)
+                            clearTimeout(e.timer);
+                        this._acks.delete(key);
+                        e.handler(data);
+                        return;
+                    }
                 }
-                const handler = this.events.get(event);
-                if (handler)
-                    handler(data);
-                if (this._wildcardHandler)
-                    this._wildcardHandler({ event, data });
+                this.events.get(event)?.(data);
+                this._wild?.({ event, data });
             }
             catch { }
             return;
         }
-        if (opcode === OP_BINARY) {
-            try {
-                let headerEnd = -1;
-                for (let i = 0; i < payload.length; i++) {
-                    if (payload[i] === 0) {
-                        headerEnd = i;
-                        break;
-                    }
-                }
-                if (headerEnd === -1)
-                    return;
-                const headerStr = payload.subarray(0, headerEnd).toString('utf8');
-                const header = JSON.parse(headerStr);
-                const buffer = payload.subarray(headerEnd + 1).buffer;
-                if (this.options.hooks.onMessage) {
-                    this.options.hooks.onMessage({ event: header.event, data: buffer, isBinary: true });
-                }
-                const handler = this.events.get(header.event);
-                if (handler)
-                    handler(buffer);
-                if (this._wildcardHandler)
-                    this._wildcardHandler({ event: header.event, data: buffer, isBinary: true, buffer });
-            }
-            catch { }
+        if (f.opcode === OP_BINARY) {
+            const parsed = parseWSBinary(f.payload);
+            if (!parsed)
+                return;
+            this.opts.hooks.onMessage?.({ event: parsed.event, data: parsed.buffer, isBinary: true });
+            this.events.get(parsed.event)?.(parsed.buffer);
+            this._wild?.({ event: parsed.event, data: parsed.buffer, isBinary: true, buffer: parsed.buffer });
         }
     }
-    /** TCP mode: connects to WS port + 1 by convention. */
+    /* ── TCP ── */
     async _connectTCP() {
         try {
-            await loadNodeModules();
+            await loadModules();
             if (!_net)
                 return;
-            const parsed = new URL(this.url);
-            const port = parseInt(parsed.port) + 1 || 3001;
-            const host = parsed.hostname || 'localhost';
-            const socketOptions = { host, port };
-            let socket;
-            if (this.options.tls && _tls) {
-                socketOptions.rejectUnauthorized = this.options.rejectUnauthorized;
-                socket = _tls.connect(socketOptions);
-            }
-            else {
-                socket = _net.createConnection(socketOptions);
-            }
-            socket.setTimeout(this.options.ackTimeout, () => {
-                socket.destroy(new Error('TCP connection timeout'));
-            });
-            socket.on('connect', () => {
-                socket.setTimeout(0);
-                this._setState('connected');
-                this._reconnectAttempts = 0;
-                this._connectTime = Date.now();
-                this._tcpParser = new FrameParser(this.options.maxFrameSize);
-                this.log.info('TCP connected', { host, port, tls: this.options.tls });
-                const handler = this.events.get('connect');
-                if (handler)
-                    handler(undefined);
-                this.startHeartbeat();
-                this._drainQueue();
-            });
-            socket.on('data', (data) => {
-                if (!this._tcpParser)
-                    return;
-                let frames;
-                try {
-                    frames = this._tcpParser.feed(data);
-                }
-                catch {
-                    this.log.error('TCP frame parse error');
-                    socket.destroy();
-                    return;
-                }
-                for (const frame of frames) {
-                    this._messagesReceived++;
-                    this._handleTCPFrame(frame);
-                }
-            });
-            socket.on('close', () => {
-                this._setState('disconnected');
-                this._fullCleanup();
-                const handler = this.events.get('disconnect');
-                if (handler)
-                    handler(undefined);
-                this._tryReconnect(() => this._connectTCP());
-            });
-            socket.on('error', (err) => {
-                this._lastError = err;
-                const handler = this.events.get('error');
-                if (handler)
-                    handler(err);
-                if (this.options.hooks.onError) {
-                    this.options.hooks.onError({ error: err, context: 'tcp' });
-                }
-            });
-            socket.on('drain', () => {
-                socket.resume();
-            });
-            this._tcpSocket = socket;
-        }
-        catch (err) {
-            this._lastError = err instanceof Error ? err : new Error(String(err));
+            const parsed = new URL(this.url), port = parseInt(parsed.port) + 1 || 3001, host = parsed.hostname || 'localhost';
+            const sockOpts = { host, port };
+            const socket = this.opts.tls && _tls ? _tls.connect({ ...sockOpts, rejectUnauthorized: this.opts.rejectUnauthorized }) : _net.createConnection(sockOpts);
+            socket.setTimeout(this.opts.ackTimeout, () => socket.destroy(new Error('TCP timeout')));
+            socket.on('connect', () => { socket.setTimeout(0); this._tcpParser = new FrameParser(this.opts.maxFrameSize); this.log.info('TCP connected', { host, port }); this._onConnected(); });
+            socket.on('data', (d) => { if (!this._tcpParser)
+                return; let frames; try {
+                frames = this._tcpParser.feed(d);
+            }
+            catch {
+                this.log.error('TCP parse error');
+                socket.destroy();
+                return;
+            } for (const f of frames) {
+                this._recv++;
+                this._handleTCPFrame(f);
+            } });
+            socket.on('close', () => { this._setState('disconnected'); this._fullCleanup(); this.events.get('disconnect')?.(undefined); this._tryReconnect(() => this._connectTCP()); });
+            socket.on('error', (e) => { this._lastErr = e; this.events.get('error')?.(e); this.opts.hooks.onError?.({ error: e, context: 'tcp' }); });
+            socket.on('drain', () => this._flushQueue());
+            this._tcpSock = socket;
+        }
+        catch (e) {
+            this._lastErr = e instanceof Error ? e : new Error(String(e));
             this._tryReconnect(() => this._connectTCP());
         }
     }
-    _handleTCPFrame(frame) {
-        const { type, event, payload } = frame;
+    _handleTCPFrame(f) {
+        const { type, event, payload } = f;
         if (type === FRAME_PING) {
-            if (this._tcpSocket && !this._tcpSocket.destroyed) {
+            if (this._tcpSock && !this._tcpSock.destroyed)
                 try {
-                    this._tcpSocket.write(encodePongFrame());
+                    this._tcpSock.write(encodePongFrame());
                 }
                 catch { }
-            }
             return;
         }
         if (type === FRAME_PONG)
@@ -893,72 +651,39 @@ class StelarClient {
             return;
         }
         if (type === FRAME_ACK_RES) {
-            if (this._acks.has(event)) {
-                try {
-                    const data = JSON.parse(payload.toString('utf8'));
-                    const entry = this._acks.get(event);
-                    if (entry.timer)
-                        clearTimeout(entry.timer);
-                    this._acks.delete(event);
-                    entry.handler(data);
+            try {
+                const raw = JSON.parse(payload.toString('utf8'));
+                const data = raw && typeof raw === 'object' && 'data' in raw ? raw.data : raw;
+                const corrId = raw && typeof raw === 'object' && '_correlationId' in raw ? String(raw._correlationId) : undefined;
+                const key = corrId || event;
+                if (this._acks.has(key)) {
+                    const e = this._acks.get(key);
+                    if (e.timer)
+                        clearTimeout(e.timer);
+                    this._acks.delete(key);
+                    e.handler(data);
                 }
-                catch { }
             }
+            catch { }
             return;
         }
         if (type === FRAME_JSON) {
             try {
                 const data = JSON.parse(payload.toString('utf8'));
-                if (this.options.hooks.onMessage) {
-                    this.options.hooks.onMessage({ event, data, isBinary: false });
-                }
-                const handler = this.events.get(event);
-                if (handler)
-                    handler(data);
-                if (this._wildcardHandler)
-                    this._wildcardHandler({ event, data });
+                this.opts.hooks.onMessage?.({ event, data, isBinary: false });
+                this.events.get(event)?.(data);
+                this._wild?.({ event, data });
             }
             catch { }
             return;
         }
         if (type === FRAME_BINARY) {
             const copy = Buffer.from(payload);
-            const buffer = copy.buffer.slice(copy.byteOffset, copy.byteOffset + copy.byteLength);
-            if (this.options.hooks.onMessage) {
-                this.options.hooks.onMessage({ event, data: buffer, isBinary: true });
-            }
-            const handler = this.events.get(event);
-            if (handler)
-                handler(buffer);
-            if (this._wildcardHandler)
-                this._wildcardHandler({ event, data: buffer, isBinary: true, buffer });
+            const buf = copy.buffer.slice(copy.byteOffset, copy.byteOffset + copy.byteLength);
+            this.opts.hooks.onMessage?.({ event, data: buf, isBinary: true });
+            this.events.get(event)?.(buf);
+            this._wild?.({ event, data: buf, isBinary: true, buffer: buf });
         }
     }
-    _tryReconnect(connectFn) {
-        if (this._isManualClose)
-            return;
-        if (!this.options.reconnection)
-            return;
-        if (this._reconnectAttempts >= this.options.reconnectionAttempts) {
-            this.log.warn('Max reconnection attempts reached', { attempts: this._reconnectAttempts });
-            const handler = this.events.get('reconnect_failed');
-            if (handler)
-                handler(undefined);
-            return;
-        }
-        this._reconnectAttempts++;
-        this._setState('reconnecting');
-        const delay = this._getReconnectDelay();
-        this.log.info('Reconnecting', { attempt: this._reconnectAttempts, delay });
-        const handler = this.events.get('reconnecting');
-        if (handler)
-            handler(this._reconnectAttempts);
-        this._reconnectTimer = setTimeout(() => {
-            this._reconnectTimer = null;
-            if (!this._isManualClose) {
-                connectFn();
-            }
-        }, delay);
-    }
 }
 export default StelarClient;