flashq 0.3.0 → 0.3.1

package/dist/client/connection.d.ts

@@ -1,23 +1,41 @@
 import { EventEmitter } from 'events';
 import type { ClientOptions } from '../types';
+import { Logger } from '../utils/logger';
 export declare const MAX_JOB_DATA_SIZE: number;
 export declare const MAX_BATCH_SIZE = 1000;
 export declare function validateQueueName(queue: string): void;
 export declare function validateJobDataSize(data: unknown): void;
 type ConnectionState = 'disconnected' | 'connecting' | 'connected' | 'reconnecting' | 'closed';
+/** Client options with required fields except hooks */
+type ResolvedClientOptions = Required<Omit<ClientOptions, 'hooks'>> & {
+    hooks?: ClientOptions['hooks'];
+};
 export declare class FlashQConnection extends EventEmitter {
-    protected _options: Required<ClientOptions>;
+    protected _options: ResolvedClientOptions;
+    protected logger: Logger;
     private socket;
     private connectionState;
     private authenticated;
     private pendingRequests;
-    private buffer;
+    private bufferChunks;
+    private bufferRemainder;
     private binaryBuffer;
     private reconnectAttempts;
     private reconnectTimer;
     private manualClose;
+    private retryConfig;
+    private queueOnDisconnect;
+    private maxQueuedRequests;
+    private requestQueue;
+    private trackRequestIds;
+    private compression;
+    private compressionThreshold;
     constructor(options?: ClientOptions);
-    get options(): Required<ClientOptions>;
+    /** @deprecated Use logger.debug() instead */
+    protected debug(message: string, data?: unknown): void;
+    /** Call connection hook */
+    private callConnectionHook;
+    get options(): ResolvedClientOptions;
     connect(): Promise<void>;
     private scheduleReconnect;
     private setupSocketHandlers;
@@ -25,11 +43,17 @@ export declare class FlashQConnection extends EventEmitter {
     private processBinaryBuffer;
     private handleResponse;
     close(): Promise<void>;
+    /** Get number of queued requests */
+    getQueuedRequestCount(): number;
     isConnected(): boolean;
     getConnectionState(): ConnectionState;
     ping(): Promise<boolean>;
     auth(token: string): Promise<void>;
     send<T>(command: Record<string, unknown>, customTimeout?: number): Promise<T>;
+    private doSend;
+    private waitForReconnection;
+    private queueRequest;
+    private processRequestQueue;
     private sendTcp;
     private sendHttp;
 }

package/dist/client/connection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"connection.d.ts","sourceRoot":"","sources":["../../src/client/connection.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAEtC,OAAO,KAAK,EAAE,aAAa,EAAe,MAAM,UAAU,CAAC;AAI3D,eAAO,MAAM,iBAAiB,QAAc,CAAC;AAC7C,eAAO,MAAM,cAAc,OAAO,CAAC;AAKnC,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAKrD;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAKvD;AAQD,KAAK,eAAe,GAAG,cAAc,GAAG,YAAY,GAAG,WAAW,GAAG,cAAc,GAAG,QAAQ,CAAC;AAE/F,qBAAa,gBAAiB,SAAQ,YAAY;IAChD,SAAS,CAAC,QAAQ,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAC;IAC5C,OAAO,CAAC,MAAM,CAA2B;IACzC,OAAO,CAAC,eAAe,CAAmC;IAC1D,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,eAAe,CAA0C;IACjE,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,YAAY,CAA2B;IAC/C,OAAO,CAAC,iBAAiB,CAAK;IAC9B,OAAO,CAAC,cAAc,CAA8C;IACpE,OAAO,CAAC,WAAW,CAAS;gBAEhB,OAAO,GAAE,aAAkB;IAmBvC,IAAI,OAAO,IAAI,QAAQ,CAAC,aAAa,CAAC,CAA0B;IAE1D,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAsD9B,OAAO,CAAC,iBAAiB;IAwBzB,OAAO,CAAC,mBAAmB;IAuB3B,OAAO,CAAC,aAAa;IASrB,OAAO,CAAC,mBAAmB;IAU3B,OAAO,CAAC,cAAc;IAUhB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAY5B,WAAW,IAAI,OAAO;IACtB,kBAAkB,IAAI,eAAe;IAE/B,IAAI,IAAI,OAAO,CAAC,OAAO,CAAC;IAOxB,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAOlC,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC;YA0BrE,OAAO;YAmBP,QAAQ;CAiBvB"}
+{"version":3,"file":"connection.d.ts","sourceRoot":"","sources":["../../src/client/connection.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAEtC,OAAO,KAAK,EAAE,aAAa,EAA4B,MAAM,UAAU,CAAC;AAWxE,OAAO,EAAE,MAAM,EAAiB,MAAM,iBAAiB,CAAC;AAKxD,eAAO,MAAM,iBAAiB,QAAc,CAAC;AAC7C,eAAO,MAAM,cAAc,OAAO,CAAC;AAKnC,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAUrD;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAQvD;AAeD,KAAK,eAAe,GAAG,cAAc,GAAG,YAAY,GAAG,WAAW,GAAG,cAAc,GAAG,QAAQ,CAAC;AAS/F,uDAAuD;AACvD,KAAK,qBAAqB,GAAG,QAAQ,CAAC,IAAI,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC,GAAG;IACpE,KAAK,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;CAChC,CAAC;AAEF,qBAAa,gBAAiB,SAAQ,YAAY;IAChD,SAAS,CAAC,QAAQ,EAAE,qBAAqB,CAAC;IAC1C,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,MAAM,CAA2B;IACzC,OAAO,CAAC,eAAe,CAAmC;IAC1D,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,eAAe,CAA0C;IACjE,OAAO,CAAC,YAAY,CAAgB;IACpC,OAAO,CAAC,eAAe,CAAM;IAC7B,OAAO,CAAC,YAAY,CAA2B;IAC/C,OAAO,CAAC,iBAAiB,CAAK;IAC9B,OAAO,CAAC,cAAc,CAA8C;IACpE,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,WAAW,CAEjB;IACF,OAAO,CAAC,iBAAiB,CAAU;IACnC,OAAO,CAAC,iBAAiB,CAAS;IAClC,OAAO,CAAC,YAAY,CAAuB;IAC3C,OAAO,CAAC,eAAe,CAAU;IACjC,OAAO,CAAC,WAAW,CAAU;IAC7B,OAAO,CAAC,oBAAoB,CAAS;gBAEzB,OAAO,GAAE,aAAkB;IA2DvC,6CAA6C;IAC7C,SAAS,CAAC,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI;IAItD,2BAA2B;IAC3B,OAAO,CAAC,kBAAkB;IAiB1B,IAAI,OAAO,IAAI,qBAAqB,CAEnC;IAEK,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAmE9B,OAAO,CAAC,iBAAiB;IAqCzB,OAAO,CAAC,mBAAmB;IA2B3B,OAAO,CAAC,aAAa;IAoBrB,OAAO,CAAC,mBAAmB;IAiB3B,OAAO,CAAC,cAAc;IAuBhB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAwB5B,oCAAoC;IACpC,qBAAqB,IAAI,MAAM;IAI/B,WAAW,IAAI,OAAO;IAGtB,kBAAkB,IAAI,eAAe;IAI/B,IAAI,IAAI,OAAO,CAAC,OAAO,CAAC;IASxB,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAOlC,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC;YAqBrE,MAAM;YAeN,mBAAmB;IAsBjC,OAAO,CAAC,YAAY;YAiBN,mBAAmB;YAenB,OAAO;YA6EP,QAAQ;CA0BvB"}

package/dist/client/connection.js

@@ -40,41 +40,70 @@ exports.validateJobDataSize = validateJobDataSize;
  * Connection management for FlashQ client.
  */
 const net = __importStar(require("net"));
+const zlib = __importStar(require("zlib"));
+const util_1 = require("util");
 const events_1 = require("events");
 const msgpack_1 = require("@msgpack/msgpack");
 const request_1 = require("./http/request");
 const response_1 = require("./http/response");
+const errors_1 = require("../errors");
+const retry_1 = require("../utils/retry");
+const logger_1 = require("../utils/logger");
+const hooks_1 = require("../hooks");
+const gzip = (0, util_1.promisify)(zlib.gzip);
 exports.MAX_JOB_DATA_SIZE = 1024 * 1024;
 exports.MAX_BATCH_SIZE = 1000;
 const QUEUE_NAME_REGEX = /^[a-zA-Z0-9_.-]{1,256}$/;
 let requestIdCounter = 0;
 const generateReqId = () => `r${++requestIdCounter}`;
 function validateQueueName(queue) {
-    if (!queue || typeof queue !== 'string')
-        throw new Error('Queue name is required');
+    if (!queue || typeof queue !== 'string') {
+        throw new errors_1.ValidationError('Queue name is required', 'queue');
+    }
     if (!QUEUE_NAME_REGEX.test(queue)) {
-        throw new Error(`Invalid queue name: "${queue}". Must be alphanumeric, _, -, . (1-256 chars)`);
+        throw new errors_1.ValidationError(`Invalid queue name: "${queue}". Must be alphanumeric, _, -, . (1-256 chars)`, 'queue');
     }
 }
 function validateJobDataSize(data) {
     const size = JSON.stringify(data).length;
     if (size > exports.MAX_JOB_DATA_SIZE) {
-        throw new Error(`Job data size (${size} bytes) exceeds max (${exports.MAX_JOB_DATA_SIZE} bytes)`);
+        throw new errors_1.ValidationError(`Job data size (${size} bytes) exceeds max (${exports.MAX_JOB_DATA_SIZE} bytes)`, 'data');
     }
 }
+const DEFAULT_RETRY_CONFIG = {
+    enabled: false,
+    maxRetries: 3,
+    initialDelay: 100,
+    maxDelay: 5000,
+};
 class FlashQConnection extends events_1.EventEmitter {
     _options;
+    logger;
     socket = null;
     connectionState = 'disconnected';
     authenticated = false;
     pendingRequests = new Map();
-    buffer = '';
+    bufferChunks = [];
+    bufferRemainder = '';
     binaryBuffer = Buffer.alloc(0);
     reconnectAttempts = 0;
     reconnectTimer = null;
     manualClose = false;
+    retryConfig;
+    queueOnDisconnect;
+    maxQueuedRequests;
+    requestQueue = [];
+    trackRequestIds;
+    compression;
+    compressionThreshold;
     constructor(options = {}) {
         super();
+        // Determine log level: logLevel takes precedence, then debug flag
+        const logLevel = options.logLevel ?? (options.debug ? 'debug' : 'silent');
+        this.logger = new logger_1.Logger({
+            level: logLevel,
+            prefix: 'flashQ',
+        });
         this._options = {
             host: options.host ?? 'localhost',
             port: options.port ?? 6789,
@@ -88,11 +117,61 @@ class FlashQConnection extends events_1.EventEmitter {
             maxReconnectAttempts: options.maxReconnectAttempts ?? 10,
             reconnectDelay: options.reconnectDelay ?? 1000,
             maxReconnectDelay: options.maxReconnectDelay ?? 30000,
+            debug: options.debug ?? false,
+            logLevel: logLevel,
+            retry: options.retry ?? false,
+            queueOnDisconnect: options.queueOnDisconnect ?? false,
+            maxQueuedRequests: options.maxQueuedRequests ?? 100,
+            trackRequestIds: options.trackRequestIds ?? false,
+            compression: options.compression ?? false,
+            compressionThreshold: options.compressionThreshold ?? 1024,
+            hooks: options.hooks,
         };
+        // Parse retry config
+        if (options.retry === true) {
+            this.retryConfig = { ...DEFAULT_RETRY_CONFIG, enabled: true };
+        }
+        else if (options.retry && typeof options.retry === 'object') {
+            this.retryConfig = {
+                enabled: options.retry.enabled ?? true,
+                maxRetries: options.retry.maxRetries ?? DEFAULT_RETRY_CONFIG.maxRetries,
+                initialDelay: options.retry.initialDelay ?? DEFAULT_RETRY_CONFIG.initialDelay,
+                maxDelay: options.retry.maxDelay ?? DEFAULT_RETRY_CONFIG.maxDelay,
+                onRetry: options.retry.onRetry,
+            };
+        }
+        else {
+            this.retryConfig = { ...DEFAULT_RETRY_CONFIG };
+        }
+        this.queueOnDisconnect = options.queueOnDisconnect ?? false;
+        this.maxQueuedRequests = options.maxQueuedRequests ?? 100;
+        this.trackRequestIds = options.trackRequestIds ?? false;
+        this.compression = options.compression ?? false;
+        this.compressionThreshold = options.compressionThreshold ?? 1024;
         if (this._options.useHttp)
             this.connectionState = 'connected';
     }
-    get options() { return this._options; }
+    /** @deprecated Use logger.debug() instead */
+    debug(message, data) {
+        this.logger.debug(message, data);
+    }
+    /** Call connection hook */
+    callConnectionHook(event, error, attempt) {
+        const hooks = this._options.hooks;
+        if (!hooks?.onConnection)
+            return;
+        const ctx = (0, hooks_1.createHookContext)({
+            host: this._options.host,
+            port: this._options.port,
+            event,
+            error,
+            attempt,
+        });
+        (0, hooks_1.callHook)(hooks.onConnection, ctx);
+    }
+    get options() {
+        return this._options;
+    }
     async connect() {
         if (this._options.useHttp) {
             this.connectionState = 'connected';
@@ -102,8 +181,14 @@ class FlashQConnection extends events_1.EventEmitter {
             return;
         if (this.connectionState === 'connecting') {
             return new Promise((resolve, reject) => {
-                const onConnect = () => { this.removeListener('error', onError); resolve(); };
-                const onError = (err) => { this.removeListener('connect', onConnect); reject(err); };
+                const onConnect = () => {
+                    this.removeListener('error', onError);
+                    resolve();
+                };
+                const onError = (err) => {
+                    this.removeListener('connect', onConnect);
+                    reject(err);
+                };
                 this.once('connect', onConnect);
                 this.once('error', onError);
             });
@@ -113,7 +198,7 @@ class FlashQConnection extends events_1.EventEmitter {
         return new Promise((resolve, reject) => {
             const timeout = setTimeout(() => {
                 this.connectionState = 'disconnected';
-                reject(new Error('Connection timeout'));
+                reject(new errors_1.ConnectionError('Connection timeout', 'CONNECTION_TIMEOUT'));
             }, this._options.timeout);
             const opts = this._options.socketPath
                 ? { path: this._options.socketPath }
@@ -123,12 +208,15 @@ class FlashQConnection extends events_1.EventEmitter {
                 this.connectionState = 'connected';
                 this.reconnectAttempts = 0;
                 this.setupSocketHandlers();
+                this.logger.info('Connected to server', opts);
                 if (this._options.token) {
                     try {
                         await this.auth(this._options.token);
                         this.authenticated = true;
+                        this.logger.info('Authenticated successfully');
                     }
                     catch (err) {
+                        this.logger.error('Authentication failed', err);
                         this.socket?.destroy();
                         this.connectionState = 'disconnected';
                         reject(err);
@@ -136,6 +224,7 @@ class FlashQConnection extends events_1.EventEmitter {
                     }
                 }
                 this.emit('connect');
+                this.callConnectionHook('connect');
                 resolve();
             });
             this.socket.on('error', (err) => {
@@ -152,7 +241,7 @@ class FlashQConnection extends events_1.EventEmitter {
             return;
         if (this._options.maxReconnectAttempts > 0 &&
             this.reconnectAttempts >= this._options.maxReconnectAttempts) {
-            this.emit('reconnect_failed', new Error('Max reconnection attempts reached'));
+            this.emit('reconnect_failed', new errors_1.ConnectionError('Max reconnection attempts reached', 'RECONNECTION_FAILED'));
             return;
         }
         this.connectionState = 'reconnecting';
@@ -160,11 +249,17 @@ class FlashQConnection extends events_1.EventEmitter {
         const baseDelay = Math.min(this._options.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1), this._options.maxReconnectDelay);
         const delay = baseDelay + Math.random() * 0.3 * baseDelay;
         this.emit('reconnecting', { attempt: this.reconnectAttempts, delay });
+        this.callConnectionHook('reconnecting', undefined, this.reconnectAttempts);
         this.reconnectTimer = setTimeout(async () => {
             try {
                 this.connectionState = 'disconnected';
                 await this.connect();
                 this.emit('reconnected');
+                this.callConnectionHook('reconnected');
+                // Process queued requests after successful reconnection
+                if (this.queueOnDisconnect) {
+                    await this.processRequestQueue();
+                }
             }
             catch {
                 this.scheduleReconnect();
@@ -180,7 +275,7 @@ class FlashQConnection extends events_1.EventEmitter {
                 this.processBinaryBuffer();
             }
             else {
-                this.buffer += data.toString();
+                this.bufferChunks.push(data.toString());
                 this.processBuffer();
             }
         });
@@ -189,22 +284,35 @@ class FlashQConnection extends events_1.EventEmitter {
             this.connectionState = 'disconnected';
             this.authenticated = false;
             this.emit('disconnect');
+            this.callConnectionHook('disconnect');
             if (wasConnected && !this.manualClose && this._options.autoReconnect) {
                 this.scheduleReconnect();
             }
         });
-        this.socket.on('error', (err) => this.emit('error', err));
+        this.socket.on('error', (err) => {
+            this.emit('error', err);
+            this.callConnectionHook('error', err);
+        });
     }
     processBuffer() {
-        const lines = this.buffer.split('\n');
-        this.buffer = lines.pop() ?? '';
+        // Join chunks only when processing (more efficient than += on each chunk)
+        const fullBuffer = this.bufferRemainder + this.bufferChunks.join('');
+        this.bufferChunks.length = 0; // Clear array without reallocating
+        const lines = fullBuffer.split('\n');
+        this.bufferRemainder = lines.pop() ?? '';
         for (const line of lines) {
             if (!line.trim())
                 continue;
             try {
                 this.handleResponse(JSON.parse(line));
             }
-            catch { /* ignore */ }
+            catch (err) {
+                this.debug('Failed to parse JSON response', {
+                    line,
+                    error: err instanceof Error ? err.message : err,
+                });
+                this.emit('parse_error', err, line);
+            }
         }
     }
     processBinaryBuffer() {
@@ -217,21 +325,34 @@ class FlashQConnection extends events_1.EventEmitter {
             try {
                 this.handleResponse((0, msgpack_1.decode)(frameData));
             }
-            catch { /* ignore */ }
+            catch (err) {
+                this.debug('Failed to decode binary response', {
+                    error: err instanceof Error ? err.message : err,
+                });
+                this.emit('parse_error', err, frameData);
+            }
         }
     }
     handleResponse(response) {
-        if (!response.reqId)
+        if (!response.reqId) {
+            this.logger.warn('Received response without reqId', response);
             return;
+        }
         const pending = this.pendingRequests.get(response.reqId);
-        if (!pending)
+        if (!pending) {
+            this.logger.warn('Received response for unknown request', { reqId: response.reqId });
             return;
+        }
         this.pendingRequests.delete(response.reqId);
         clearTimeout(pending.timer);
-        if (response.ok === false && response.error)
-            pending.reject(new Error(response.error));
-        else
+        if (response.ok === false && response.error) {
+            this.logger.debug('Request failed', { reqId: response.reqId, error: response.error });
+            pending.reject((0, errors_1.parseServerError)(response.error, response.code));
+        }
+        else {
+            this.logger.trace('Request succeeded', { reqId: response.reqId });
             pending.resolve(response);
+        }
     }
     async close() {
         this.manualClose = true;
@@ -240,18 +361,32 @@ class FlashQConnection extends events_1.EventEmitter {
             clearTimeout(this.reconnectTimer);
             this.reconnectTimer = null;
         }
+        // Reject pending requests
         for (const [, pending] of this.pendingRequests) {
             clearTimeout(pending.timer);
-            pending.reject(new Error('Connection closed'));
+            pending.reject(new errors_1.ConnectionError('Connection closed', 'CONNECTION_CLOSED'));
         }
         this.pendingRequests.clear();
+        // Reject queued requests
+        for (const req of this.requestQueue) {
+            req.reject(new errors_1.ConnectionError('Connection closed', 'CONNECTION_CLOSED'));
+        }
+        this.requestQueue = [];
         if (this.socket) {
             this.socket.destroy();
             this.socket = null;
         }
     }
-    isConnected() { return this.connectionState === 'connected'; }
-    getConnectionState() { return this.connectionState; }
+    /** Get number of queued requests */
+    getQueuedRequestCount() {
+        return this.requestQueue.length;
+    }
+    isConnected() {
+        return this.connectionState === 'connected';
+    }
+    getConnectionState() {
+        return this.connectionState;
+    }
     async ping() {
         try {
             const response = await this.send({ cmd: 'PING' });
@@ -264,54 +399,165 @@ class FlashQConnection extends events_1.EventEmitter {
     async auth(token) {
         const response = await this.send({ cmd: 'AUTH', token });
         if (!response.ok)
-            throw new Error('Authentication failed');
+            throw new errors_1.AuthenticationError();
         this._options.token = token;
         this.authenticated = true;
     }
     async send(command, customTimeout) {
-        if (this.connectionState === 'reconnecting') {
-            await new Promise((resolve, reject) => {
-                const timeout = setTimeout(() => {
-                    this.removeListener('reconnected', onReconnect);
-                    this.removeListener('reconnect_failed', onFailed);
-                    reject(new Error('Reconnection timeout'));
-                }, this._options.timeout);
-                const onReconnect = () => {
-                    clearTimeout(timeout);
-                    this.removeListener('reconnect_failed', onFailed);
-                    resolve();
-                };
-                const onFailed = (err) => {
-                    clearTimeout(timeout);
-                    this.removeListener('reconnected', onReconnect);
-                    reject(err);
-                };
-                this.once('reconnected', onReconnect);
-                this.once('reconnect_failed', onFailed);
+        // If retry is enabled, wrap the actual send with retry logic
+        if (this.retryConfig.enabled) {
+            return (0, retry_1.withRetry)(() => this.doSend(command, customTimeout), {
+                maxRetries: this.retryConfig.maxRetries,
+                initialDelay: this.retryConfig.initialDelay,
+                maxDelay: this.retryConfig.maxDelay,
+                onRetry: (error, attempt, delay) => {
+                    this.debug('Retrying request', {
+                        cmd: command.cmd,
+                        attempt,
+                        delay,
+                        error: error.message,
+                    });
+                    this.retryConfig.onRetry?.(error, attempt, delay);
+                },
             });
         }
+        return this.doSend(command, customTimeout);
+    }
+    async doSend(command, customTimeout) {
+        // Queue request if disconnected and queueOnDisconnect is enabled
+        if (this.queueOnDisconnect && this.connectionState === 'reconnecting') {
+            return this.queueRequest(command, customTimeout);
+        }
+        if (this.connectionState === 'reconnecting') {
+            await this.waitForReconnection();
+        }
         if (this.connectionState !== 'connected')
             await this.connect();
-        return this._options.useHttp ? this.sendHttp(command, customTimeout) : this.sendTcp(command, customTimeout);
+        return this._options.useHttp
+            ? this.sendHttp(command, customTimeout)
+            : this.sendTcp(command, customTimeout);
+    }
+    async waitForReconnection() {
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.removeListener('reconnected', onReconnect);
+                this.removeListener('reconnect_failed', onFailed);
+                reject(new errors_1.ConnectionError('Reconnection timeout', 'RECONNECTION_FAILED'));
+            }, this._options.timeout);
+            const onReconnect = () => {
+                clearTimeout(timeout);
+                this.removeListener('reconnect_failed', onFailed);
+                resolve();
+            };
+            const onFailed = (err) => {
+                clearTimeout(timeout);
+                this.removeListener('reconnected', onReconnect);
+                reject(err);
+            };
+            this.once('reconnected', onReconnect);
+            this.once('reconnect_failed', onFailed);
+        });
+    }
+    queueRequest(command, customTimeout) {
+        if (this.requestQueue.length >= this.maxQueuedRequests) {
+            return Promise.reject(new errors_1.ConnectionError(`Request queue full (max: ${this.maxQueuedRequests})`, 'QUEUE_FULL'));
+        }
+        this.debug('Queueing request', { cmd: command.cmd, queueSize: this.requestQueue.length + 1 });
+        return new Promise((resolve, reject) => {
+            this.requestQueue.push({
+                command,
+                customTimeout,
+                resolve: resolve,
+                reject,
+            });
+        });
+    }
+    async processRequestQueue() {
+        if (this.requestQueue.length === 0)
+            return;
+        this.debug('Processing queued requests', { count: this.requestQueue.length });
+        const queue = [...this.requestQueue];
+        this.requestQueue = [];
+        for (const req of queue) {
+            try {
+                const result = await this.doSend(req.command, req.customTimeout);
+                req.resolve(result);
+            }
+            catch (error) {
+                req.reject(error instanceof Error ? error : new Error(String(error)));
+            }
+        }
     }
     async sendTcp(command, customTimeout) {
-        if (!this.socket || this.connectionState !== 'connected')
-            throw new Error('Not connected');
+        if (!this.socket || this.connectionState !== 'connected') {
+            throw new errors_1.ConnectionError('Not connected', 'NOT_CONNECTED');
+        }
+        const reqId = generateReqId();
+        const timeoutMs = customTimeout ?? this._options.timeout;
+        // Set request ID for logger correlation if tracking is enabled
+        if (this.trackRequestIds) {
+            this.logger.setRequestId(reqId);
+        }
+        this.logger.trace('Preparing request', { reqId, cmd: command.cmd });
+        // Apply compression if enabled and payload is large enough
+        let payload = command;
+        let compressed = false;
+        if (this.compression && !this._options.useBinary) {
+            const jsonStr = JSON.stringify(command);
+            if (jsonStr.length >= this.compressionThreshold) {
+                try {
+                    const compressedData = await gzip(Buffer.from(jsonStr));
+                    payload = { ...command, _compressed: compressedData.toString('base64') };
+                    compressed = true;
+                    this.logger.trace('Payload compressed', {
+                        reqId,
+                        original: jsonStr.length,
+                        compressed: compressedData.length,
+                    });
+                }
+                catch (err) {
+                    this.logger.warn('Compression failed, sending uncompressed', { reqId, error: err });
+                }
+            }
+        }
         return new Promise((resolve, reject) => {
-            const reqId = generateReqId();
-            const timeoutMs = customTimeout ?? this._options.timeout;
-            const timer = setTimeout(() => { this.pendingRequests.delete(reqId); reject(new Error('Request timeout')); }, timeoutMs);
-            this.pendingRequests.set(reqId, { resolve: (value) => resolve(value), reject, timer });
+            this.logger.debug('Sending command', {
+                reqId,
+                cmd: command.cmd,
+                timeout: timeoutMs,
+                compressed,
+            });
+            const timer = setTimeout(() => {
+                this.pendingRequests.delete(reqId);
+                if (this.trackRequestIds)
+                    this.logger.clearRequestId();
+                this.logger.warn('Request timeout', { reqId, cmd: command.cmd, timeout: timeoutMs });
+                reject(new errors_1.TimeoutError(`Request timeout for ${command.cmd}`, timeoutMs));
+            }, timeoutMs);
+            this.pendingRequests.set(reqId, {
+                resolve: (value) => {
+                    if (this.trackRequestIds)
+                        this.logger.clearRequestId();
+                    resolve(value);
+                },
+                reject: (err) => {
+                    if (this.trackRequestIds)
+                        this.logger.clearRequestId();
+                    reject(err);
+                },
+                timer,
+            });
             if (this._options.useBinary) {
-                const encoded = (0, msgpack_1.encode)({ ...command, reqId });
+                const encoded = (0, msgpack_1.encode)({ ...payload, reqId });
                 const frame = Buffer.alloc(4 + encoded.length);
                 frame.writeUInt32BE(encoded.length, 0);
                 frame.set(encoded, 4);
                 this.socket.write(frame);
             }
             else {
-                this.socket.write(JSON.stringify({ ...command, reqId }) + '\n');
+                this.socket.write(JSON.stringify({ ...payload, reqId }) + '\n');
             }
+            this.logger.trace('Command sent', { reqId });
         });
     }
     async sendHttp(command, customTimeout) {
@@ -323,13 +569,19 @@ class FlashQConnection extends events_1.EventEmitter {
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), timeout);
         try {
-            const res = await fetch(req.url, { method: req.method, headers, body: req.body, signal: controller.signal });
+            const res = await fetch(req.url, {
+                method: req.method,
+                headers,
+                body: req.body,
+                signal: controller.signal,
+            });
             const json = (await res.json());
             return (0, response_1.parseHttpResponse)(cmd, json);
         }
         catch (error) {
-            if (error instanceof Error && error.name === 'AbortError')
-                throw new Error('HTTP request timeout');
+            if (error instanceof Error && error.name === 'AbortError') {
+                throw new errors_1.TimeoutError('HTTP request timeout', timeout);
+            }
             throw error;
         }
         finally {