hedgequantx 2.6.163 → 2.7.0

package/src/pages/stats/metrics.js

@@ -0,0 +1,213 @@
+/**
+ * @fileoverview Stats metrics calculations
+ * @module pages/stats/metrics
+ * 
+ * STRICT RULE: All calculations based on API data only
+ */
+
+/**
+ * Calculate quantitative metrics from trade data
+ * @param {Array} trades - Trade array from API
+ * @param {number} totalStartingBalance - Starting balance
+ * @param {number} totalPnL - Total P&L from API
+ * @returns {Object} Calculated metrics
+ */
+const calculateQuantMetrics = (trades, totalStartingBalance, totalPnL) => {
+  const tradePnLs = trades.map(t => t.profitAndLoss || t.pnl || 0);
+  const avgReturn = tradePnLs.length > 0 ? tradePnLs.reduce((a, b) => a + b, 0) / tradePnLs.length : 0;
+  
+  // Standard deviation
+  const variance = tradePnLs.length > 0 
+    ? tradePnLs.reduce((sum, pnl) => sum + Math.pow(pnl - avgReturn, 2), 0) / tradePnLs.length 
+    : 0;
+  const stdDev = Math.sqrt(variance);
+  
+  // Downside deviation
+  const downsideReturns = tradePnLs.filter(pnl => pnl < 0);
+  const downsideVariance = downsideReturns.length > 0 
+    ? downsideReturns.reduce((sum, pnl) => sum + Math.pow(pnl, 2), 0) / downsideReturns.length 
+    : 0;
+  const downsideDev = Math.sqrt(downsideVariance);
+  
+  // Ratios
+  const sharpeRatio = stdDev > 0 ? (avgReturn / stdDev).toFixed(2) : 'N/A';
+  const sortinoRatio = downsideDev > 0 ? (avgReturn / downsideDev).toFixed(2) : 'N/A';
+  
+  // Max Drawdown
+  let maxDrawdown = 0;
+  let peak = totalStartingBalance || 0;
+  let equity = peak;
+  if (peak > 0 && tradePnLs.length > 0) {
+    tradePnLs.forEach(pnl => {
+      equity += pnl;
+      if (equity > peak) peak = equity;
+      const drawdown = peak > 0 ? (peak - equity) / peak * 100 : 0;
+      if (drawdown > maxDrawdown) maxDrawdown = drawdown;
+    });
+  }
+  
+  const returnPercent = totalStartingBalance > 0 ? ((totalPnL / totalStartingBalance) * 100).toFixed(2) : 'N/A';
+  
+  return {
+    avgReturn,
+    stdDev,
+    downsideDev,
+    sharpeRatio,
+    sortinoRatio,
+    maxDrawdown,
+    returnPercent,
+  };
+};
+
+/**
+ * Aggregate stats from lifetime stats or trades
+ * @param {Array} activeAccounts - Active accounts with lifetimeStats
+ * @param {Array} allTrades - All trades from API
+ * @returns {Object} Aggregated stats
+ */
+const aggregateStats = (activeAccounts, allTrades) => {
+  let stats = {
+    totalTrades: 0, winningTrades: 0, losingTrades: 0,
+    totalWinAmount: 0, totalLossAmount: 0,
+    bestTrade: 0, worstTrade: 0, totalVolume: 0,
+    maxConsecutiveWins: 0, maxConsecutiveLosses: 0,
+    longTrades: 0, shortTrades: 0, longWins: 0, shortWins: 0
+  };
+  
+  // First: aggregate lifetimeStats from APIs
+  for (const account of activeAccounts) {
+    if (account.lifetimeStats) {
+      const s = account.lifetimeStats;
+      stats.totalTrades += s.totalTrades || 0;
+      stats.winningTrades += s.winningTrades || 0;
+      stats.losingTrades += s.losingTrades || 0;
+      stats.totalWinAmount += s.totalWinAmount || 0;
+      stats.totalLossAmount += s.totalLossAmount || 0;
+      stats.bestTrade = Math.max(stats.bestTrade, s.bestTrade || 0);
+      stats.worstTrade = Math.min(stats.worstTrade, s.worstTrade || 0);
+      stats.totalVolume += s.totalVolume || 0;
+      stats.maxConsecutiveWins = Math.max(stats.maxConsecutiveWins, s.maxConsecutiveWins || 0);
+      stats.maxConsecutiveLosses = Math.max(stats.maxConsecutiveLosses, s.maxConsecutiveLosses || 0);
+      stats.longTrades += s.longTrades || 0;
+      stats.shortTrades += s.shortTrades || 0;
+    }
+  }
+  
+  // If no lifetimeStats, calculate from trade history
+  if (stats.totalTrades === 0 && allTrades.length > 0) {
+    stats.totalTrades = allTrades.length;
+    let consecutiveWins = 0, consecutiveLosses = 0;
+    
+    for (const trade of allTrades) {
+      const pnl = trade.profitAndLoss || trade.pnl || 0;
+      const size = trade.size || trade.quantity || 1;
+      const side = trade.side;
+      
+      stats.totalVolume += Math.abs(size);
+      
+      if (side === 0) {
+        stats.longTrades++;
+        if (pnl > 0) stats.longWins++;
+      } else if (side === 1) {
+        stats.shortTrades++;
+        if (pnl > 0) stats.shortWins++;
+      }
+      
+      if (pnl > 0) {
+        stats.winningTrades++;
+        stats.totalWinAmount += pnl;
+        consecutiveWins++;
+        consecutiveLosses = 0;
+        if (consecutiveWins > stats.maxConsecutiveWins) stats.maxConsecutiveWins = consecutiveWins;
+        if (pnl > stats.bestTrade) stats.bestTrade = pnl;
+      } else if (pnl < 0) {
+        stats.losingTrades++;
+        stats.totalLossAmount += Math.abs(pnl);
+        consecutiveLosses++;
+        consecutiveWins = 0;
+        if (consecutiveLosses > stats.maxConsecutiveLosses) stats.maxConsecutiveLosses = consecutiveLosses;
+        if (pnl < stats.worstTrade) stats.worstTrade = pnl;
+      }
+    }
+  }
+  
+  return stats;
+};
+
+/**
+ * Calculate derived metrics
+ * @param {Object} stats - Aggregated stats
+ * @param {number} totalStartingBalance - Starting balance
+ * @param {number} totalPnL - Total P&L
+ * @returns {Object} Derived metrics
+ */
+const calculateDerivedMetrics = (stats, totalStartingBalance, totalPnL) => {
+  const winRate = stats.totalTrades > 0 ? ((stats.winningTrades / stats.totalTrades) * 100).toFixed(1) : 'N/A';
+  const avgWin = stats.winningTrades > 0 ? (stats.totalWinAmount / stats.winningTrades).toFixed(2) : '0.00';
+  const avgLoss = stats.losingTrades > 0 ? (stats.totalLossAmount / stats.losingTrades).toFixed(2) : '0.00';
+  const profitFactor = stats.totalLossAmount > 0 
+    ? (stats.totalWinAmount / stats.totalLossAmount).toFixed(2) 
+    : (stats.totalWinAmount > 0 ? '∞' : 'N/A');
+  const netPnL = stats.totalWinAmount - stats.totalLossAmount;
+  const returnPercent = totalStartingBalance > 0 ? ((totalPnL / totalStartingBalance) * 100).toFixed(2) : 'N/A';
+  const longWinRate = stats.longTrades > 0 ? ((stats.longWins / stats.longTrades) * 100).toFixed(1) : 'N/A';
+  const shortWinRate = stats.shortTrades > 0 ? ((stats.shortWins / stats.shortTrades) * 100).toFixed(1) : 'N/A';
+  const expectancy = stats.totalTrades > 0 ? netPnL / stats.totalTrades : 0;
+  const riskRewardRatio = parseFloat(avgLoss) > 0 ? (parseFloat(avgWin) / parseFloat(avgLoss)).toFixed(2) : 'N/A';
+  
+  return {
+    winRate,
+    avgWin,
+    avgLoss,
+    profitFactor,
+    netPnL,
+    returnPercent,
+    longWinRate,
+    shortWinRate,
+    expectancy,
+    riskRewardRatio,
+  };
+};
+
+/**
+ * Calculate HQX score
+ * @param {Object} stats - Stats object
+ * @param {Object} metrics - Derived metrics
+ * @param {number} totalStartingBalance - Starting balance
+ * @returns {Object} Score data
+ */
+const calculateHQXScore = (stats, metrics, totalStartingBalance) => {
+  const winRateNum = metrics.winRate !== 'N/A' ? parseFloat(metrics.winRate) : 0;
+  const winRateScore = Math.min(100, winRateNum * 1.5);
+  const profitFactorScore = metrics.profitFactor === '∞' ? 100 : metrics.profitFactor === 'N/A' ? 0 : Math.min(100, parseFloat(metrics.profitFactor) * 40);
+  const consistencyScore = stats.maxConsecutiveLosses > 0 ? Math.max(0, 100 - (stats.maxConsecutiveLosses * 15)) : 100;
+  const riskScore = stats.worstTrade !== 0 && totalStartingBalance > 0 
+    ? Math.max(0, 100 - (Math.abs(stats.worstTrade) / totalStartingBalance * 1000)) 
+    : 50;
+  const volumeScore = Math.min(100, stats.totalTrades * 2);
+  const returnNum = metrics.returnPercent !== 'N/A' ? parseFloat(metrics.returnPercent) : 0;
+  const returnScore = Math.min(100, Math.max(0, returnNum * 10 + 50));
+  
+  const hqxScore = Math.round((winRateScore + profitFactorScore + consistencyScore + riskScore + volumeScore + returnScore) / 6);
+  const scoreGrade = hqxScore >= 90 ? 'S' : hqxScore >= 80 ? 'A' : hqxScore >= 70 ? 'B' : hqxScore >= 60 ? 'C' : hqxScore >= 50 ? 'D' : 'F';
+  
+  return {
+    hqxScore,
+    scoreGrade,
+    breakdown: [
+      { name: 'Win Rate', score: winRateScore },
+      { name: 'Profit Factor', score: profitFactorScore },
+      { name: 'Consistency', score: consistencyScore },
+      { name: 'Risk Management', score: riskScore },
+      { name: 'Volume', score: volumeScore },
+      { name: 'Returns', score: returnScore }
+    ]
+  };
+};
+
+module.exports = {
+  calculateQuantMetrics,
+  aggregateStats,
+  calculateDerivedMetrics,
+  calculateHQXScore,
+};

