violetics 7.0.3-alpha → 7.0.5-alpha

package/lib/Defaults/index.js

@@ -53,7 +53,7 @@ export const DEFAULT_CONNECTION_CONFIG = {
     emitOwnEvents: true,
     defaultQueryTimeoutMs: 60000,
     customUploadHosts: [],
-    retryRequestDelayMs: 250,
+    retryRequestDelayMs: 0,
     maxMsgRetryCount: 3,
     fireInitQueries: true,
     auth: undefined,

package/lib/Socket/Client/websocket.js

@@ -5,6 +5,7 @@ export class WebSocketClient extends AbstractSocketClient {
     constructor() {
         super(...arguments);
         this.socket = null;
+        this._eventForwarders = [];
     }
     get isOpen() {
         return this.socket?.readyState === WebSocket.OPEN;
@@ -31,14 +32,22 @@ export class WebSocketClient extends AbstractSocketClient {
         });
         this.socket.setMaxListeners(0);
         const events = ['close', 'error', 'upgrade', 'message', 'open', 'ping', 'pong', 'unexpected-response'];
+        this._eventForwarders = [];
         for (const event of events) {
-            this.socket?.on(event, (...args) => this.emit(event, ...args));
+            const handler = (...args) => this.emit(event, ...args);
+            this.socket?.on(event, handler);
+            this._eventForwarders.push({ event, handler });
         }
     }
     async close() {
         if (!this.socket) {
             return;
         }
+        // Remove all forwarding listeners to prevent memory leaks
+        for (const { event, handler } of this._eventForwarders) {
+            this.socket?.off(event, handler);
+        }
+        this._eventForwarders = [];
         const closePromise = new Promise(resolve => {
             this.socket?.once('close', resolve);
         });

package/lib/Socket/chats.js

@@ -1,4 +1,5 @@
 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';
@@ -12,12 +13,12 @@ import { getBinaryNodeChild, getBinaryNodeChildren, isLidUser, isPnUser, jidDeco
 import { USyncQuery, USyncUser } from '../WAUSync/index.js';
 import { makeSocket } from './socket.js';
 const MAX_SYNC_ATTEMPTS = 2;
-// Lia@Note 08-02-26 --- I know it's not efficient for RSS ಥ⁠‿⁠ಥ
-const USER_ID_CACHE = new Map();
 export const makeChatsSocket = (config) => {
     const { logger, markOnlineOnConnect, fireInitQueries, appStateMacVerification, shouldIgnoreJid, shouldSyncHistoryMessage, getMessage } = config;
     const sock = makeSocket(config);
     const { ev, ws, authState, generateMessageTag, sendNode, query, signalRepository, onUnexpectedError, sendUnifiedSession } = sock;
+    // Scoped per-connection with LRU to prevent unbounded memory growth
+    const USER_ID_CACHE = new LRUCache({ max: 5000, ttl: 30 * 60 * 1000 });
     let privacySettings;
     let syncState = SyncState.Connecting;
     /** this mutex ensures that messages are processed in order */

package/lib/Socket/messages-recv.js

@@ -7,6 +7,8 @@ import { DEFAULT_CACHE_TTLS, KEY_BUNDLE_TYPE, MIN_PREKEY_COUNT, PLACEHOLDER_MAX_
 import { WAMessageStatus, WAMessageStubType } from '../Types/index.js';
 import { aesDecryptCTR, aesEncryptGCM, cleanMessage, Curve, decodeMediaRetryNode, decodeMessageNode, decryptMessageNode, delay, derivePairingCodeKey, encodeBigEndian, encodeSignedDeviceIdentity, extractAddressingContext, getCallStatusFromNode, getHistoryMsg, getNextPreKeys, getStatusFromReceiptType, handleIdentityChange, hkdf, MISSING_KEYS_ERROR_TEXT, NACK_REASONS, NO_MESSAGE_FOUND_ERROR_TEXT, toNumber, unixTimestampSeconds, xmppPreKey, xmppSignedPreKey } from '../Utils/index.js';
 import { makeMutex } from '../Utils/make-mutex.js';
+import { makeOfflineNodeProcessor } from '../Utils/offline-node-processor.js';
+import { buildAckStanza } from '../Utils/stanza-ack.js';
 import { areJidsSameUser, binaryNodeToString, getAllBinaryNodeChildren, getBinaryNodeChild, getBinaryNodeChildBuffer, getBinaryNodeChildren, getBinaryNodeChildString, isJidGroup, isJidNewsletter, isJidStatusBroadcast, isLidUser, isPnUser, jidDecode, jidNormalizedUser, S_WHATSAPP_NET } from '../WABinary/index.js';
 import { extractGroupMetadata } from './groups.js';
 import { makeMessagesSocket } from './messages-send.js';
@@ -63,7 +65,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(500);
         if (!(await placeholderResendCache.get(messageKey?.id))) {
             logger.debug({ messageKey }, 'message received while resend requested');
             return 'RESOLVED';
@@ -217,32 +219,9 @@ export const makeMessagesRecvSocket = (config) => {
                 break;
         }
     };
-    const sendMessageAck = async ({ tag, attrs, content }, errorCode) => {
-        const stanza = {
-            tag: 'ack',
-            attrs: {
-                id: attrs.id,
-                to: attrs.from,
-                class: tag
-            }
-        };
-        if (!!errorCode) {
-            stanza.attrs.error = errorCode.toString();
-        }
-        if (!!attrs.participant) {
-            stanza.attrs.participant = attrs.participant;
-        }
-        if (!!attrs.recipient) {
-            stanza.attrs.recipient = attrs.recipient;
-        }
-        if (!!attrs.type &&
-            (tag !== 'message' || getBinaryNodeChild({ tag, attrs, content }, 'unavailable') || errorCode !== 0)) {
-            stanza.attrs.type = attrs.type;
-        }
-        if (tag === 'message' && getBinaryNodeChild({ tag, attrs, content }, 'unavailable')) {
-            stanza.attrs.from = authState.creds.me.id;
-        }
-        logger.debug({ recv: { tag, attrs }, sent: stanza.attrs }, 'sent ack');
+    const sendMessageAck = async (node, errorCode) => {
+        const stanza = buildAckStanza(node, errorCode, authState.creds.me.id);
+        logger.debug({ recv: { tag: node.tag, attrs: node.attrs }, sent: stanza.attrs }, 'sent ack');
         await sendNode(stanza);
     };
     const rejectCall = async (callId, callFrom) => {
@@ -995,7 +974,7 @@ export const makeMessagesRecvSocket = (config) => {
             ]);
         }
         finally {
-            await sendMessageAck(node);
+            await sendMessageAck(node).catch(ackErr => logger.error({ ackErr }, 'failed to ack receipt'));
         }
     };
     const handleNotification = async (node) => {
@@ -1030,7 +1009,7 @@ export const makeMessagesRecvSocket = (config) => {
             ]);
         }
         finally {
-            await sendMessageAck(node);
+            await sendMessageAck(node).catch(ackErr => logger.error({ ackErr }, 'failed to ack notification'));
         }
     };
     const handleMessage = async (node) => {
@@ -1046,36 +1025,34 @@ export const makeMessagesRecvSocket = (config) => {
             await sendMessageAck(node, NACK_REASONS.MissingMessageSecret);
             return;
         }
-        const { fullMessage: msg, category, author, decrypt } = decryptMessageNode(node, authState.creds.me.id, authState.creds.me.lid || '', signalRepository, logger);
-        const alt = msg.key.participantAlt || msg.key.remoteJidAlt;
-        // store new mappings we didn't have before
-        if (!!alt) {
-            const altServer = jidDecode(alt)?.server;
-            const primaryJid = msg.key.participant || msg.key.remoteJid;
-            if (altServer === 'lid') {
-                if (!(await signalRepository.lidMapping.getPNForLID(alt))) {
-                    await signalRepository.lidMapping.storeLIDPNMappings([{ lid: alt, pn: primaryJid }]);
-                    await signalRepository.migrateSession(primaryJid, alt);
+        let acked = false;
+        try {
+            const { fullMessage: msg, category, author, decrypt } = decryptMessageNode(node, authState.creds.me.id, authState.creds.me.lid || '', signalRepository, logger);
+            const alt = msg.key.participantAlt || msg.key.remoteJidAlt;
+            // store new mappings we didn't have before
+            if (!!alt) {
+                const altServer = jidDecode(alt)?.server;
+                const primaryJid = msg.key.participant || msg.key.remoteJid;
+                if (altServer === 'lid') {
+                    if (!(await signalRepository.lidMapping.getPNForLID(alt))) {
+                        await signalRepository.lidMapping.storeLIDPNMappings([{ lid: alt, pn: primaryJid }]);
+                        await signalRepository.migrateSession(primaryJid, alt);
+                    }
+                }
+                else {
+                    await signalRepository.lidMapping.storeLIDPNMappings([{ lid: primaryJid, pn: alt }]);
+                    await signalRepository.migrateSession(alt, primaryJid);
                 }
             }
-            else {
-                await signalRepository.lidMapping.storeLIDPNMappings([{ lid: primaryJid, pn: alt }]);
-                await signalRepository.migrateSession(alt, primaryJid);
-            }
-        }
-        if (msg.key?.remoteJid && msg.key?.id && messageRetryManager) {
-            messageRetryManager.addRecentMessage(msg.key.remoteJid, msg.key.id, msg.message);
-            logger.debug({
-                jid: msg.key.remoteJid,
-                id: msg.key.id
-            }, 'Added message to recent cache for retry receipts');
-        }
-        try {
             await messageMutex.mutex(async () => {
                 await decrypt();
+                if (msg.key?.remoteJid && msg.key?.id && msg.message && messageRetryManager) {
+                    messageRetryManager.addRecentMessage(msg.key.remoteJid, msg.key.id, msg.message);
+                }
                 // message failed to decrypt
                 if (msg.messageStubType === proto.WebMessageInfo.StubType.CIPHERTEXT && msg.category !== 'peer') {
                     if (msg?.messageStubParameters?.[0] === MISSING_KEYS_ERROR_TEXT) {
+                        acked = true;
                         return sendMessageAck(node, NACK_REASONS.ParsingError);
                     }
                     if (msg.messageStubParameters?.[0] === NO_MESSAGE_FOUND_ERROR_TEXT) {
@@ -1087,11 +1064,13 @@ export const makeMessagesRecvSocket = (config) => {
                             unavailableType === 'hosted_unavailable_fanout' ||
                             unavailableType === 'view_once_unavailable_fanout') {
                             logger.debug({ msgId: msg.key.id, unavailableType }, 'skipping placeholder resend for excluded unavailable type');
+                            acked = true;
                             return sendMessageAck(node);
                         }
                         const messageAge = unixTimestampSeconds() - toNumber(msg.messageTimestamp);
                         if (messageAge > PLACEHOLDER_MAX_AGE_SECONDS) {
                             logger.debug({ msgId: msg.key.id, messageAge }, 'skipping placeholder resend for old message');
+                            acked = true;
                             return sendMessageAck(node);
                         }
                         // Request the real content from the phone via placeholder resend PDO.
@@ -1115,19 +1094,20 @@ export const makeMessagesRecvSocket = (config) => {
                         };
                         requestPlaceholderResend(cleanKey, msgData)
                             .then(requestId => {
-                            if (requestId && requestId !== 'RESOLVED') {
-                                logger.debug({ msgId: msg.key.id, requestId }, 'requested placeholder resend for unavailable message');
-                                ev.emit('messages.update', [
-                                    {
-                                        key: msg.key,
-                                        update: { messageStubParameters: [NO_MESSAGE_FOUND_ERROR_TEXT, requestId] }
-                                    }
-                                ]);
-                            }
-                        })
+                                if (requestId && requestId !== 'RESOLVED') {
+                                    logger.debug({ msgId: msg.key.id, requestId }, 'requested placeholder resend for unavailable message');
+                                    ev.emit('messages.update', [
+                                        {
+                                            key: msg.key,
+                                            update: { messageStubParameters: [NO_MESSAGE_FOUND_ERROR_TEXT, requestId] }
+                                        }
+                                    ]);
+                                }
+                            })
                             .catch(err => {
-                            logger.warn({ err, msgId: msg.key.id }, 'failed to request placeholder resend for unavailable message');
-                        });
+                                logger.warn({ err, msgId: msg.key.id }, 'failed to request placeholder resend for unavailable message');
+                            });
+                        acked = true;
                         await sendMessageAck(node);
                         // Don't return — fall through to upsertMessage so the stub is emitted
                     }
@@ -1137,6 +1117,7 @@ export const makeMessagesRecvSocket = (config) => {
                             const messageAge = unixTimestampSeconds() - toNumber(msg.messageTimestamp);
                             if (messageAge > STATUS_EXPIRY_SECONDS) {
                                 logger.debug({ msgId: msg.key.id, messageAge, remoteJid: msg.key.remoteJid }, 'skipping retry for expired status message');
+                                acked = true;
                                 return sendMessageAck(node);
                             }
                         }
@@ -1157,7 +1138,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(200);
                                     }
                                     catch (uploadErr) {
                                         logger.error({ uploadErr }, 'Pre-key upload failed, proceeding with retry anyway');
@@ -1180,6 +1161,7 @@ export const makeMessagesRecvSocket = (config) => {
                                     logger.error({ retryErr }, 'Failed to send retry after error handling');
                                 }
                             }
+                            acked = true;
                             await sendMessageAck(node, NACK_REASONS.UnhandledError);
                         });
                     }
@@ -1208,6 +1190,7 @@ export const makeMessagesRecvSocket = (config) => {
                         else if (!sendActiveReceipts) {
                             type = 'inactive';
                         }
+                        acked = true;
                         await sendReceipt(msg.key.remoteJid, participant, [msg.key.id], type);
                         // send ack for history message
                         const isAnyHistoryMsg = getHistoryMsg(msg.message);
@@ -1217,6 +1200,7 @@ export const makeMessagesRecvSocket = (config) => {
                         }
                     }
                     else {
+                        acked = true;
                         await sendMessageAck(node);
                         logger.debug({ key: msg.key }, 'processed newsletter message without receipts');
                     }
@@ -1227,45 +1211,55 @@ export const makeMessagesRecvSocket = (config) => {
         }
         catch (error) {
             logger.error({ error, node: binaryNodeToString(node) }, 'error in handling message');
+            if (!acked) {
+                await sendMessageAck(node, NACK_REASONS.UnhandledError).catch(ackErr => logger.error({ ackErr }, 'failed to ack message after error'));
+            }
         }
     };
     const handleCall = async (node) => {
-        const { attrs } = node;
-        const [infoChild] = getAllBinaryNodeChildren(node);
-        const status = getCallStatusFromNode(infoChild);
-        if (!infoChild) {
-            throw new Boom('Missing call info in call node');
-        }
-        const callId = infoChild.attrs['call-id'];
-        const from = infoChild.attrs.from || infoChild.attrs['call-creator'];
-        const call = {
-            chatId: attrs.from,
-            from,
-            callerPn: infoChild.attrs['caller_pn'],
-            id: callId,
-            date: new Date(+attrs.t * 1000),
-            offline: !!attrs.offline,
-            status
-        };
-        if (status === 'offer') {
-            call.isVideo = !!getBinaryNodeChild(infoChild, 'video');
-            call.isGroup = infoChild.attrs.type === 'group' || !!infoChild.attrs['group-jid'];
-            call.groupJid = infoChild.attrs['group-jid'];
-            await callOfferCache.set(call.id, call);
+        try {
+            const { attrs } = node;
+            const [infoChild] = getAllBinaryNodeChildren(node);
+            if (!infoChild) {
+                throw new Boom('Missing call info in call node');
+            }
+            const status = getCallStatusFromNode(infoChild);
+            const callId = infoChild.attrs['call-id'];
+            const from = infoChild.attrs.from || infoChild.attrs['call-creator'];
+            const call = {
+                chatId: attrs.from,
+                from,
+                callerPn: infoChild.attrs['caller_pn'],
+                id: callId,
+                date: new Date(+attrs.t * 1000),
+                offline: !!attrs.offline,
+                status
+            };
+            if (status === 'offer') {
+                call.isVideo = !!getBinaryNodeChild(infoChild, 'video');
+                call.isGroup = infoChild.attrs.type === 'group' || !!infoChild.attrs['group-jid'];
+                call.groupJid = infoChild.attrs['group-jid'];
+                await callOfferCache.set(call.id, call);
+            }
+            const existingCall = await callOfferCache.get(call.id);
+            // use existing call info to populate this event
+            if (existingCall) {
+                call.isVideo = existingCall.isVideo;
+                call.isGroup = existingCall.isGroup;
+                call.callerPn = call.callerPn || existingCall.callerPn;
+            }
+            // delete data once call has ended
+            if (status === 'reject' || status === 'accept' || status === 'timeout' || status === 'terminate') {
+                await callOfferCache.del(call.id);
+            }
+            ev.emit('call', [call]);
         }
-        const existingCall = await callOfferCache.get(call.id);
-        // use existing call info to populate this event
-        if (existingCall) {
-            call.isVideo = existingCall.isVideo;
-            call.isGroup = existingCall.isGroup;
-            call.callerPn = call.callerPn || existingCall.callerPn;
+        catch (error) {
+            logger.error({ error, node: binaryNodeToString(node) }, 'error in handling call');
         }
-        // delete data once call has ended
-        if (status === 'reject' || status === 'accept' || status === 'timeout' || status === 'terminate') {
-            await callOfferCache.del(call.id);
+        finally {
+            await sendMessageAck(node).catch(ackErr => logger.error({ ackErr }, 'failed to ack call'));
         }
-        ev.emit('call', [call]);
-        await sendMessageAck(node);
     };
     const handleBadAck = async ({ attrs }) => {
         const key = { remoteJid: attrs.from, fromMe: true, id: attrs.id };
@@ -1314,58 +1308,26 @@ export const makeMessagesRecvSocket = (config) => {
     /// and adds the task to the existing buffer if we're buffering events
     const processNodeWithBuffer = async (node, identifier, exec) => {
         ev.buffer();
-        await execTask();
-        ev.flush();
+        try {
+            await execTask();
+        }
+        finally {
+            ev.flush();
+        }
         function execTask() {
             return exec(node, false).catch(err => onUnexpectedError(err, identifier));
         }
     };
-    /** Yields control to the event loop to prevent blocking */
-    const yieldToEventLoop = () => {
-        return new Promise(resolve => setImmediate(resolve));
-    };
-    const makeOfflineNodeProcessor = () => {
-        const nodeProcessorMap = new Map([
-            ['message', handleMessage],
-            ['call', handleCall],
-            ['receipt', handleReceipt],
-            ['notification', handleNotification]
-        ]);
-        const nodes = [];
-        let isProcessing = false;
-        // Number of nodes to process before yielding to event loop
-        const BATCH_SIZE = 10;
-        const enqueue = (type, node) => {
-            nodes.push({ type, node });
-            if (isProcessing) {
-                return;
-            }
-            isProcessing = true;
-            const promise = async () => {
-                let processedInBatch = 0;
-                while (nodes.length && ws.isOpen) {
-                    const { type, node } = nodes.shift();
-                    const nodeProcessor = nodeProcessorMap.get(type);
-                    if (!nodeProcessor) {
-                        onUnexpectedError(new Error(`unknown offline node type: ${type}`), 'processing offline node');
-                        continue;
-                    }
-                    await nodeProcessor(node);
-                    processedInBatch++;
-                    // Yield to event loop after processing a batch
-                    // This prevents blocking the event loop for too long when there are many offline nodes
-                    if (processedInBatch >= BATCH_SIZE) {
-                        processedInBatch = 0;
-                        await yieldToEventLoop();
-                    }
-                }
-                isProcessing = false;
-            };
-            promise().catch(error => onUnexpectedError(error, 'processing offline nodes'));
-        };
-        return { enqueue };
-    };
-    const offlineNodeProcessor = makeOfflineNodeProcessor();
+    const offlineNodeProcessor = makeOfflineNodeProcessor(new Map([
+        ['message', handleMessage],
+        ['call', handleCall],
+        ['receipt', handleReceipt],
+        ['notification', handleNotification]
+    ]), {
+        isWsOpen: () => ws.isOpen,
+        onUnexpectedError,
+        yieldToEventLoop: () => new Promise(resolve => setImmediate(resolve))
+    });
     const processNode = async (type, node, identifier, exec) => {
         const isOffline = !!node.attrs.offline;
         if (isOffline) {

package/lib/Socket/socket.js

@@ -123,12 +123,9 @@ export const makeSocket = (config) => {
             node.attrs.id = generateMessageTag();
         }
         const msgId = node.attrs.id;
-        const result = await promiseTimeout(timeoutMs, async (resolve, reject) => {
-            const result = waitForMessage(msgId, timeoutMs).catch(reject);
-            sendNode(node)
-                .then(async () => resolve(await result))
-                .catch(reject);
-        });
+        const resultPromise = waitForMessage(msgId, timeoutMs);
+        await sendNode(node);
+        const result = await resultPromise;
         if (result && 'tag' in result) {
             assertNodeErrorFree(result);
         }
@@ -483,15 +480,18 @@ export const makeSocket = (config) => {
         logger.info({ trace: error?.stack }, error ? 'connection errored' : 'connection closed');
         clearInterval(keepAliveReq);
         clearTimeout(qrTimer);
-        ws.removeAllListeners('close');
-        ws.removeAllListeners('open');
-        ws.removeAllListeners('message');
+        // Clear all WS listeners (CB:*, TAG:*, frame, error, etc.) to prevent memory leaks
+        ws.removeAllListeners();
         if (!ws.isClosed && !ws.isClosing) {
             try {
                 await ws.close();
             }
             catch { }
         }
+        // Clean up noise handler buffers
+        if (noise.destroy) {
+            noise.destroy();
+        }
         ev.emit('connection.update', {
             connection: 'close',
             lastDisconnect: {
@@ -499,7 +499,11 @@ export const makeSocket = (config) => {
                 date: new Date()
             }
         });
+        // Remove only internal socket listeners — preserve user-registered listeners
         ev.removeAllListeners('connection.update');
+        ev.removeAllListeners('creds.update');
+        ev.removeAllListeners('call');
+        ev.removeAllListeners('lid-mapping.update');
     };
     const waitForSocketOpen = async () => {
         if (ws.isOpen) {
@@ -522,7 +526,8 @@ export const makeSocket = (config) => {
             ws.off('error', onClose);
         });
     };
-    const startKeepAliveRequest = () => (keepAliveReq = setInterval(() => {
+    const startKeepAliveRequest = () => {
+        keepAliveReq = setInterval(() => {
         if (!lastDateRecv) {
             lastDateRecv = new Date();
         }
@@ -552,7 +557,12 @@ export const makeSocket = (config) => {
         else {
             logger.warn('keep alive called when WS not open');
         }
-    }, keepAliveIntervalMs));
+    }, keepAliveIntervalMs);
+        // unref so the interval doesn't prevent Node.js process from exiting
+        if (keepAliveReq?.unref) {
+            keepAliveReq.unref();
+        }
+    };
     /** i have no idea why this exists. pls enlighten me */
     const sendPassiveIq = (tag) => query({
         tag: 'iq',
@@ -598,7 +608,7 @@ export const makeSocket = (config) => {
             id: jidEncode(phoneNumber, 's.whatsapp.net'),
             name: '~'
         };
-        ev.emit('creds.update', authState.creds);
+        ev.emit('creds.update', { pairingCode: authState.creds.pairingCode, me: authState.creds.me });
         await sendNode({
             tag: 'iq',
             attrs: {
@@ -810,7 +820,7 @@ export const makeSocket = (config) => {
         const routingInfo = getBinaryNodeChild(edgeRoutingNode, 'routing_info');
         if (routingInfo?.content) {
             authState.creds.routingInfo = Buffer.from(routingInfo?.content);
-            ev.emit('creds.update', authState.creds);
+            ev.emit('creds.update', { routingInfo: authState.creds.routingInfo });
         }
     });
     let didStartBuffer = false;

package/lib/Utils/event-buffer.js

@@ -149,7 +149,7 @@ export const makeEventBuffer = (logger) => {
                             if (isBuffering && bufferCount === 1) {
                                 flush();
                             }
-                        }, 100); // Small delay to allow nested buffers
+                        }, 10); // Minimal delay to allow nested buffers without adding latency
                     }
                     return result;
                 }
@@ -161,7 +161,7 @@ export const makeEventBuffer = (logger) => {
                     if (bufferCount === 0) {
                         // Only schedule ONE timeout, not 10,000
                         if (!flushPendingTimeout) {
-                            flushPendingTimeout = setTimeout(flush, 100);
+                            flushPendingTimeout = setTimeout(flush, 10);
                         }
                     }
                 }

package/lib/Utils/index.js

@@ -16,4 +16,5 @@ export * from './event-buffer.js';
 export * from './process-message.js';
 export * from './message-retry-manager.js';
 export * from './browser-utils.js';
-export * from './identity-change-handler.js';
+export * from './identity-change-handler.js';
+export * from './stanza-ack.js';

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 PHONE_REQUEST_DELAY = 1000;
 // Retry reason codes matching WhatsApp Web's Signal error codes.
 export var RetryReason;
 (function (RetryReason) {

package/lib/Utils/noise-handler.js

@@ -195,6 +195,12 @@ export const makeNoiseHandler = ({ keyPair: { private: privateKey, public: publi
                 inBytes = Buffer.concat([inBytes, newData]);
             }
             await processData(onFrame);
+        },
+        /** Clean up internal buffers to prevent memory leaks on connection close */
+        destroy() {
+            inBytes = Buffer.alloc(0);
+            transport = null;
+            pendingOnFrame = null;
         }
     };
 };

package/lib/Utils/offline-node-processor.js

@@ -0,0 +1,39 @@
+/**
+ * Creates a processor for offline stanza nodes that:
+ * - Queues nodes for sequential processing
+ * - Yields to the event loop periodically to avoid blocking
+ * - Catches handler errors to prevent the processing loop from crashing
+ */
+export function makeOfflineNodeProcessor(nodeProcessorMap, deps, batchSize = 10) {
+    const nodes = [];
+    let isProcessing = false;
+    const enqueue = (type, node) => {
+        nodes.push({ type, node });
+        if (isProcessing) {
+            return;
+        }
+        isProcessing = true;
+        const promise = async () => {
+            let processedInBatch = 0;
+            while (nodes.length && deps.isWsOpen()) {
+                const { type, node } = nodes.shift();
+                const nodeProcessor = nodeProcessorMap.get(type);
+                if (!nodeProcessor) {
+                    deps.onUnexpectedError(new Error(`unknown offline node type: ${type}`), 'processing offline node');
+                    continue;
+                }
+                await nodeProcessor(node).catch(err => deps.onUnexpectedError(err, `processing offline ${type}`));
+                processedInBatch++;
+                // Yield to event loop after processing a batch
+                // This prevents blocking the event loop for too long when there are many offline nodes
+                if (processedInBatch >= batchSize) {
+                    processedInBatch = 0;
+                    await deps.yieldToEventLoop();
+                }
+            }
+            isProcessing = false;
+        };
+        promise().catch(error => deps.onUnexpectedError(error, 'processing offline nodes'));
+    };
+    return { enqueue };
+}