violetics 7.0.11-alpha → 7.0.13-alpha

package/lib/Defaults/index.js

@@ -47,13 +47,13 @@ export const DEFAULT_CONNECTION_CONFIG = {
     version: version,
     browser: Browsers.macOS('Chrome'),
     waWebSocketUrl: 'wss://web.whatsapp.com/ws/chat',
-    connectTimeoutMs: 60000,
-    keepAliveIntervalMs: 30000,
+    connectTimeoutMs: 45000, // 45 seconds - faster than 60s
+    keepAliveIntervalMs: 20000, // 20 seconds - faster disconnect detection
     logger: logger.child({ class: 'baileys' }),
     emitOwnEvents: true,
-    defaultQueryTimeoutMs: 90000,
+    defaultQueryTimeoutMs: 60000, // 60 seconds - reduced from 90s
     customUploadHosts: [],
-    retryRequestDelayMs: 250,
+    retryRequestDelayMs: 200, // Faster retry (was 250ms)
     maxMsgRetryCount: 5,
     fireInitQueries: true,
     auth: undefined,
@@ -77,7 +77,21 @@ export const DEFAULT_CONNECTION_CONFIG = {
     countryCode: 'US',
     getMessage: async () => undefined,
     cachedGroupMetadata: async () => undefined,
-    makeSignalRepository: makeLibSignalRepository
+    makeSignalRepository: makeLibSignalRepository,
+    
+    // New connection stability options
+    maxReconnectAttempts: 5,
+    reconnectDelay: 2000,
+    maxReconnectDelay: 30000,
+    
+    // Memory management options
+    maxMessagesPerChat: 2000,
+    maxChats: 10000,
+    maxContacts: 20000,
+    messageCleanupIntervalMs: 5 * 60 * 1000, // 5 minutes
+    maxHistoryCacheSize: 15000,
+    bufferTimeoutMs: 30000,
+    maxBufferCount: 10000
 };
 export const MEDIA_PATH_MAP = {
     image: '/mms/image',

package/lib/Socket/Client/websocket.js

@@ -5,6 +5,7 @@ export class WebSocketClient extends AbstractSocketClient {
     constructor() {
         super(...arguments);
         this.socket = null;
+        this.socketListeners = new Map();
     }
     get isOpen() {
         return this.socket?.readyState === WebSocket.OPEN;
@@ -32,13 +33,19 @@ export class WebSocketClient extends AbstractSocketClient {
         this.socket.setMaxListeners(0);
         const events = ['close', 'error', 'upgrade', 'message', 'open', 'ping', 'pong', 'unexpected-response'];
         for (const event of events) {
-            this.socket?.on(event, (...args) => this.emit(event, ...args));
+            const handler = (...args) => this.emit(event, ...args);
+            this.socketListeners.set(event, handler);
+            this.socket?.on(event, handler);
         }
     }
     async close() {
         if (!this.socket) {
             return;
         }
+        for (const [event, handler] of this.socketListeners) {
+            this.socket.removeListener(event, handler);
+        }
+        this.socketListeners.clear();
         const closePromise = new Promise(resolve => {
             this.socket?.once('close', resolve);
         });

package/lib/Socket/chats.js

@@ -1,4 +1,4 @@
-import NodeCache from '@cacheable/node-cache';
+import { LRUCache } from 'lru-cache';
 import { Boom } from '@hapi/boom';
 import { proto } from '../../WAProto/index.js';
 import { DEFAULT_CACHE_TTLS, PROCESSABLE_HISTORY_TYPES } from '../Defaults/index.js';
@@ -29,9 +29,10 @@ export const makeChatsSocket = (config) => {
     // Timeout for AwaitingInitialSync state
     let awaitingSyncTimeout;
     const placeholderResendCache = config.placeholderResendCache ||
-        new NodeCache({
-            stdTTL: DEFAULT_CACHE_TTLS.MSG_RETRY, // 1 hour
-            useClones: false
+        new LRUCache({
+            max: 5000,
+            ttl: DEFAULT_CACHE_TTLS.MSG_RETRY * 1000, // 1 hour
+            allowStale: false
         });
     if (!config.placeholderResendCache) {
         config.placeholderResendCache = placeholderResendCache;

package/lib/Socket/messages-recv.js

@@ -1,4 +1,4 @@
-import NodeCache from '@cacheable/node-cache';
+import { LRUCache } from 'lru-cache';
 import { Boom } from '@hapi/boom';
 import { randomBytes } from 'crypto';
 import Long from 'long';
@@ -18,22 +18,29 @@ export const makeMessagesRecvSocket = (config) => {
     /** this mutex ensures that each retryRequest will wait for the previous one to finish */
     const retryMutex = makeMutex();
     const msgRetryCache = config.msgRetryCounterCache ||
-        new NodeCache({
-            stdTTL: DEFAULT_CACHE_TTLS.MSG_RETRY, // 1 hour
-            useClones: false
+        new LRUCache({
+            max: 10000,
+            ttl: DEFAULT_CACHE_TTLS.MSG_RETRY * 1000,
+            allowStale: false
         });
     const callOfferCache = config.callOfferCache ||
-        new NodeCache({
-            stdTTL: DEFAULT_CACHE_TTLS.CALL_OFFER, // 5 mins
-            useClones: false
+        new LRUCache({
+            max: 5000,
+            ttl: DEFAULT_CACHE_TTLS.CALL_OFFER * 1000,
+            allowStale: false
         });
     const placeholderResendCache = config.placeholderResendCache ||
-        new NodeCache({
-            stdTTL: DEFAULT_CACHE_TTLS.MSG_RETRY, // 1 hour
-            useClones: false
+        new LRUCache({
+            max: 5000,
+            ttl: DEFAULT_CACHE_TTLS.MSG_RETRY * 1000,
+            allowStale: false
         });
     // Debounce identity-change session refreshes per JID to avoid bursts
-    const identityAssertDebounce = new NodeCache({ stdTTL: 5, useClones: false });
+    const identityAssertDebounce = new LRUCache({ 
+        max: 1000, 
+        ttl: 10000,
+        allowStale: false
+    });
     let sendActiveReceipts = false;
     const fetchMessageHistory = async (count, oldestMsgKey, oldestMsgTimestamp) => {
         if (!authState.creds.me?.id) {
@@ -1662,11 +1669,22 @@ export const makeMessagesRecvSocket = (config) => {
             await upsertMessage(protoMsg, call.offline ? 'append' : 'notify');
         }
     });
-    ev.on('connection.update', ({ isOnline }) => {
+    ev.on('connection.update', ({ isOnline, connection }) => {
         if (typeof isOnline !== 'undefined') {
             sendActiveReceipts = isOnline;
             logger.trace(`sendActiveReceipts set to "${sendActiveReceipts}"`);
         }
+        // Clean up caches on disconnect - LRU cache will expire naturally, but we can reset
+        if (connection === 'close' || connection === 'loggedOut') {
+            try {
+                // LRU cache doesn't have clear(), but TTL handles expiration
+                // We can reset by creating new cache instances if needed
+                // For now just log that disconnection happened
+                logger.debug('connection closed, caches will expire via TTL');
+            } catch (e) {
+                logger.warn({ err: e }, 'error in cache cleanup');
+            }
+        }
     });
     return {
         ...sock,

package/lib/Socket/messages-send.js

@@ -1,4 +1,4 @@
-import NodeCache from '@cacheable/node-cache';
+import { LRUCache } from 'lru-cache';
 import { Boom } from '@hapi/boom';
 import { randomBytes } from 'crypto';
 import { proto } from '../../WAProto/index.js';
@@ -20,13 +20,15 @@ export const makeMessagesSocket = (config) => {
     const sock = makeNewsletterSocket(config);
     const { ev, authState, messageMutex, signalRepository, upsertMessage, query, fetchPrivacySettings, sendNode, groupMetadata, groupToggleEphemeral } = sock;
     const userDevicesCache = config.userDevicesCache ||
-        new NodeCache({
-            stdTTL: DEFAULT_CACHE_TTLS.USER_DEVICES, // 5 minutes
-            useClones: false
+        new LRUCache({
+            max: 5000,
+            ttl: DEFAULT_CACHE_TTLS.USER_DEVICES * 1000, // 5 minutes
+            allowStale: false
         });
-    const peerSessionsCache = new NodeCache({
-        stdTTL: DEFAULT_CACHE_TTLS.USER_DEVICES,
-        useClones: false
+    const peerSessionsCache = new LRUCache({
+        max: 5000,
+        ttl: DEFAULT_CACHE_TTLS.USER_DEVICES * 1000,
+        allowStale: false
     });
     // Initialize message retry manager if enabled
     const messageRetryManager = enableRecentMessageCache ? new MessageRetryManager(logger, maxMsgRetryCount) : null;

package/lib/Socket/socket.js

@@ -266,7 +266,11 @@ export const makeSocket = (config) => {
         }
         return [];
     };
-    const ev = makeEventBuffer(logger);
+    const ev = makeEventBuffer(logger, {
+        maxHistoryCacheSize: config.maxHistoryCacheSize,
+        bufferTimeoutMs: config.bufferTimeoutMs,
+        maxBufferCount: config.maxBufferCount
+    });
     const { creds } = authState;
     // add transaction capability
     const keys = addTransactionCapability(authState.keys, logger, transactionOpts);
@@ -276,6 +280,8 @@ export const makeSocket = (config) => {
     let keepAliveReq;
     let qrTimer;
     let closed = false;
+    let consecutivePingFailures = 0;
+    const MAX_PING_FAILURES = 3;
     /** log & process any unexpected errors */
     const onUnexpectedError = (err, msg) => {
         logger.error({ err }, `unexpected error in '${msg}'`);
@@ -487,14 +493,19 @@ export const makeSocket = (config) => {
         }
         closed = true;
         logger.info({ trace: error?.stack }, error ? 'connection errored' : 'connection closed');
-        clearInterval(keepAliveReq);
+        clearTimeout(keepAliveReq);
         clearTimeout(qrTimer);
-        ws.removeAllListeners('close');
-        ws.removeAllListeners('open');
-        ws.removeAllListeners('message');
+        consecutivePingFailures = 0;
+        ws.removeAllListeners();
+        if (ev.isBuffering()) {
+            ev.flush();
+        }
         if (!ws.isClosed && !ws.isClosing) {
             try {
-                await ws.close();
+                await Promise.race([
+                    ws.close(),
+                    new Promise(resolve => setTimeout(resolve, 5000))
+                ]);
             }
             catch { }
         }
@@ -505,7 +516,8 @@ export const makeSocket = (config) => {
                 date: new Date()
             }
         });
-        ev.removeAllListeners('connection.update');
+        noise.destroy();
+        ev.removeAllListeners();
     };
     const waitForSocketOpen = async () => {
         if (ws.isOpen) {
@@ -528,37 +540,57 @@ export const makeSocket = (config) => {
             ws.off('error', onClose);
         });
     };
-    const startKeepAliveRequest = () => (keepAliveReq = setInterval(() => {
-        if (!lastDateRecv) {
-            lastDateRecv = new Date();
-        }
-        const diff = Date.now() - lastDateRecv.getTime();
-        /*
-            check if it's been a suspicious amount of time since the server responded with our last seen
-            it could be that the network is down
-        */
-        if (diff > keepAliveIntervalMs + 60000) {
-            void end(new Boom('Connection was lost', { statusCode: DisconnectReason.connectionLost }));
-        }
-        else if (ws.isOpen) {
-            // if its all good, send a keep alive request
-            query({
-                tag: 'iq',
-                attrs: {
-                    id: generateMessageTag(),
-                    to: S_WHATSAPP_NET,
-                    type: 'get',
-                    xmlns: 'w:p'
-                },
-                content: [{ tag: 'ping', attrs: {} }]
-            }).catch(err => {
-                logger.error({ trace: err.stack }, 'error in sending keep alive');
-            });
-        }
-        else {
-            logger.warn('keep alive called when WS not open');
-        }
-    }, keepAliveIntervalMs));
+    const startKeepAliveRequest = () => {
+        const scheduleNextPing = () => {
+            keepAliveReq = setTimeout(async () => {
+                if (closed) {
+                    return;
+                }
+                if (!lastDateRecv) {
+                    lastDateRecv = new Date();
+                }
+                const diff = Date.now() - lastDateRecv.getTime();
+                if (diff > keepAliveIntervalMs * 2 + 5000) {
+                    logger.warn({ diff, keepAliveIntervalMs }, 'connection silent for too long');
+                    void end(new Boom('Connection was lost', { statusCode: DisconnectReason.connectionLost }));
+                    return;
+                }
+                if (ws.isOpen) {
+                    try {
+                        await query({
+                            tag: 'iq',
+                            attrs: {
+                                id: generateMessageTag(),
+                                to: S_WHATSAPP_NET,
+                                type: 'get',
+                                xmlns: 'w:p'
+                            },
+                            content: [{ tag: 'ping', attrs: {} }]
+                        });
+                        consecutivePingFailures = 0;
+                    }
+                    catch (err) {
+                        consecutivePingFailures++;
+                        logger.error({ trace: err.stack, consecutivePingFailures, maxFailures: MAX_PING_FAILURES }, 'error in sending keep alive');
+                        if (consecutivePingFailures >= MAX_PING_FAILURES) {
+                            logger.warn('max ping failures reached, terminating connection');
+                            void end(new Boom('Connection was lost (ping failures)', {
+                                statusCode: DisconnectReason.connectionLost
+                            }));
+                            return;
+                        }
+                    }
+                }
+                else {
+                    logger.warn('keep alive called when WS not open');
+                }
+                if (!closed) {
+                    scheduleNextPing();
+                }
+            }, keepAliveIntervalMs);
+        };
+        scheduleNextPing();
+    };
     /** i have no idea why this exists. pls enlighten me */
     const sendPassiveIq = (tag) => query({
         tag: 'iq',
@@ -571,27 +603,63 @@ export const makeSocket = (config) => {
     });
     /** logout & invalidate connection */
     const logout = async (msg) => {
+        logger.info({ msg }, 'initiating logout');
+        
+        // Prevent reconnect on logout
+        if (ws) {
+            ws.maxReconnectAttempts = 0;
+            ws.reconnecting = false;
+        }
+        
         const jid = authState.creds.me?.id;
-        if (jid) {
-            await sendNode({
-                tag: 'iq',
-                attrs: {
-                    to: S_WHATSAPP_NET,
-                    type: 'set',
-                    id: generateMessageTag(),
-                    xmlns: 'md'
-                },
-                content: [
-                    {
-                        tag: 'remove-companion-device',
-                        attrs: {
-                            jid,
-                            reason: 'user_initiated'
+        
+        // Try to send logout IQ to WA server
+        try {
+            if (jid) {
+                const logoutNode = {
+                    tag: 'iq',
+                    attrs: {
+                        to: S_WHATSAPP_NET,
+                        type: 'set',
+                        id: generateMessageTag(),
+                        xmlns: 'md'
+                    },
+                    content: [
+                        {
+                            tag: 'remove-companion-device',
+                            attrs: {
+                                jid,
+                                reason: 'user_initiated'
+                            }
                         }
-                    }
-                ]
-            });
+                    ]
+                };
+                await sendNode(logoutNode);
+                logger.info({ jid }, 'sent logout IQ to server');
+            }
+        } catch (e) {
+            logger.warn({ err: e }, 'failed to send logout IQ, continuing with local logout');
         }
+        
+        // Emit proper logout event BEFORE ending connection
+        ev.emit('connection.update', {
+            connection: 'loggedOut',
+            lastDisconnect: {
+                error: new Boom(msg || 'Intentional Logout', { statusCode: DisconnectReason.loggedOut }),
+                date: new Date()
+            },
+            isOnline: false,
+            qr: undefined
+        });
+        
+        // Clear sensitive credentials
+        if (authState.creds) {
+            authState.creds.me = undefined;
+            authState.creds.lid = undefined;
+            authState.creds.deviceName = undefined;
+        }
+        
+        // End the connection
         void end(new Boom(msg || 'Intentional Logout', { statusCode: DisconnectReason.loggedOut }));
     };
     const requestPairingCode = async (phoneNumber, customPairingCode) => {
@@ -681,6 +749,8 @@ export const makeSocket = (config) => {
     };
     ws.on('message', onMessageReceived);
     ws.on('open', async () => {
+        // Reset reconnect attempts on successful connection
+        ws.reconnectAttempts = 0;
         try {
             await validateConnection();
         }
@@ -690,7 +760,26 @@ export const makeSocket = (config) => {
         }
     });
     ws.on('error', mapWebSocketError(end));
-    ws.on('close', () => void end(new Boom('Connection Terminated', { statusCode: DisconnectReason.connectionClosed })));
+    ws.on('close', (code, reason) => {
+        // Check if reconnecting - if so, don't end the connection
+        if (ws.reconnecting) {
+            logger.info({ code, reason: reason?.toString() }, 'connection closed, waiting for reconnect');
+            return;
+        }
+        void end(new Boom('Connection Terminated', { statusCode: DisconnectReason.connectionClosed, data: { code, reason: reason?.toString() } }));
+    });
+    ws.on('reconnecting', (info) => {
+        ev.emit('connection.update', {
+            connection: 'reconnecting',
+            lastDisconnect: {
+                error: new Boom('Reconnecting', { statusCode: DisconnectReason.connectionClosed }),
+                date: new Date()
+            },
+            reconnectAttempt: info.attempt,
+            maxReconnectAttempts: info.maxAttempts,
+            reconnectDelay: info.delay
+        });
+    });
     // the server terminated the connection
     ws.on('CB:xmlstreamend', () => void end(new Boom('Connection Terminated by Server', { statusCode: DisconnectReason.connectionClosed })));
     // QR gen
@@ -929,7 +1018,13 @@ export const makeSocket = (config) => {
         waitForConnectionUpdate: bindWaitForConnectionUpdate(ev),
         sendWAMBuffer,
         executeUSyncQuery,
-        onWhatsApp
+        onWhatsApp,
+        get connectionHealth() {
+            return {
+                lastMessageReceived: lastDateRecv,
+                consecutivePingFailures
+            };
+        }
     };
 };
 /**

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

@@ -37,6 +37,75 @@ export const makeInMemoryStore = (config) => {
     const state = { connection: 'close' };
     const labels = new ObjectRepository();
     const labelAssociations = new KeyedDB(labelAssociationKey, labelAssociationKey.key);
+    
+    // Memory management - configurable limits
+    const MAX_MESSAGES_PER_CHAT = config.maxMessagesPerChat || 2000;
+    const MAX_CHATS = config.maxChats || 10000;
+    const MAX_CONTACTS = config.maxContacts || 20000;
+    const MESSAGE_CLEANUP_INTERVAL = config.messageCleanupIntervalMs || 5 * 60 * 1000; // 5 min
+    let cleanupTimer = null;
+    
+    // Check and enforce memory limits
+    const enforceMemoryLimits = () => {
+        // Cleanup old messages if exceeds limit
+        for (const jid in messages) {
+            const list = messages[jid];
+            if (list && list.array && list.array.length > MAX_MESSAGES_PER_CHAT) {
+                const excess = list.array.length - MAX_MESSAGES_PER_CHAT;
+                list.array.splice(0, excess);
+                logger.debug({ jid, removed: excess, remaining: list.array.length }, 'cleaned excess messages from chat');
+            }
+        }
+        
+        // Limit total chats
+        if (chats.length > MAX_CHATS) {
+            const toRemove = chats.length - MAX_CHATS;
+            const sortedChats = [...chats].sort((a, b) => {
+                const aTime = a.conversationTimestamp || 0;
+                const bTime = b.conversationTimestamp || 0;
+                return aTime - bTime;
+            });
+            for (let i = 0; i < toRemove; i++) {
+                const chatId = sortedChats[i]?.id;
+                if (chatId) {
+                    chats.deleteById(chatId);
+                    delete messages[chatId];
+                }
+            }
+            logger.debug({ removed: toRemove }, 'cleaned old chats due to memory limit');
+        }
+        
+        // Limit contacts
+        const contactIds = Object.keys(contacts);
+        if (contactIds.length > MAX_CONTACTS) {
+            const toRemove = contactIds.length - MAX_CONTACTS;
+            const sortedContacts = contactIds
+                .map(id => ({ id, contact: contacts[id] }))
+                .sort((a, b) => {
+                    const aTime = a.contact?.lastSeen || 0;
+                    const bTime = b.contact?.lastSeen || 0;
+                    return aTime - bTime;
+                });
+            for (let i = 0; i < toRemove; i++) {
+                delete contacts[sortedContacts[i].id];
+            }
+            logger.debug({ removed: toRemove }, 'cleaned old contacts due to memory limit');
+        }
+    };
+    
+    // Start periodic cleanup
+    const startMemoryCleanup = () => {
+        if (cleanupTimer) return;
+        cleanupTimer = setInterval(enforceMemoryLimits, MESSAGE_CLEANUP_INTERVAL);
+        cleanupTimer.unref(); // Don't block process exit
+    };
+    
+    const stopMemoryCleanup = () => {
+        if (cleanupTimer) {
+            clearInterval(cleanupTimer);
+            cleanupTimer = null;
+        }
+    };
     const assertMessageList = (jid) => {
         if (!messages[jid]) {
             messages[jid] = makeMessagesDictionary();
@@ -65,6 +134,13 @@ export const makeInMemoryStore = (config) => {
     const bind = (ev) => {
         ev.on('connection.update', update => {
             Object.assign(state, update);
+            
+            // Start cleanup when connected, stop when disconnected
+            if (update.connection === 'open') {
+                startMemoryCleanup();
+            } else if (update.connection === 'close' || update.connection === 'loggedOut') {
+                stopMemoryCleanup();
+            }
         });
         ev.on('messaging-history.set', ({ chats: newChats, contacts: newContacts, messages: newMessages, isLatest, syncType }) => {
             if (syncType === proto.HistorySync.HistorySyncType.ON_DEMAND) {
@@ -395,6 +471,44 @@ export const makeInMemoryStore = (config) => {
                 const json = JSON.parse(jsonStr);
                 fromJSON(json);
             }
+        },
+        /** Clear all stored data - useful for logout */
+        clear: () => {
+            chats.clear();
+            for (const key of Object.keys(messages)) {
+                delete messages[key];
+            }
+            for (const key of Object.keys(contacts)) {
+                delete contacts[key];
+            }
+            for (const key of Object.keys(groupMetadata)) {
+                delete groupMetadata[key];
+            }
+            for (const key of Object.keys(presences)) {
+                delete presences[key];
+            }
+            labels.clear();
+            labelAssociations.clear();
+            stopMemoryCleanup();
+            logger.info('Cleared all store data');
+        },
+        /** Get memory usage stats */
+        getMemoryStats: () => {
+            let totalMessages = 0;
+            for (const jid in messages) {
+                totalMessages += messages[jid]?.array?.length || 0;
+            }
+            return {
+                chats: chats.length,
+                messages: totalMessages,
+                contacts: Object.keys(contacts).length,
+                groups: Object.keys(groupMetadata).length,
+                labels: labels.count(),
+                labelAssociations: labelAssociations.length,
+                maxMessagesPerChat: MAX_MESSAGES_PER_CHAT,
+                maxChats: MAX_CHATS,
+                maxContacts: MAX_CONTACTS
+            };
         }
     };
 };

package/lib/Types/index.js

@@ -23,5 +23,8 @@ export var DisconnectReason;
     DisconnectReason[DisconnectReason["multideviceMismatch"] = 411] = "multideviceMismatch";
     DisconnectReason[DisconnectReason["forbidden"] = 403] = "forbidden";
     DisconnectReason[DisconnectReason["unavailableService"] = 503] = "unavailableService";
+    DisconnectReason[DisconnectReason["streamReplaced"] = 405] = "streamReplaced";
+    DisconnectReason[DisconnectReason["conflict"] = 409] = "conflict";
+    DisconnectReason[DisconnectReason["preconditionFailed"] = 412] = "preconditionFailed";
 })(DisconnectReason || (DisconnectReason = {}));
 //# sourceMappingURL=index.js.map

package/lib/Utils/auth-utils.js

@@ -1,4 +1,4 @@
-import NodeCache from '@cacheable/node-cache';
+import { LRUCache } from 'lru-cache';
 import { AsyncLocalStorage } from 'async_hooks';
 import { Mutex } from 'async-mutex';
 import { randomBytes } from 'crypto';
@@ -15,10 +15,10 @@ import { PreKeyManager } from './pre-key-manager.js';
  */
 export function makeCacheableSignalKeyStore(store, logger, _cache) {
     const cache = _cache ||
-        new NodeCache({
-            stdTTL: DEFAULT_CACHE_TTLS.SIGNAL_STORE, // 5 minutes
-            useClones: false,
-            deleteOnExpire: true
+        new LRUCache({
+            max: 5000,
+            ttl: DEFAULT_CACHE_TTLS.SIGNAL_STORE * 1000, // 5 minutes
+            allowStale: false
         });
     // Mutex for protecting cache operations
     const cacheMutex = new Mutex();

package/lib/Utils/event-buffer.js

@@ -22,16 +22,17 @@ const BUFFERABLE_EVENT_SET = new Set(BUFFERABLE_EVENT);
  * The event buffer logically consolidates different events into a single event
  * making the data processing more efficient.
  */
-export const makeEventBuffer = (logger) => {
+export const makeEventBuffer = (logger, config = {}) => {
     const ev = new EventEmitter();
     const historyCache = new Set();
     let data = makeBufferData();
     let isBuffering = false;
     let bufferTimeout = null;
-    let flushPendingTimeout = null; // Add a specific timer for the debounced flush to prevent leak
+    let flushPendingTimeout = null;
     let bufferCount = 0;
-    const MAX_HISTORY_CACHE_SIZE = 10000; // Limit the history cache size to prevent memory bloat
-    const BUFFER_TIMEOUT_MS = 30000; // 30 seconds
+    let activeBufferedTimeouts = new Set();
+    const MAX_HISTORY_CACHE_SIZE = config.maxHistoryCacheSize || 10000;
+    const BUFFER_TIMEOUT_MS = config.bufferTimeoutMs || 30000;
     // take the generic event and fire it as a baileys event
     ev.on('event', (map) => {
         for (const event in map) {
@@ -55,6 +56,12 @@ export const makeEventBuffer = (logger) => {
         }
         // Always increment count when requested
         bufferCount++;
+        
+        // Auto-flush if buffer count exceeds limit
+        if (bufferCount > MAX_BUFFER_COUNT) {
+            logger.debug({ bufferCount }, 'buffer count exceeded limit, auto-flushing');
+            flush();
+        }
     }
     function flush() {
         if (!isBuffering) {
@@ -143,13 +150,14 @@ export const makeEventBuffer = (logger) => {
                 buffer();
                 try {
                     const result = await work(...args);
-                    // If this is the only buffer, flush after a small delay
                     if (bufferCount === 1) {
-                        setTimeout(() => {
+                        const t = setTimeout(() => {
+                            activeBufferedTimeouts.delete(t);
                             if (isBuffering && bufferCount === 1) {
                                 flush();
                             }
-                        }, 100); // Small delay to allow nested buffers
+                        }, 100);
+                        activeBufferedTimeouts.add(t);
                     }
                     return result;
                 }
@@ -159,7 +167,6 @@ export const makeEventBuffer = (logger) => {
                 finally {
                     bufferCount = Math.max(0, bufferCount - 1);
                     if (bufferCount === 0) {
-                        // Only schedule ONE timeout, not 10,000
                         if (!flushPendingTimeout) {
                             flushPendingTimeout = setTimeout(flush, 100);
                         }
@@ -169,7 +176,25 @@ export const makeEventBuffer = (logger) => {
         },
         on: (...args) => ev.on(...args),
         off: (...args) => ev.off(...args),
-        removeAllListeners: (...args) => ev.removeAllListeners(...args)
+        removeAllListeners: (...args) => {
+            if (bufferTimeout) {
+                clearTimeout(bufferTimeout);
+                bufferTimeout = null;
+            }
+            if (flushPendingTimeout) {
+                clearTimeout(flushPendingTimeout);
+                flushPendingTimeout = null;
+            }
+            for (const t of activeBufferedTimeouts) {
+                clearTimeout(t);
+            }
+            activeBufferedTimeouts.clear();
+            isBuffering = false;
+            bufferCount = 0;
+            historyCache.clear();
+            data = makeBufferData();
+            return ev.removeAllListeners(...args);
+        }
     };
 };
 const makeBufferData = () => {

package/lib/Utils/generics.js

@@ -281,7 +281,10 @@ export const getStatusFromReceiptType = (type) => {
     return status;
 };
 const CODE_MAP = {
-    conflict: DisconnectReason.connectionReplaced
+    conflict: DisconnectReason.connectionReplaced,
+    'stream-replaced': DisconnectReason.streamReplaced,
+    conflict: DisconnectReason.conflict,
+    'precondition-failed': DisconnectReason.preconditionFailed
 };
 /**
  * Stream errors generally provide a reason, map that to a baileys DisconnectReason

package/lib/Utils/identity-change-handler.js

@@ -1,4 +1,4 @@
-import NodeCache from '@cacheable/node-cache';
+import { LRUCache } from 'lru-cache';
 import { areJidsSameUser, getBinaryNodeChild, jidDecode } from '../WABinary/index.js';
 import { isStringNullOrEmpty } from './generics.js';
 export async function handleIdentityChange(node, ctx) {

package/lib/Utils/noise-handler.js

@@ -5,6 +5,7 @@ import { decodeBinaryNode } from '../WABinary/index.js';
 import { aesDecryptGCM, aesEncryptGCM, Curve, hkdf, sha256 } from './crypto.js';
 const IV_LENGTH = 12;
 const EMPTY_BUFFER = Buffer.alloc(0);
+const MAX_BUFFER_SIZE = 10 * 1024 * 1024; // 10MB max buffer cap
 const generateIV = (counter) => {
     const iv = new ArrayBuffer(IV_LENGTH);
     new DataView(iv).setUint32(8, counter);
@@ -194,7 +195,18 @@ export const makeNoiseHandler = ({ keyPair: { private: privateKey, public: publi
             else {
                 inBytes = Buffer.concat([inBytes, newData]);
             }
+            if (inBytes.length > MAX_BUFFER_SIZE) {
+                logger.error({ bufferSize: inBytes.length }, 'noise handler buffer exceeded max size, clearing');
+                inBytes = Buffer.alloc(0);
+                return;
+            }
             await processData(onFrame);
+        },
+        destroy: () => {
+            inBytes = Buffer.alloc(0);
+            transport = null;
+            pendingOnFrame = null;
+            isWaitingForTransport = false;
         }
     };
 };

package/package.json

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