violetics 7.0.16-alpha → 7.0.18-alpha

package/lib/Defaults/index.js

@@ -84,14 +84,20 @@ export const DEFAULT_CONNECTION_CONFIG = {
     reconnectDelay: 2000,
     maxReconnectDelay: 30000,
     
+    // Connection sync timeout (ms to wait for history sync before forcing flush)
+    awaitingSyncTimeoutMs: 5000,
+    // Message retry phone request delay
+    phoneRequestDelayMs: 2000,
+
     // Memory management options
     maxMessagesPerChat: 2000,
-    maxChats: 10000,
-    maxContacts: 20000,
-    messageCleanupIntervalMs: 5 * 60 * 1000, // 5 minutes
+    maxChats: 5000,
+    maxContacts: 10000,
+    maxPresences: 500,
+    messageCleanupIntervalMs: 2 * 60 * 1000, // 2 minutes
     maxHistoryCacheSize: 15000,
-    bufferTimeoutMs: 30000,
-    maxBufferCount: 10000
+    bufferTimeoutMs: 100,
+    maxBufferCount: 500
 };
 export const MEDIA_PATH_MAP = {
     image: '/mms/image',

package/lib/Socket/Client/websocket.js

@@ -11,6 +11,7 @@ export class WebSocketClient extends AbstractSocketClient {
         this.reconnectDelay = this.config.reconnectDelay || 1000;
         this.maxReconnectDelay = this.config.maxReconnectDelay || 30000;
         this.reconnecting = false;
+        this._destroyed = false;
     }
     get isOpen() {
         return this.socket?.readyState === WebSocket.OPEN;
@@ -28,6 +29,7 @@ export class WebSocketClient extends AbstractSocketClient {
         if (this.socket) {
             return;
         }
+        this._destroyed = false;
         this.socket = new WebSocket(this.url, {
             origin: DEFAULT_ORIGIN,
             headers: this.config.options?.headers,
@@ -36,31 +38,35 @@ export class WebSocketClient extends AbstractSocketClient {
             agent: this.config.agent
         });
         this.socket.setMaxListeners(0);
-        const events = ['close', 'error', 'upgrade', 'message', 'open', 'ping', 'pong', 'unexpected-response'];
+        // Exclude 'close' from the generic forwarding loop — handled separately below
+        // so that reconnecting flag is set BEFORE the close event reaches listeners.
+        const events = ['error', 'upgrade', 'message', 'open', 'ping', 'pong', 'unexpected-response'];
         for (const event of events) {
             const handler = (...args) => this.emit(event, ...args);
             this.socketListeners.set(event, handler);
             this.socket?.on(event, handler);
         }
-        
-        this.socket.on('close', (code, reason) => {
-            this.emit('close', code, reason);
+        // Close handler: set reconnecting flag synchronously BEFORE emitting so that
+        // socket.js close listeners can check ws.reconnecting and avoid calling end().
+        const closeHandler = (code, reason) => {
             this.attemptReconnect(code, reason);
-        });
-        this.socketListeners.set('close-internal', (...args) => this.socket?.emit('close', ...args));
+            this.emit('close', code, reason);
+        };
+        this.socketListeners.set('close', closeHandler);
+        this.socket.on('close', closeHandler);
     }
     
     async attemptReconnect(code, reason) {
         if (this.reconnecting || code === 1000 || this.reconnectAttempts >= this.maxReconnectAttempts) {
             return;
         }
-        
+
         this.reconnecting = true;
         const delay = Math.min(
             this.reconnectDelay * Math.pow(2, this.reconnectAttempts),
             this.maxReconnectDelay
         );
-        
+
         this.emit('reconnecting', {
             attempt: this.reconnectAttempts + 1,
             maxAttempts: this.maxReconnectAttempts,
@@ -68,16 +74,23 @@ export class WebSocketClient extends AbstractSocketClient {
             code,
             reason: reason?.toString() || 'Connection closed'
         });
-        
+
         await new Promise(resolve => setTimeout(resolve, delay));
-        
+
+        // If close() was called during the delay, abort reconnect
+        if (this._destroyed) {
+            this.reconnecting = false;
+            return;
+        }
+
         this.reconnectAttempts++;
         this.reconnecting = false;
-        
+
         this.connect();
     }
     
     async close() {
+        this._destroyed = true;
         this.reconnecting = false;
         this.reconnectAttempts = 0;
         

package/lib/Socket/chats.js

@@ -13,7 +13,7 @@ import { USyncQuery, USyncUser } from '../WAUSync/index.js';
 import { makeSocket } from './socket.js';
 const MAX_SYNC_ATTEMPTS = 2;
 export const makeChatsSocket = (config) => {
-    const { logger, markOnlineOnConnect, fireInitQueries, appStateMacVerification, shouldIgnoreJid, shouldSyncHistoryMessage, getMessage } = config;
+    const { logger, markOnlineOnConnect, fireInitQueries, appStateMacVerification, shouldIgnoreJid, shouldSyncHistoryMessage, getMessage, awaitingSyncTimeoutMs = 5000 } = config;
     const sock = makeSocket(config);
     const { ev, ws, authState, generateMessageTag, sendNode, query, signalRepository, onUnexpectedError, sendUnifiedSession } = sock;
     let privacySettings;
@@ -30,7 +30,7 @@ export const makeChatsSocket = (config) => {
     let awaitingSyncTimeout;
     const placeholderResendCache = config.placeholderResendCache ||
         new LRUCache({
-            max: 5000,
+            max: 250,
             ttl: DEFAULT_CACHE_TTLS.MSG_RETRY * 1000, // 1 hour
             allowStale: false
         });
@@ -1006,18 +1006,17 @@ export const makeChatsSocket = (config) => {
             setTimeout(() => ev.flush(), 0);
             return;
         }
-        logger.info('History sync is enabled, awaiting notification with a 20s timeout.');
+        logger.info({ awaitingSyncTimeoutMs }, 'History sync is enabled, awaiting notification.');
         if (awaitingSyncTimeout) {
             clearTimeout(awaitingSyncTimeout);
         }
         awaitingSyncTimeout = setTimeout(() => {
             if (syncState === SyncState.AwaitingInitialSync) {
-                // TODO: investigate
-                logger.warn('Timeout in AwaitingInitialSync, forcing state to Online and flushing buffer');
+                logger.warn({ awaitingSyncTimeoutMs }, 'Timeout in AwaitingInitialSync, forcing state to Online and flushing buffer');
                 syncState = SyncState.Online;
                 ev.flush();
             }
-        }, 20000);
+        }, awaitingSyncTimeoutMs);
     });
     ev.on('lid-mapping.update', async ({ lid, pn }) => {
         try {

package/lib/Socket/messages-recv.js

@@ -19,25 +19,25 @@ export const makeMessagesRecvSocket = (config) => {
     const retryMutex = makeMutex();
     const msgRetryCache = config.msgRetryCounterCache ||
         new LRUCache({
-            max: 10000,
+            max: 1000,
             ttl: DEFAULT_CACHE_TTLS.MSG_RETRY * 1000,
             allowStale: false
         });
     const callOfferCache = config.callOfferCache ||
         new LRUCache({
-            max: 5000,
+            max: 500,
             ttl: DEFAULT_CACHE_TTLS.CALL_OFFER * 1000,
             allowStale: false
         });
     const placeholderResendCache = config.placeholderResendCache ||
         new LRUCache({
-            max: 5000,
+            max: 250,
             ttl: DEFAULT_CACHE_TTLS.MSG_RETRY * 1000,
             allowStale: false
         });
     // Debounce identity-change session refreshes per JID to avoid bursts
     const identityAssertDebounce = new LRUCache({ 
-        max: 1000, 
+        max: 250, 
         ttl: 10000,
         allowStale: false
     });
@@ -71,7 +71,7 @@ export const makeMessagesRecvSocket = (config) => {
             // metadata (LID details, timestamps, etc.) that the phone may omit
             await placeholderResendCache.set(messageKey?.id, msgData || true);
         }
-        await delay(2000);
+        await delay(50);
         if (!(await placeholderResendCache.get(messageKey?.id))) {
             logger.debug({ messageKey }, 'message received while resend requested');
             return 'RESOLVED';
@@ -1312,7 +1312,7 @@ export const makeMessagesRecvSocket = (config) => {
                                         logger.debug('Uploading pre-keys for error recovery');
                                         await uploadPreKeys(5);
                                         logger.debug('Waiting for server to process new pre-keys');
-                                        await delay(1000);
+                                        await delay(500);
                                     }
                                     catch (uploadErr) {
                                         logger.error({ uploadErr }, 'Pre-key upload failed, proceeding with retry anyway');
@@ -1582,7 +1582,12 @@ export const makeMessagesRecvSocket = (config) => {
         let isProcessing = false;
         // Number of nodes to process before yielding to event loop
         const BATCH_SIZE = 10;
+        const MAX_OFFLINE_NODES = 500;
         const enqueue = (type, node) => {
+            if (nodes.length >= MAX_OFFLINE_NODES) {
+                logger.warn({ queueSize: nodes.length }, 'offline node queue full, dropping oldest node');
+                nodes.shift();
+            }
             nodes.push({ type, node });
             if (isProcessing) {
                 return;

package/lib/Socket/messages-send.js

@@ -16,22 +16,22 @@ import { makeNewsletterSocket } from './newsletter.js';
 const _isNewsletterJid = (jid) => typeof jid === 'string' && jid.endsWith('@newsletter');
 
 export const makeMessagesSocket = (config) => {
-    const { logger, linkPreviewImageThumbnailWidth, generateHighQualityLinkPreview, options: httpRequestOptions, patchMessageBeforeSending, cachedGroupMetadata, enableRecentMessageCache, maxMsgRetryCount } = config;
+    const { logger, linkPreviewImageThumbnailWidth, generateHighQualityLinkPreview, options: httpRequestOptions, patchMessageBeforeSending, cachedGroupMetadata, enableRecentMessageCache, maxMsgRetryCount, phoneRequestDelayMs } = config;
     const sock = makeNewsletterSocket(config);
     const { ev, authState, messageMutex, signalRepository, upsertMessage, query, fetchPrivacySettings, sendNode, groupMetadata, groupToggleEphemeral } = sock;
     const userDevicesCache = config.userDevicesCache ||
         new LRUCache({
-            max: 5000,
+            max: 500,
             ttl: DEFAULT_CACHE_TTLS.USER_DEVICES * 1000, // 5 minutes
             allowStale: false
         });
     const peerSessionsCache = new LRUCache({
-        max: 5000,
+        max: 500,
         ttl: DEFAULT_CACHE_TTLS.USER_DEVICES * 1000,
         allowStale: false
     });
     // Initialize message retry manager if enabled
-    const messageRetryManager = enableRecentMessageCache ? new MessageRetryManager(logger, maxMsgRetryCount) : null;
+    const messageRetryManager = enableRecentMessageCache ? new MessageRetryManager(logger, maxMsgRetryCount, phoneRequestDelayMs) : null;
     // Prevent race conditions in Signal session encryption by user
     const encryptionMutex = makeKeyedMutex();
     let mediaConn;
@@ -1389,7 +1389,7 @@ export const makeMessagesSocket = (config) => {
                                 : { is_group_status_mention: 'true' }
                         }]
                     });
-                    await delay(2000);
+                    await delay(50);
                 } catch (error) {
                     logger.error(`Error sending status mention to ${id}: ${error}`);
                 }

package/lib/Store/make-in-memory-store.js

@@ -42,6 +42,7 @@ export const makeInMemoryStore = (config) => {
     const MAX_MESSAGES_PER_CHAT = config.maxMessagesPerChat || 2000;
     const MAX_CHATS = config.maxChats || 10000;
     const MAX_CONTACTS = config.maxContacts || 20000;
+    const MAX_PRESENCES = config.maxPresences || 500;
     const MESSAGE_CLEANUP_INTERVAL = config.messageCleanupIntervalMs || 5 * 60 * 1000; // 5 min
     let cleanupTimer = null;
     
@@ -70,11 +71,22 @@ export const makeInMemoryStore = (config) => {
                 if (chatId) {
                     chats.deleteById(chatId);
                     delete messages[chatId];
+                    delete groupMetadata[chatId];
                 }
             }
             logger.debug({ removed: toRemove }, 'cleaned old chats due to memory limit');
         }
         
+        // Limit presences
+        const presenceIds = Object.keys(presences);
+        if (presenceIds.length > MAX_PRESENCES) {
+            const toRemove = presenceIds.length - MAX_PRESENCES;
+            for (let i = 0; i < toRemove; i++) {
+                delete presences[presenceIds[i]];
+            }
+            logger.debug({ removed: toRemove }, 'cleaned old presences due to memory limit');
+        }
+
         // Limit contacts
         const contactIds = Object.keys(contacts);
         if (contactIds.length > MAX_CONTACTS) {

package/lib/Utils/auth-utils.js

@@ -16,7 +16,7 @@ import { PreKeyManager } from './pre-key-manager.js';
 export function makeCacheableSignalKeyStore(store, logger, _cache) {
     const cache = _cache ||
         new LRUCache({
-            max: 5000,
+            max: 500,
             ttl: DEFAULT_CACHE_TTLS.SIGNAL_STORE * 1000, // 5 minutes
             allowStale: false
         });

package/lib/Utils/event-buffer.js

@@ -24,6 +24,7 @@ const BUFFERABLE_EVENT_SET = new Set(BUFFERABLE_EVENT);
  */
 export const makeEventBuffer = (logger, config = {}) => {
     const ev = new EventEmitter();
+    ev.setMaxListeners(0); // Unlock listener limit for multi-bot environments
     const historyCache = new Set();
     let data = makeBufferData();
     let isBuffering = false;
@@ -157,7 +158,7 @@ export const makeEventBuffer = (logger, config = {}) => {
                             if (isBuffering && bufferCount === 1) {
                                 flush();
                             }
-                        }, 100);
+                        }, 10);
                         activeBufferedTimeouts.add(t);
                     }
                     return result;
@@ -169,7 +170,7 @@ export const makeEventBuffer = (logger, config = {}) => {
                     bufferCount = Math.max(0, bufferCount - 1);
                     if (bufferCount === 0) {
                         if (!flushPendingTimeout) {
-                            flushPendingTimeout = setTimeout(flush, 100);
+                            flushPendingTimeout = setTimeout(flush, 10);
                         }
                     }
                 }

package/lib/Utils/generics.js

@@ -281,7 +281,6 @@ export const getStatusFromReceiptType = (type) => {
     return status;
 };
 const CODE_MAP = {
-    conflict: DisconnectReason.connectionReplaced,
     'stream-replaced': DisconnectReason.streamReplaced,
     conflict: DisconnectReason.conflict,
     'precondition-failed': DisconnectReason.preconditionFailed

package/lib/Utils/message-retry-manager.js

@@ -4,7 +4,7 @@ const RECENT_MESSAGES_SIZE = 512;
 const MESSAGE_KEY_SEPARATOR = '\u0000';
 /** Timeout for session recreation - 1 hour */
 const RECREATE_SESSION_TIMEOUT = 60 * 60 * 1000; // 1 hour in milliseconds
-const PHONE_REQUEST_DELAY = 3000;
+const DEFAULT_PHONE_REQUEST_DELAY = 2000;
 // Retry reason codes matching WhatsApp Web's Signal error codes.
 export var RetryReason;
 (function (RetryReason) {
@@ -28,8 +28,9 @@ export var RetryReason;
 /** Error codes that indicate a MAC failure and require immediate session recreation */
 const MAC_ERROR_CODES = new Set([RetryReason.SignalErrorInvalidMessage, RetryReason.SignalErrorBadMac]);
 export class MessageRetryManager {
-    constructor(logger, maxMsgRetryCount) {
+    constructor(logger, maxMsgRetryCount, phoneRequestDelayMs) {
         this.logger = logger;
+        this.phoneRequestDelayMs = phoneRequestDelayMs ?? DEFAULT_PHONE_REQUEST_DELAY;
         this.recentMessagesMap = new LRUCache({
             max: RECENT_MESSAGES_SIZE,
             ttl: 5 * 60 * 1000,
@@ -189,7 +190,7 @@ export class MessageRetryManager {
     /**
      * Schedule a phone request with delay
      */
-    schedulePhoneRequest(messageId, callback, delay = PHONE_REQUEST_DELAY) {
+    schedulePhoneRequest(messageId, callback, delay = this.phoneRequestDelayMs) {
         // Cancel any existing request for this message
         this.cancelPendingPhoneRequest(messageId);
         this.pendingPhoneRequests[messageId] = setTimeout(() => {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "violetics",
   "type": "module",
-  "version": "7.0.16-alpha",
+  "version": "7.0.18-alpha",
   "description": "A WebSockets library for interacting with WhatsApp Web",
   "keywords": [
     "whatsapp",