package/src/pages/user.js

@@ -26,7 +26,7 @@ const showUserInfo = async (service) => {
 
   try {
     // Step 1: Get user info
-    spinner = ora({ text: 'LOADING USER INFO...', color: 'yellow' }).start();
+    spinner = ora({ text: 'Loading user info...', color: 'yellow' }).start();
     
     let userInfo = null;
     
@@ -39,10 +39,10 @@ const showUserInfo = async (service) => {
       } catch (e) {}
     }
     
-    spinner.succeed('USER INFO LOADED');
+    spinner.succeed('User info loaded');
 
     // Step 2: Get account count
-    spinner = ora({ text: 'COUNTING ACCOUNTS...', color: 'yellow' }).start();
+    spinner = ora({ text: 'Counting accounts...', color: 'yellow' }).start();
     
     let accountCount = 0;
     
@@ -71,13 +71,13 @@ const showUserInfo = async (service) => {
 
       const username = userInfo.userName || userInfo.username || 'Unknown';
       const connCount = connections.count() || 1;
-      console.log(chalk.cyan('║') + fmtRow('USERNAME:', chalk.cyan(username.toUpperCase()), col1) + chalk.cyan('│') + fmtRow('CONNECTIONS:', chalk.cyan(String(connCount)), col2) + chalk.cyan('║'));
+      console.log(chalk.cyan('║') + fmtRow('Username:', chalk.cyan(username.toUpperCase()), col1) + chalk.cyan('│') + fmtRow('Connections:', chalk.cyan(String(connCount)), col2) + chalk.cyan('║'));
 
       const email = userInfo.email || 'N/A';
-      console.log(chalk.cyan('║') + fmtRow('EMAIL:', chalk.white(email), col1) + chalk.cyan('│') + fmtRow('ACCOUNTS:', chalk.cyan(String(accountCount)), col2) + chalk.cyan('║'));
+      console.log(chalk.cyan('║') + fmtRow('Email:', chalk.white(email), col1) + chalk.cyan('│') + fmtRow('Accounts:', chalk.cyan(String(accountCount)), col2) + chalk.cyan('║'));
 
       const userId = userInfo.userId || userInfo.id || 'N/A';
-      const platform = service?.propfirm?.name || 'ProjectX';
+      const platform = service?.propfirm?.name || 'Rithmic';
       console.log(chalk.cyan('║') + fmtRow('User ID:', chalk.gray(String(userId)), col1) + chalk.cyan('│') + fmtRow('Platform:', chalk.magenta(platform), col2) + chalk.cyan('║'));
 
       const firstName = userInfo.firstName || '';

package/src/services/hqx-server/constants.js

@@ -0,0 +1,55 @@
+/**
+ * @fileoverview HQX Server Constants
+ * @module services/hqx-server/constants
+ */
+
+/** Message types as bytes for faster switching */
+const MSG_TYPE = {
+  // Outgoing
+  PING: 0x01,
+  START_ALGO: 0x10,
+  STOP_ALGO: 0x11,
+  START_COPY: 0x12,
+  ORDER: 0x20,
+  
+  // Incoming
+  PONG: 0x81,
+  SIGNAL: 0x90,
+  TRADE: 0x91,
+  FILL: 0x92,
+  LOG: 0xA0,
+  STATS: 0xA1,
+  ERROR: 0xFF,
+};
+
+/** Pre-allocated ping buffer */
+const PING_BUFFER = Buffer.alloc(9);
+PING_BUFFER.writeUInt8(MSG_TYPE.PING, 0);
+
+/**
+ * Fast JSON stringify with pre-check
+ * @param {Object} obj 
+ * @returns {string}
+ */
+const fastStringify = (obj) => {
+  if (obj === null) return 'null';
+  if (typeof obj !== 'object') return JSON.stringify(obj);
+  return JSON.stringify(obj);
+};
+
+/**
+ * Fast JSON parse with type hint
+ * @param {string|Buffer} data 
+ * @returns {Object}
+ */
+const fastParse = (data) => {
+  const str = typeof data === 'string' ? data : data.toString('utf8');
+  return JSON.parse(str);
+};
+
+module.exports = {
+  MSG_TYPE,
+  PING_BUFFER,
+  fastStringify,
+  fastParse,
+};

package/src/services/hqx-server/index.js

@@ -0,0 +1,401 @@
+/**
+ * @fileoverview HQX Server Service - Ultra Low Latency WebSocket
+ * @module services/hqx-server
+ * 
+ * STRICT RULE: No mock data, real API only
+ */
+
+const WebSocket = require('ws');
+const crypto = require('crypto');
+const os = require('os');
+const { request } = require('../../utils/http');
+const { HQX_SERVER, SECURITY } = require('../../config/settings');
+const { logger } = require('../../utils/logger');
+const { MSG_TYPE, PING_BUFFER, fastStringify, fastParse } = require('./constants');
+const { LatencyTracker } = require('./latency');
+
+const log = logger.scope('HQX');
+
+/**
+ * HQX Server Service - Ultra Low Latency
+ */
+class HQXServerService {
+  constructor() {
+    this.ws = null;
+    this.connected = false;
+    this.reconnecting = false;
+    this.reconnectAttempts = 0;
+    
+    this.token = null;
+    this.refreshToken = null;
+    this.apiKey = null;
+    this.sessionId = null;
+    
+    this.latencyTracker = new LatencyTracker();
+    this.lastPingTime = 0;
+    this.pingInterval = null;
+    
+    this.listeners = new Map();
+    this.messageQueue = [];
+    this._deviceId = null;
+    
+    this.messagesSent = 0;
+    this.messagesReceived = 0;
+    this.bytesReceived = 0;
+  }
+
+  // ==================== DEVICE ID ====================
+
+  _getDeviceId() {
+    if (this._deviceId) return this._deviceId;
+    const data = `${os.hostname()}-${os.platform()}-${os.arch()}-${os.cpus()[0]?.model || 'cpu'}`;
+    this._deviceId = crypto.createHash('sha256').update(data).digest('hex').slice(0, 32);
+    return this._deviceId;
+  }
+
+  // ==================== AUTH ====================
+
+  async authenticate(userId, propfirm = 'unknown') {
+    const start = process.hrtime.bigint();
+    
+    try {
+      const deviceId = this._getDeviceId();
+      const url = `http://${HQX_SERVER.host}:${HQX_SERVER.port}/${HQX_SERVER.VERSION}/auth/token`;
+      
+      const response = await request(url, {
+        method: 'POST',
+        body: { userId: userId || deviceId, deviceId, propfirm, timestamp: Date.now() },
+        timeout: 5000,
+      });
+
+      if (response.statusCode === 200 && response.data?.success) {
+        const { token, refreshToken, apiKey, sessionId } = response.data.data;
+        this.token = token;
+        this.refreshToken = refreshToken;
+        this.apiKey = apiKey;
+        this.sessionId = sessionId;
+        
+        const elapsed = Number(process.hrtime.bigint() - start) / 1e6;
+        log.info('Authenticated', { sessionId, latency: `${elapsed.toFixed(1)}ms` });
+        
+        return { success: true, sessionId, apiKey };
+      }
+      
+      return { success: false, error: response.data?.error || 'Authentication failed' };
+    } catch (err) {
+      log.error('Auth error', { error: err.message });
+      return { success: false, error: err.message };
+    }
+  }
+
+  // ==================== WEBSOCKET ====================
+
+  async connect() {
+    if (!this.token) return { success: false, error: 'Not authenticated' };
+
+    return new Promise((resolve) => {
+      const wsUrl = `${HQX_SERVER.wsUrl}?token=${this.token}&session=${this.sessionId}`;
+      
+      this.ws = new WebSocket(wsUrl, {
+        headers: { 'X-Device-Id': this._getDeviceId(), 'X-API-Key': this.apiKey },
+        perMessageDeflate: false,
+        maxPayload: 64 * 1024,
+        handshakeTimeout: 5000,
+      });
+
+      this.ws.binaryType = 'nodebuffer';
+
+      const connectTimeout = setTimeout(() => {
+        if (!this.connected) {
+          this.ws?.terminate();
+          resolve({ success: false, error: 'Connection timeout' });
+        }
+      }, 5000);
+
+      this.ws.on('open', () => {
+        clearTimeout(connectTimeout);
+        this.connected = true;
+        this.reconnectAttempts = 0;
+        this._optimizeSocket();
+        this._startHeartbeat();
+        this._flushQueue();
+        this._emit('connected', { sessionId: this.sessionId });
+        log.info('Connected with TCP_NODELAY');
+        resolve({ success: true });
+      });
+
+      this.ws.on('message', (data) => this._handleMessage(data));
+
+      this.ws.on('close', (code, reason) => {
+        clearTimeout(connectTimeout);
+        this.connected = false;
+        this._stopHeartbeat();
+        log.info('Disconnected', { code });
+        this._emit('disconnected', { code, reason: reason?.toString() });
+        if (!this.reconnecting) this._attemptReconnect();
+      });
+
+      this.ws.on('error', (err) => {
+        log.error('WebSocket error', { error: err.message });
+        this._emit('error', { message: err.message });
+        if (!this.connected) {
+          clearTimeout(connectTimeout);
+          resolve({ success: false, error: err.message });
+        }
+      });
+    });
+  }
+
+  _optimizeSocket() {
+    try {
+      const socket = this.ws._socket;
+      if (socket) {
+        socket.setNoDelay(true);
+        socket.setKeepAlive(true, 10000);
+      }
+    } catch (err) {
+      log.warn('Socket optimization failed', { error: err.message });
+    }
+  }
+
+  // ==================== MESSAGE HANDLING ====================
+
+  _handleMessage(data) {
+    const receiveTime = process.hrtime.bigint();
+    this.messagesReceived++;
+    this.bytesReceived += data.length;
+    
+    try {
+      if (Buffer.isBuffer(data) && data.length > 0) {
+        const msgType = data.readUInt8(0);
+        
+        if (msgType === MSG_TYPE.PONG) {
+          this._handlePong(receiveTime);
+          return;
+        }
+        
+        if (msgType === MSG_TYPE.SIGNAL) {
+          this._handleBinarySignal(data);
+          return;
+        }
+      }
+      
+      const message = fastParse(data);
+      this._handleJsonMessage(message);
+    } catch (err) {
+      log.warn('Message parse error', { error: err.message });
+    }
+  }
+
+  _handlePong(receiveTime) {
+    if (this.lastPingTime > 0) {
+      const latency = Number(receiveTime - this.lastPingTime) / 1e6;
+      this.latencyTracker.update(latency);
+      this._emit('latency', this.latencyTracker.getStats());
+    }
+  }
+
+  _handleBinarySignal(data) {
+    if (data.length >= 22) {
+      const signal = {
+        timestamp: data.readBigInt64LE(1),
+        side: data.readUInt8(9),
+        price: data.readDoubleLE(10),
+        quantity: data.readUInt32LE(18),
+      };
+      this._emit('signal', signal);
+    }
+  }
+
+  _handleJsonMessage(message) {
+    if (message.timestamp) {
+      const latency = Date.now() - message.timestamp;
+      if (latency >= 0 && latency < 5000) {
+        this.latencyTracker.update(latency);
+      }
+    }
+    
+    switch (message.type) {
+      case 'signal': this._emit('signal', message.data); break;
+      case 'trade': this._emit('trade', message.data); break;
+      case 'fill': this._emit('fill', message.data); break;
+      case 'log': this._emit('log', message.data); break;
+      case 'stats': this._emit('stats', message.data); break;
+      case 'error': this._emit('error', message.data); break;
+      default: this._emit('message', message);
+    }
+  }
+
+  // ==================== SENDING ====================
+
+  send(type, data) {
+    const message = { type, data, ts: Date.now(), sid: this.sessionId };
+
+    if (this.connected && this.ws?.readyState === WebSocket.OPEN) {
+      try { this.ws.send(fastStringify(message)); } catch {}
+      this.messagesSent++;
+    } else {
+      this.messageQueue.push(message);
+    }
+  }
+
+  _sendBinaryPing() {
+    if (!this.connected || this.ws?.readyState !== WebSocket.OPEN) return;
+    this.lastPingTime = process.hrtime.bigint();
+    PING_BUFFER.writeBigInt64LE(this.lastPingTime, 1);
+    try { this.ws.send(PING_BUFFER); } catch {}
+  }
+
+  _flushQueue() {
+    while (this.messageQueue.length > 0 && this.ws?.readyState === WebSocket.OPEN) {
+      const message = this.messageQueue.shift();
+      try { this.ws.send(fastStringify(message)); } catch {}
+      this.messagesSent++;
+    }
+  }
+
+  // ==================== ALGO CONTROL ====================
+
+  startAlgo(config) {
+    log.info('Starting algo', { symbol: config.symbol, contracts: config.contracts });
+    this.send('start_algo', {
+      accountId: config.accountId,
+      contractId: config.contractId,
+      symbol: config.symbol,
+      contracts: config.contracts,
+      dailyTarget: config.dailyTarget,
+      maxRisk: config.maxRisk,
+      propfirm: config.propfirm,
+      propfirmToken: config.propfirmToken,
+      rithmicCredentials: config.rithmicCredentials || null,
+      copyTrading: config.copyTrading || false,
+      followerSymbol: config.followerSymbol,
+      followerContracts: config.followerContracts,
+    });
+  }
+
+  stopAlgo() {
+    log.info('Stopping algo');
+    this.send('stop_algo', {});
+  }
+
+  startCopyTrading(config) {
+    log.info('Starting copy trading');
+    this.send('start_copy_trading', {
+      leadAccountId: config.leadAccountId,
+      leadContractId: config.leadContractId,
+      leadSymbol: config.leadSymbol,
+      leadContracts: config.leadContracts,
+      leadPropfirm: config.leadPropfirm,
+      leadToken: config.leadToken,
+      leadRithmicCredentials: config.leadRithmicCredentials,
+      followerAccountId: config.followerAccountId,
+      followerContractId: config.followerContractId,
+      followerSymbol: config.followerSymbol,
+      followerContracts: config.followerContracts,
+      followerPropfirm: config.followerPropfirm,
+      followerToken: config.followerToken,
+      followerRithmicCredentials: config.followerRithmicCredentials,
+      dailyTarget: config.dailyTarget,
+      maxRisk: config.maxRisk,
+    });
+  }
+
+  // ==================== EVENTS ====================
+
+  on(event, callback) {
+    if (!this.listeners.has(event)) this.listeners.set(event, []);
+    this.listeners.get(event).push(callback);
+  }
+
+  off(event, callback) {
+    const callbacks = this.listeners.get(event);
+    if (callbacks) {
+      const index = callbacks.indexOf(callback);
+      if (index > -1) callbacks.splice(index, 1);
+    }
+  }
+
+  _emit(event, data) {
+    const callbacks = this.listeners.get(event);
+    if (!callbacks) return;
+    for (let i = 0; i < callbacks.length; i++) {
+      try { callbacks[i](data); } catch {}
+    }
+  }
+
+  // ==================== HEARTBEAT ====================
+
+  _startHeartbeat() {
+    this._stopHeartbeat();
+    const heartbeat = () => {
+      if (this.connected) {
+        this._sendBinaryPing();
+        this.pingInterval = setTimeout(heartbeat, this.latencyTracker.adaptiveHeartbeat);
+      }
+    };
+    this._sendBinaryPing();
+    this.pingInterval = setTimeout(heartbeat, this.latencyTracker.adaptiveHeartbeat);
+  }
+
+  _stopHeartbeat() {
+    if (this.pingInterval) {
+      clearTimeout(this.pingInterval);
+      this.pingInterval = null;
+    }
+  }
+
+  // ==================== RECONNECT ====================
+
+  _attemptReconnect() {
+    if (this.reconnectAttempts >= SECURITY.MAX_RECONNECT_ATTEMPTS) {
+      log.error('Max reconnect attempts reached');
+      return;
+    }
+
+    this.reconnecting = true;
+    this.reconnectAttempts++;
+    const delay = Math.min(100 * Math.pow(2, this.reconnectAttempts - 1), 10000);
+    
+    log.info('Reconnecting', { attempt: this.reconnectAttempts, delay });
+
+    setTimeout(async () => {
+      try { await this.connect(); } catch {}
+      this.reconnecting = false;
+    }, delay);
+  }
+
+  // ==================== STATS & CLEANUP ====================
+
+  getLatencyStats() { return this.latencyTracker.getStats(); }
+  getLatency() { return this.latencyTracker.latency; }
+  isConnected() { return this.connected && this.ws?.readyState === WebSocket.OPEN; }
+
+  getStats() {
+    return {
+      connected: this.connected,
+      messagesSent: this.messagesSent,
+      messagesReceived: this.messagesReceived,
+      bytesReceived: this.bytesReceived,
+      heartbeatInterval: this.latencyTracker.adaptiveHeartbeat,
+      latency: this.getLatencyStats(),
+    };
+  }
+
+  disconnect() {
+    log.info('Disconnecting');
+    this._stopHeartbeat();
+    if (this.ws) {
+      this.ws.close(1000, 'Client disconnect');
+      this.ws = null;
+    }
+    this.connected = false;
+    this.token = null;
+    this.sessionId = null;
+    this.messageQueue = [];
+    this.listeners.clear();
+    this.latencyTracker.reset();
+  }
+}
+
+module.exports = { HQXServerService, HQX_SERVER, MSG_TYPE };