@violetix/baileys 0.4.0 → 0.5.1

package/lib/Defaults/index.d.ts

@@ -41,6 +41,11 @@ export namespace DEFAULT_CONNECTION_CONFIG {
     export let browser: any[];
     export let waWebSocketUrl: string;
     export let connectTimeoutMs: number;
+    export let closeTimeoutMs: number;
+    export let autoReconnect: boolean;
+    export let reconnectDelayMs: number;
+    export let maxReconnectDelayMs: number;
+    export let maxReconnectAttempts: number;
     export let keepAliveIntervalMs: number;
     export let logger: any;
     export let emitOwnEvents: boolean;

package/lib/Defaults/index.js

@@ -2,7 +2,7 @@ import { proto } from '../../WAProto/index.js';
 import { makeLibSignalRepository } from '../Signal/libsignal.js';
 import { Browsers } from '../Utils/browser-utils.js';
 import logger from '../Utils/logger.js';
-const version = [2, 3000, 1048107131];
+const version = [2, 3000, 1053032355];
 export const UNAUTHORIZED_CODES = [401, 403, 419];
 export const BIZ_BOT_SUPPORT_PAYLOAD = '{"version":1,"is_ai_message":true,"should_upload_client_logs":false,"should_show_system_message":false,"ticket_id":"7004947587700716","citation_items":[],"ticket_locale":"us"}';
 export const DEFAULT_ORIGIN = 'https://web.whatsapp.com';
@@ -57,6 +57,14 @@ export const DEFAULT_CONNECTION_CONFIG = {
     browser: Browsers.macOS('Chrome'),
     waWebSocketUrl: 'wss://web.whatsapp.com/ws/chat',
     connectTimeoutMs: 20000,
+    // a half-open socket never answers close(); without a ceiling every reconnect leaks one
+    closeTimeoutMs: 5000,
+    // reconnect the transport in place instead of ending the socket, so a host that treats
+    // connection 'close' as "build a new socket" never runs two sockets for one account
+    autoReconnect: true,
+    reconnectDelayMs: 2000,
+    maxReconnectDelayMs: 60000,
+    maxReconnectAttempts: 10,
     keepAliveIntervalMs: 30000,
     keepAliveGracePeriodMs: 30000,
     logger: logger.child({ class: 'baileys' }),
@@ -68,7 +76,9 @@ export const DEFAULT_CONNECTION_CONFIG = {
     fireInitQueries: true,
     auth: undefined,
     markOnlineOnConnect: true,
-    syncFullHistory: true,
+    // FULL history is dropped by shouldSyncHistoryMessage below anyway; asking for it only adds
+    // reconnect load (upstream default is false too)
+    syncFullHistory: false,
     patchMessageBeforeSending: msg => msg,
     shouldSyncHistoryMessage: ({ syncType }) => {
         return syncType !== proto.HistorySync.HistorySyncType.FULL;

package/lib/Socket/Client/websocket.js

@@ -35,16 +35,51 @@ export class WebSocketClient extends AbstractSocketClient {
             this.socket?.on(event, (...args) => this.emit(event, ...args));
         }
     }
+    /**
+     * Drop the raw socket and open a new one on the SAME emitter. Every stanza listener the layers
+     * above registered (messages-recv, chats, the host) stays attached, which is what makes a
+     * reconnect invisible to them. The noise session is rebuilt by the caller.
+     */
+    reconnect() {
+        const socket = this.socket;
+        this.socket = null;
+        if (socket) {
+            // remove the forwarders first: a late close from the old socket must not be reported
+            // as a close of the new one
+            socket.removeAllListeners();
+            try {
+                socket.terminate();
+            }
+            catch { }
+        }
+        this.connect();
+    }
     async close() {
         if (!this.socket) {
             return;
         }
+        const socket = this.socket;
+        // A half-open peer never answers the close handshake, so an unbounded wait here leaks one
+        // socket per reconnect. With a fleet that ends as FD exhaustion, so bound it and terminate.
+        const timeoutMs = this.config.closeTimeoutMs ?? 5000;
         const closePromise = new Promise(resolve => {
-            this.socket?.once('close', resolve);
-            this.socket?.once('error', resolve);
+            const timer = setTimeout(() => {
+                try {
+                    socket.terminate();
+                }
+                catch { }
+                resolve();
+            }, timeoutMs);
+            timer.unref?.();
+            const done = () => {
+                clearTimeout(timer);
+                resolve();
+            };
+            socket.once('close', done);
+            socket.once('error', done);
         });
         try {
-            this.socket.close();
+            socket.close();
         } catch { }
         await closePromise;
         this.socket = null;

package/lib/Socket/chats.js

@@ -1077,7 +1077,9 @@ export const makeChatsSocket = (config) => {
                 if (attrs.timestamp) {
                     let { lastAccountSyncTimestamp } = authState.creds;
                     if (lastAccountSyncTimestamp) {
-                        await cleanDirtyBits('account_sync', lastAccountSyncTimestamp);
+                        // async ws handler: a rejection here would be unhandled and kill the process
+                        await cleanDirtyBits('account_sync', lastAccountSyncTimestamp)
+                            .catch(error => logger.warn({ error }, 'failed to clean account_sync dirty bits'));
                     }
                     lastAccountSyncTimestamp = +attrs.timestamp;
                     ev.emit('creds.update', { lastAccountSyncTimestamp });

package/lib/Socket/groups.js

@@ -23,7 +23,7 @@ export const makeGroupsSocket = (config) => {
         }
         const promise = groupQuery(jid, 'get', [{ tag: 'query', attrs: { request: 'interactive' } }])
             .then(result => extractGroupMetadata(result))
-            .catch(() => null)
+            // no swallow: a null here made group sends go to zero recipients silently
             .finally(() => inflightGroupMetadata.delete(jid));
         inflightGroupMetadata.set(jid, promise);
         return promise;
@@ -69,8 +69,13 @@ export const makeGroupsSocket = (config) => {
         if (attrs.type !== 'groups') {
             return;
         }
-        await groupFetchAllParticipating();
-        await sock.cleanDirtyBits('groups');
+        try {
+            await groupFetchAllParticipating();
+            await sock.cleanDirtyBits('groups');
+        }
+        catch (error) {
+            config.logger?.warn({ error }, 'failed to handle dirty groups');
+        }
     });
     return {
         ...sock,

package/lib/Socket/index.d.ts

@@ -875,6 +875,8 @@ declare function makeWASocket(config: import('../Types/Socket.js').SocketConfig)
     };
     signalRepository: any;
     user: any;
+    /** true while the transport is repairing itself; do not build a second socket for the account */
+    isReconnecting: boolean;
     generateMessageTag: () => string;
     /**
      * Drops matching inbound stanzas before any handler — including the decryption and
@@ -890,6 +892,7 @@ declare function makeWASocket(config: import('../Types/Socket.js').SocketConfig)
     logout: (msg: any) => Promise<void>;
     end: (error: any) => Promise<void>;
     registerSocketEndHandler: (handler: any) => void;
+    registerSocketReconnectHandler: (handler: any) => void;
     onUnexpectedError: (err: any, msg: any) => void;
     uploadPreKeys: (count?: number) => Promise<void>;
     uploadPreKeysToServerIfRequired: () => Promise<void>;

package/lib/Socket/messages-recv.js

@@ -5,7 +5,7 @@ import Long from 'long';
 import { proto } from '../../WAProto/index.js';
 import { DEFAULT_CACHE_TTLS, KEY_BUNDLE_TYPE, MIN_PREKEY_COUNT, PLACEHOLDER_MAX_AGE_SECONDS, STATUS_EXPIRY_SECONDS } from '../Defaults/index.js';
 import { ReachoutTimelockEnforcementType, WAMessageStatus, WAMessageStubType } from '../Types/index.js';
-import { ACCOUNT_RESTRICTED_TEXT, aesDecryptCTR, aesEncryptGCM, cleanMessage, Curve, decodeMediaRetryNode, decodeMessageNode, decryptMessageNode, setBotMessageSecret, delay, derivePairingCodeKey, encodeBigEndian, encodeSignedDeviceIdentity, extractAddressingContext, extractE2ESessionFromRetryReceipt, getCallStatusFromNode, getHistoryMsg, getNextPreKeys, getStatusFromReceiptType, handleIdentityChange, hkdf, MISSING_KEYS_ERROR_TEXT, NACK_REASONS, NO_MESSAGE_FOUND_ERROR_TEXT, SERVER_ERROR_CODES, toNumber, unixTimestampSeconds, xmppPreKey, xmppSignedPreKey } from '../Utils/index.js';
+import { ACCOUNT_RESTRICTED_TEXT, aesDecryptCTR, aesEncryptGCM, cleanMessage, Curve, decodeMediaRetryNode, decodeMessageNode, decryptMessageNode, setBotMessageSecret, delay, derivePairingCodeKey, encodeBigEndian, encodeSignedDeviceIdentity, extractAddressingContext, extractE2ESessionFromRetryReceipt, getCallStatusFromNode, getHistoryMsg, getNextPreKeys, getStatusFromReceiptType, handleIdentityChange, hkdf, MISSING_KEYS_ERROR_TEXT, NACK_REASONS, NO_MESSAGE_FOUND_ERROR_TEXT, SERVER_ERROR_CODES, toNumber, unixTimestampSeconds, unpadRandomMax16, 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';
@@ -394,7 +394,7 @@ export const makeMessagesRecvSocket = (config) => {
         }
     };
     const sendMessageAck = async (node, errorCode) => {
-        const stanza = buildAckStanza(node, errorCode, authState.creds.me.id);
+        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);
     };
@@ -657,7 +657,7 @@ export const makeMessagesRecvSocket = (config) => {
                 };
                 break;
             case 'modify':
-                const oldNumber = getBinaryNodeChildren(child, 'participant').map(p => p.attrs.jid);
+                const oldNumber = getBinaryNodeChildren(child, 'participant').map(p => JSON.stringify({ id: p.attrs.jid, phoneNumber: p.attrs.phone_number, lid: p.attrs.lid }));
                 msg.messageStubParameters = oldNumber || [];
                 msg.messageStubType = WAMessageStubType.GROUP_PARTICIPANT_CHANGE_NUMBER;
                 break;

package/lib/Socket/messages-send.js

@@ -55,7 +55,7 @@ const getMediaTypeForGroupStatus = (media) => {
 export const makeMessagesSocket = (config) => {
     const { logger, linkPreviewImageThumbnailWidth, generateHighQualityLinkPreview, options: httpRequestOptions, patchMessageBeforeSending, cachedGroupMetadata, enableRecentMessageCache, maxMsgRetryCount } = config;
     const sock = makeNewsletterSocket(config);
-    const { ev, authState, messageMutex, signalRepository, upsertMessage, query, fetchPrivacySettings, sendNode, groupMetadata, groupToggleEphemeral, registerSocketEndHandler } = sock;
+    const { ev, authState, messageMutex, signalRepository, upsertMessage, query, fetchPrivacySettings, sendNode, groupMetadata, groupToggleEphemeral, registerSocketEndHandler, registerSocketReconnectHandler } = sock;
     /**
      * Echo a message we just sent back into our own store, off the send path.
      *
@@ -1242,6 +1242,10 @@ export const makeMessagesSocket = (config) => {
             messageRetryManager.clear();
         }
     });
+    // the media host auth token is bound to the connection that fetched it
+    registerSocketReconnectHandler?.(() => {
+        mediaConn = undefined;
+    });
     const socket = {
         ...sock,
         userDevicesCache,
@@ -1455,8 +1459,10 @@ export const makeMessagesSocket = (config) => {
                 const isQuizMsg = 'poll' in content && !!content.poll.pollType;
                 const isAiMsg = 'ai' in content && !!content.ai;
                 const isNeedBizAttrs = 'secureMetaServiceLabel' in content && !!content.secureMetaServiceLabel;
-                const additionalAttributes = options.additionalAttributes || {};
-                const additionalNodes = options.additionalNodes || [];
+                // copies: these get .edit / meta / bot added below, which must not leak into the
+                // caller's reused options object (stacked nodes, stray edit turning sends into deletes)
+                const additionalAttributes = { ...options.additionalAttributes };
+                const additionalNodes = [...(options.additionalNodes || [])];
                 // required for delete
                 if (isDeleteMsg || isKeepMsg) {
                     // if the chat is a group, and I am not the author, then delete the message as an admin
@@ -1512,7 +1518,6 @@ export const makeMessagesSocket = (config) => {
                         },
                         content: undefined
                     });
-                    delete content.ai;
                 }
                 const relayOpts = {
                     messageId: fullMsg.key.id,
@@ -1523,12 +1528,11 @@ export const makeMessagesSocket = (config) => {
                     additionalAttributes,
                     additionalNodes
                 };
-                if (options.exclusive) {
-                    await relayExclusive(jid, fullMsg.message, options, relayOpts);
-                }
-                else {
-                    await relayMessage(jid, fullMsg.message, relayOpts);
-                }
+                // children (poll option images, album items) must honour `exclusive` too
+                const relay = (message, opts) => options.exclusive
+                    ? relayExclusive(jid, message, options, opts)
+                    : relayMessage(jid, message, opts);
+                await relay(fullMsg.message, relayOpts);
                 if (config.emitOwnEvents) {
                     setImmediate(() => emitOwnUpsert(fullMsg));
                 }
@@ -1548,7 +1552,7 @@ export const makeMessagesSocket = (config) => {
                             userJid,
                             messageId: generateMessageIDV2(userJid)
                         });
-                        await relayMessage(jid, optionMsg.message, {
+                        await relay(optionMsg.message, {
                             messageId: optionMsg.key.id,
                             useCachedGroupMetadata: options.useCachedGroupMetadata,
                             additionalAttributes,
@@ -1581,7 +1585,7 @@ export const makeMessagesSocket = (config) => {
                             parentMessageKey: fullMsg.key,
                             associationType: AssociationType.MEDIA_ALBUM
                         };
-                        await relayMessage(jid, albumMsg.message, {
+                        await relay(albumMsg.message, {
                             messageId: albumMsg.key.id,
                             useCachedGroupMetadata: options.useCachedGroupMetadata,
                             addBizAttributes: isNeedBizAttrs,

package/lib/Socket/socket.js

@@ -27,6 +27,17 @@ import { executeWMexQuery } from './mex.js';
  * so a stale hardcoded version heals on the next reconnect instead of looping on 405.
  */
 let latestVersionOverride;
+/**
+ * Reasons that end a session for good. Reconnecting any of these is how an unattended host turns
+ * one logout into an auth loop and gets the number banned.
+ */
+const DEAD_DISCONNECT_REASONS = new Set([
+    DisconnectReason.loggedOut,
+    DisconnectReason.forbidden,
+    DisconnectReason.multideviceMismatch,
+    DisconnectReason.badSession,
+    DisconnectReason.connectionReplaced
+]);
 export const makeSocket = (config) => {
     const { waWebSocketUrl, connectTimeoutMs, logger, keepAliveIntervalMs, keepAliveGracePeriodMs, browser, auth: authState, printQRInTerminal, defaultQueryTimeoutMs, transactionOpts, qrTimeout, makeSignalRepository } = config;
     const publicWAMBuffer = new BinaryInfo();
@@ -52,9 +63,9 @@ export const makeSocket = (config) => {
         url.searchParams.append('ED', authState.creds.routingInfo.toString('base64url'));
     }
     /** ephemeral key pair used to encrypt/decrypt communication. Unique for each connection */
-    const ephemeralKeyPair = Curve.generateKeyPair();
+    let ephemeralKeyPair = Curve.generateKeyPair();
     /** WA noise protocol wrapper */
-    const noise = makeNoiseHandler({
+    let noise = makeNoiseHandler({
         keyPair: ephemeralKeyPair,
         NOISE_HEADER: NOISE_WA_HEADER,
         logger,
@@ -136,12 +147,13 @@ export const makeSocket = (config) => {
             node.attrs.id = generateMessageTag();
         }
         const msgId = node.attrs.id;
+        pendingQueries++;
         const result = await promiseTimeout(timeoutMs, async (resolve, reject) => {
             const result = waitForMessage(msgId, timeoutMs).catch(reject);
             sendNode(node)
                 .then(async () => resolve(await result))
                 .catch(reject);
-        });
+        }).finally(() => { pendingQueries--; });
         if (result && 'tag' in result) {
             assertNodeErrorFree(result);
         }
@@ -376,10 +388,17 @@ export const makeSocket = (config) => {
     const keys = addTransactionCapability(authState.keys, logger, transactionOpts);
     const signalRepository = makeSignalRepository({ creds, keys }, logger, pnFromLIDUSync);
     let lastDateRecv;
+    /** queries awaiting a reply; keep-alive skips its ping while these are flowing */
+    let pendingQueries = 0;
     let epoch = 1;
     let keepAliveReq;
     let qrTimer;
     let closed = false;
+    /** transparent transport reconnect state; see scheduleReconnect */
+    let reconnecting = false;
+    let reconnectAttempts = 0;
+    let reconnectTimer;
+    let reconnectWaitResolve;
     /** set once WhatsApp sends pair-device; requestPairingCode queues until then */
     let pairingReady = false;
     let pairingInProgress = false;
@@ -388,6 +407,8 @@ export const makeSocket = (config) => {
     let pendingPairingResolve;
     let pendingPairingReject;
     const socketEndHandlers = [];
+    /** per-connection caches (media host auth, ...) that must be dropped when the transport reopens */
+    const socketReconnectHandlers = [];
     const timers = new Set();
     const safeSetTimeout = (fn, ms) => { const id = setTimeout(fn, ms); timers.add(id); return id; };
     const safeSetInterval = (fn, ms) => { const id = setInterval(fn, ms); timers.add(id); return id; };
@@ -647,6 +668,9 @@ export const makeSocket = (config) => {
             keepAliveReq?.cancel();
             clearSafeTimer(qrTimer);
             clearAllTimers();
+            // release a pending reconnect wait so scheduleReconnect cannot stay suspended
+            reconnectWaitResolve?.();
+            reconnectWaitResolve = undefined;
             // a queued requestPairingCode would hang forever otherwise
             pairingReady = false;
             pairingInProgress = false;
@@ -690,6 +714,90 @@ export const makeSocket = (config) => {
             logger.error({ err }, 'error while closing connection');
         }
     };
+    /** rebuild the state that belongs to one transport connection, not to the socket object */
+    const resetTransport = () => {
+        keepAliveReq?.cancel();
+        keepAliveReq = undefined;
+        clearSafeTimer(qrTimer);
+        qrTimer = undefined;
+        lastDateRecv = undefined;
+        ephemeralKeyPair = Curve.generateKeyPair();
+        noise = makeNoiseHandler({
+            keyPair: ephemeralKeyPair,
+            NOISE_HEADER: NOISE_WA_HEADER,
+            logger,
+            routingInfo: authState?.creds?.routingInfo
+        });
+        // the media host token is issued per connection; a cached one fails every upload after this
+        for (const handler of socketReconnectHandlers) {
+            try {
+                handler();
+            }
+            catch (err) {
+                logger.error({ err }, 'error in socket reconnect handler');
+            }
+        }
+    };
+    /**
+     * Transparent reconnect. The WebSocket client object is kept and only the raw socket and the
+     * noise session under it are replaced, so every stanza listener registered by the layers above
+     * (messages-recv, chats, the host) keeps working and the host never sees a `close` for a drop
+     * that this socket can repair itself.
+     */
+    const scheduleReconnect = async (error) => {
+        if (reconnecting || closed) {
+            return;
+        }
+        reconnecting = true;
+        const statusCode = error?.output?.statusCode;
+        const maxAttempts = config.maxReconnectAttempts ?? 10;
+        if (!config.autoReconnect || DEAD_DISCONNECT_REASONS.has(statusCode) || reconnectAttempts >= maxAttempts) {
+            reconnecting = false;
+            return end(error);
+        }
+        reconnectAttempts += 1;
+        // 515 means the server wants the connection back now; backing off only delays it
+        const immediate = statusCode === DisconnectReason.restartRequired;
+        const base = config.reconnectDelayMs ?? 2000;
+        const ceiling = config.maxReconnectDelayMs ?? 60000;
+        const backoff = Math.min(ceiling, base * 2 ** (reconnectAttempts - 1));
+        // jitter keeps a fleet from reconnecting in lockstep after a server-side blip
+        const delayMs = immediate ? 0 : Math.round(backoff * (0.75 + Math.random() * 0.5));
+        logger.info({ statusCode, attempt: reconnectAttempts, delayMs }, 'connection lost, reconnecting');
+        // NOT 'close': a host reads close as "build a new socket", and a second socket for the same
+        // account is what earns a 440 connectionReplaced
+        ev.emit('connection.update', {
+            connection: 'connecting',
+            lastDisconnect: { error, date: new Date() }
+        });
+        await new Promise(resolve => {
+            reconnectWaitResolve = resolve;
+            reconnectTimer = safeSetTimeout(() => {
+                reconnectWaitResolve = undefined;
+                resolve();
+            }, delayMs);
+        });
+        reconnectTimer = undefined;
+        reconnecting = false;
+        if (closed) {
+            return;
+        }
+        try {
+            resetTransport();
+            ws.reconnect();
+        }
+        catch (err) {
+            logger.error({ err }, 'failed to reopen the transport');
+            return end(err);
+        }
+    };
+    /** single entry point for every transport-level close */
+    const handleDisconnect = (error) => {
+        if (closed) {
+            return;
+        }
+        return scheduleReconnect(error);
+    };
     const waitForSocketOpen = async () => {
         if (ws.isOpen) {
             return;
@@ -711,48 +819,89 @@ export const makeSocket = (config) => {
             ws.off('error', onClose);
         });
     };
+    /**
+     * Keep-alive, modelled on zapo-js (src/transport/keepalive/WaKeepAlive.ts):
+     * - self-rescheduling setTimeout with +-10% jitter (min 250ms), so a fleet of sockets in one
+     *   process drifts apart instead of pinging in the same tick
+     * - at most one ping in flight; a slow pong never stacks more pings on a busy loop
+     * - no ping while other queries are pending and data arrived recently: the link is
+     *   demonstrably alive and the ping would only add queue pressure
+     * - "lost" is still decided by inbound silence (interval + grace), and skipped when the
+     *   timer itself fired late (blocked event loop: pongs may be unread in the socket buffer)
+     */
     const startKeepAliveRequest = () => {
+        let timer;
+        let stopped = false;
+        let pingInFlight = false;
+        let lastCheckAt;
+        let expectedDelayMs = 0;
+        const nextDelay = () => {
+            const jitter = Math.max(250, Math.floor(keepAliveIntervalMs * 0.1));
+            return Math.max(1000, keepAliveIntervalMs + Math.floor((Math.random() * 2 - 1) * jitter));
+        };
+        const schedule = (delayMs) => {
+            if (stopped) {
+                return;
+            }
+            expectedDelayMs = delayMs;
+            timer = safeSetTimeout(() => {
+                timer = undefined;
+                cb();
+                schedule(nextDelay());
+            }, delayMs);
+        };
         const cb = () => {
             if (!lastDateRecv) {
                 lastDateRecv = new Date();
             }
-            const diff = Date.now() - lastDateRecv.getTime();
-            if (diff > keepAliveIntervalMs + keepAliveGracePeriodMs) {
-                void end(new Boom('Connection was lost', { statusCode: DisconnectReason.connectionLost }));
+            const now = Date.now();
+            const sinceRecvMs = now - lastDateRecv.getTime();
+            const lagMs = lastCheckAt ? now - lastCheckAt - expectedDelayMs : 0;
+            lastCheckAt = now;
+            const loopStalled = lagMs > keepAliveGracePeriodMs;
+            if (loopStalled) {
+                logger.warn({ lagMs, sinceLastRecvMs: sinceRecvMs }, 'event loop stalled; deferring keep-alive timeout');
             }
-            else if (ws.isOpen) {
-                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');
-                });
+            if (sinceRecvMs > keepAliveIntervalMs + keepAliveGracePeriodMs && !loopStalled) {
+                void handleDisconnect(new Boom('Connection was lost', { statusCode: DisconnectReason.connectionLost }));
+                return;
             }
-            else {
+            if (!ws.isOpen) {
                 logger.warn('keep alive called when WS not open');
+                return;
+            }
+            if (pingInFlight) {
+                logger.trace('keep alive skipped: ping already in flight');
+                return;
             }
+            if (pendingQueries > 0 && sinceRecvMs < keepAliveGracePeriodMs) {
+                logger.trace({ pendingQueries, sinceRecvMs }, 'keep alive skipped: queries pending with recent inbound');
+                return;
+            }
+            pingInFlight = true;
+            query({
+                tag: 'iq',
+                attrs: {
+                    id: generateMessageTag(),
+                    to: S_WHATSAPP_NET,
+                    type: 'get',
+                    xmlns: 'w:p'
+                },
+                content: [{ tag: 'ping', attrs: {} }]
+            }, keepAliveIntervalMs + keepAliveGracePeriodMs)
+                .catch(err => {
+                    // the verdict stays with inbound silence above; a failed ping alone is not "lost"
+                    logger.warn({ trace: err.stack }, 'error in sending keep alive');
+                })
+                .finally(() => { pingInFlight = false; });
         };
-        // Per socket, so keepAliveIntervalMs from the config is actually the ping interval: the
-        // shared process-wide timer ran at a hardcoded 30s while the staleness check below still
-        // used the configured value, so any interval other than 30s produced false connectionLost.
-        // The random start offset staggers the fleet - on the shared timer every socket in the
-        // process pinged in the same tick, which is a self-inflicted burst at 100+ sessions.
-        let pinger;
-        const starter = safeSetTimeout(() => {
-            cb();
-            pinger = safeSetInterval(cb, keepAliveIntervalMs);
-        }, Math.floor(Math.random() * (keepAliveIntervalMs / 2)));
+        // random first tick staggers sockets that connect together (reconnect storms)
+        schedule(Math.floor(Math.random() * (keepAliveIntervalMs / 2)));
         keepAliveReq = {
             cb,
             cancel: () => {
-                clearSafeTimer(starter);
-                clearSafeTimer(pinger);
+                stopped = true;
+                clearSafeTimer(timer);
             }
         };
     };
@@ -944,13 +1093,13 @@ export const makeSocket = (config) => {
         }
         catch (err) {
             logger.error({ err }, 'error in validating connection');
-            void end(err);
+            void handleDisconnect(err);
         }
     });
-    ws.on('error', mapWebSocketError(end));
-    ws.on('close', () => void end(new Boom('Connection Terminated', { statusCode: DisconnectReason.connectionClosed })));
+    ws.on('error', mapWebSocketError(handleDisconnect));
+    ws.on('close', () => void handleDisconnect(new Boom('Connection Terminated', { statusCode: DisconnectReason.connectionClosed })));
     // the server terminated the connection
-    ws.on('CB:xmlstreamend', () => void end(new Boom('Connection Terminated by Server', { statusCode: DisconnectReason.connectionClosed })));
+    ws.on('CB:xmlstreamend', () => void handleDisconnect(new Boom('Connection Terminated by Server', { statusCode: DisconnectReason.connectionClosed })));
     // QR gen
     ws.on('CB:iq,type:set,pair-device', async (stanza) => {
         const iq = {
@@ -1015,6 +1164,9 @@ export const makeSocket = (config) => {
     });
     // login complete
     ws.on('CB:success', async (node) => {
+        // a completed handshake clears the reconnect budget: the next drop starts from the base delay
+        reconnectAttempts = 0;
+        reconnecting = false;
         try {
             updateServerTimeOffset(node);
             await uploadPreKeysToServerIfRequired();
@@ -1063,7 +1215,7 @@ export const makeSocket = (config) => {
         const [reasonNode] = getAllBinaryNodeChildren(node);
         logger.error({ reasonNode, fullErrorNode: node }, 'stream errored out');
         const { reason, statusCode } = getErrorCodeFromStreamError(node);
-        void end(new Boom(`Stream Errored (${reason})`, { statusCode, data: reasonNode || node }));
+        void handleDisconnect(new Boom(`Stream Errored (${reason})`, { statusCode, data: reasonNode || node }));
     });
     // stream fail, possible logout
     ws.on('CB:failure', async (node) => {
@@ -1079,10 +1231,10 @@ export const makeSocket = (config) => {
                 logger.warn({ err: latest.error?.message }, 'server rejected the client version as too old (405) and the latest version could not be fetched; pass a current `version`');
             }
         }
-        void end(new Boom('Connection Failure', { statusCode: reason, data: node.attrs }));
+        void handleDisconnect(new Boom('Connection Failure', { statusCode: reason, data: node.attrs }));
     });
     ws.on('CB:ib,,downgrade_webclient', () => {
-        void end(new Boom('Multi-device beta not joined', { statusCode: DisconnectReason.multideviceMismatch }));
+        void handleDisconnect(new Boom('Multi-device beta not joined', { statusCode: DisconnectReason.multideviceMismatch }));
     });
     // The server delivers the offline queue in windows and waits for another <offline_batch/>
     // before sending the next one. A single request only drained the first 100 stanzas, so a
@@ -1211,6 +1363,9 @@ export const makeSocket = (config) => {
     const registerSocketEndHandler = (handler) => {
         socketEndHandlers.push(handler);
     };
+    const registerSocketReconnectHandler = (handler) => {
+        socketReconnectHandlers.push(handler);
+    };
     /**
      * Fetches your account's standing when it comes to restrictions.
      * @returns Returns the state of the restrictions.
@@ -1243,6 +1398,14 @@ export const makeSocket = (config) => {
         get user() {
             return authState.creds.me;
         },
+        /**
+         * True while the transport is repairing itself. A host that reads this does not build a
+         * second socket for the same account, which is what a `ws.isOpen === false` check would
+         * make it do during the backoff window and the handshake that follows.
+         */
+        get isReconnecting() {
+            return reconnecting || (reconnectAttempts > 0 && !closed && !ws.isOpen);
+        },
         generateMessageTag,
         ignoreKey: ignoreKeyRegistry.register,
         query,
@@ -1253,6 +1416,7 @@ export const makeSocket = (config) => {
         logout,
         end,
         registerSocketEndHandler,
+        registerSocketReconnectHandler,
         onUnexpectedError,
         uploadPreKeys,
         uploadPreKeysToServerIfRequired,

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

@@ -9,7 +9,7 @@ import { writeFileSync, readFileSync, existsSync } from 'fs';
 import { WAProto } from '../Types/index.js';
 import { LabelAssociationType } from '../Types/LabelAssociation.js';
 import { DEFAULT_CONNECTION_CONFIG } from '../Defaults/index.js';
-import { md5, toNumber, updateMessageWithReceipt, updateMessageWithReaction } from '../Utils/index.js';
+import { BufferJSON, md5, toNumber, updateMessageWithReceipt, updateMessageWithReaction } from '../Utils/index.js';
 import { jidDecode, jidNormalizedUser } from '../WABinary/index.js';
 import { makeOrderedDictionary } from './make-ordered-dictionary.js';
 import { ObjectRepository } from './object-repository.js';
@@ -69,6 +69,9 @@ export const makeInMemoryStore = (config = {}) => {
             }
         }
     };
+    // one key rule for every handler; upsert used alt+normalized while update/receipt/reaction/delete
+    // used raw or non-alt keys, so LID chats never found their stored messages
+    const keyJid = (key) => jidNormalizedUser(key.remoteJidAlt || key.remoteJid);
     const assertMessageList = (jid) => {
         if (!messages[jid]) {
             messages[jid] = makeMessagesDictionary();
@@ -116,8 +119,7 @@ export const makeInMemoryStore = (config = {}) => {
             }
             logger.debug({ deletedContacts: isLatest ? oldContacts.size : 0, newContacts }, 'synced contacts');
             for (const msg of newMessages) {
-                const jid = msg.key.remoteJidAlt || msg.key.remoteJid;
-                const list = assertMessageList(jid);
+                const list = assertMessageList(keyJid(msg.key));
                 list.upsert(msg, 'prepend');
             }
             enforceLimits(messages, groupMetadata, chats, maxChats, maxMessagesPerChat);
@@ -149,9 +151,13 @@ export const makeInMemoryStore = (config = {}) => {
                     }
                 }
                 else {
-                    return logger.debug({ update }, 'got update for non-existant contact');
+                    logger.debug({ update }, 'got update for non-existant contact');
+                    continue;
                 }
-                Object.assign(contacts[contact.id], contact);
+                // was Object.assign(contact, contact): update fields (notify, name...) never landed.
+                // id may be a WA_ADD_NOTIF hash and imgUrl a sentinel, so neither is copied.
+                const { id: _id, imgUrl: _imgUrl, ...fields } = update;
+                Object.assign(contact, fields);
             }
         });
         on('chats.upsert', newChats => {
@@ -211,7 +217,7 @@ export const makeInMemoryStore = (config = {}) => {
                 case 'append':
                 case 'notify':
                     for (const msg of newMessages) {
-                        const jid = jidNormalizedUser(msg.key.remoteJidAlt || msg.key.remoteJid);
+                        const jid = keyJid(msg.key);
                         const list = assertMessageList(jid);
                         list.upsert(msg, 'append');
                         enforceLimits(messages, groupMetadata, chats, maxChats, maxMessagesPerChat);
@@ -231,7 +237,12 @@ export const makeInMemoryStore = (config = {}) => {
         on('messages.update', updates => {
             var _a;
             for (const { update, key } of updates) {
-                const list = assertMessageList(jidNormalizedUser(key.remoteJid));
+                // no create: an update for an unknown chat must not add an empty list that evicts real ones
+                const list = messages[keyJid(key)];
+                if (!list) {
+                    logger.debug({ update }, 'got update for non-existent message');
+                    continue;
+                }
                 if (update === null || update === void 0 ? void 0 : update.status) {
                     const listStatus = (_a = list.get(key.id)) === null || _a === void 0 ? void 0 : _a.status;
                     if (listStatus && (update === null || update === void 0 ? void 0 : update.status) <= listStatus) {
@@ -252,8 +263,7 @@ export const makeInMemoryStore = (config = {}) => {
                 list === null || list === void 0 ? void 0 : list.clear();
             }
             else {
-                const jid = item.keys[0].remoteJidAlt || item.keys[0].remoteJid;
-                const list = messages[jid];
+                const list = messages[keyJid(item.keys[0])];
                 if (list) {
                     const idSet = new Set(item.keys.map(k => k.id));
                     list.filter(m => !idSet.has(m.key.id));
@@ -308,8 +318,7 @@ export const makeInMemoryStore = (config = {}) => {
         });
         on('message-receipt.update', updates => {
             for (const { key, receipt } of updates) {
-                const obj = messages[key.remoteJidAlt || key.remoteJid];
-                const msg = obj === null || obj === void 0 ? void 0 : obj.get(key.id);
+                const msg = messages[keyJid(key)]?.get(key.id);
                 if (msg) {
                     updateMessageWithReceipt(msg, receipt);
                 }
@@ -317,8 +326,7 @@ export const makeInMemoryStore = (config = {}) => {
         });
         on('messages.reaction', (reactions) => {
             for (const { key, reaction } of reactions) {
-                const obj = messages[key.remoteJidAlt || key.remoteJid];
-                const msg = obj === null || obj === void 0 ? void 0 : obj.get(key.id);
+                const msg = messages[keyJid(key)]?.get(key.id);
                 if (msg) {
                     updateMessageWithReaction(msg, reaction);
                 }
@@ -363,28 +371,28 @@ export const makeInMemoryStore = (config = {}) => {
         bind,
         /** loads messages from the store, if not found -- uses the legacy connection */
         loadMessages: async (jid, count, cursor) => {
-            const list = assertMessageList(jid);
+            const list = messages[jid]; // read-only: don't create phantom lists
             const mode = !cursor || 'before' in cursor ? 'before' : 'after';
             const cursorKey = !!cursor ? ('before' in cursor ? cursor.before : cursor.after) : undefined;
-            const cursorValue = cursorKey ? list.get(cursorKey.id) : undefined;
-            let messages;
+            const cursorValue = cursorKey ? list?.get(cursorKey.id) : undefined;
+            let result;
             if (list && mode === 'before' && (!cursorKey || cursorValue)) {
                 if (cursorValue) {
                     const msgIdx = list.array.findIndex(m => m.key.id === (cursorKey === null || cursorKey === void 0 ? void 0 : cursorKey.id));
-                    messages = list.array.slice(0, msgIdx);
+                    result = list.array.slice(0, msgIdx);
                 }
                 else {
-                    messages = list.array;
+                    result = list.array;
                 }
-                const diff = count - messages.length;
+                const diff = count - result.length;
                 if (diff < 0) {
-                    messages = messages.slice(-count); // get the last X messages
+                    result = result.slice(-count); // get the last X messages
                 }
             }
             else {
-                messages = [];
+                result = [];
             }
-            return messages;
+            return result;
         },
         /**
          * Get all available labels for profile
@@ -447,13 +455,13 @@ export const makeInMemoryStore = (config = {}) => {
         toJSON,
         fromJSON,
         writeToFile: (path) => {
-            writeFileSync(path, JSON.stringify(toJSON()));
+            writeFileSync(path, JSON.stringify(toJSON(), BufferJSON.replacer));
         },
         readFromFile: (path) => {
             if (existsSync(path)) {
                 logger.debug({ path }, 'reading from file');
                 const jsonStr = readFileSync(path, { encoding: 'utf-8' });
-                const json = JSON.parse(jsonStr);
+                const json = JSON.parse(jsonStr, BufferJSON.reviver);
                 fromJSON(json);
             }
         }

package/lib/Utils/chat-utils.js

@@ -344,7 +344,6 @@ export const decodePatches = async (name, syncds, initial, getAppStateSyncKey, o
             syncd.mutations?.push(...ref.mutations);
         }
         const patchVersion = toNumber(version.version);
-        newState.version = patchVersion;
         const shouldMutate = typeof minimumVersionNumber === 'undefined' || patchVersion > minimumVersionNumber;
         let decodeResult;
         try {
@@ -358,9 +357,12 @@ export const decodePatches = async (name, syncds, initial, getAppStateSyncKey, o
         catch (err) {
             if (isMissingKeyError(err))
                 throw err;
-            logger?.warn({ name, version: patchVersion, error: err.message }, 'failed to decode patch, skipping');
-            continue;
+            // stop here: advancing the version past an undecoded patch loses its mutations for good;
+            // the next sync resumes from the last good version
+            logger?.warn({ name, version: patchVersion, error: err.message }, 'failed to decode patch, stopping');
+            break;
         }
+        newState.version = patchVersion;
         newState.hash = decodeResult.hash;
         newState.indexValueMap = decodeResult.indexValueMap;
         if (validateMacs) {

package/lib/Utils/connection-manager.d.ts

@@ -0,0 +1,44 @@
+import { EventEmitter } from "events";
+import { Agent } from "https";
+export type ConnectionManagerSession = {
+    id: string;
+    [key: string]: any;
+};
+export type ConnectionManagerOptions = {
+    /** Build one socket for a session. Called again for every reconnect. */
+    create: (session: ConnectionManagerSession) => Promise<any> | any;
+    sessions?: ConnectionManagerSession[];
+    maxConcurrent?: number;
+    reconnect?: boolean;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+    maxAttempts?: number;
+    staggerMs?: number;
+    logger?: any;
+};
+export type ConnectionManagerStats = {
+    total: number;
+    idle: number;
+    connecting: number;
+    open: number;
+    reconnecting: number;
+    closed: number;
+    failed: number;
+    activeConnects: number;
+    queuedConnects: number;
+};
+export declare class ConnectionManager extends EventEmitter {
+    #private;
+    constructor(options: ConnectionManagerOptions);
+    start(): ConnectionManagerStats;
+    get(id: string): any | null;
+    stop(id: string): boolean;
+    close(): Promise<void>;
+    stats(): ConnectionManagerStats;
+}
+export declare const makeConnectionManager: (options: ConnectionManagerOptions) => ConnectionManager;
+export declare const makeWssAgent: (options?: {
+    maxSockets?: number;
+    keepAlive?: boolean;
+    keepAliveMsecs?: number;
+}) => Agent;

package/lib/Utils/connection-manager.js

@@ -0,0 +1,258 @@
+import { EventEmitter } from 'events';
+import { Agent } from 'https';
+import { DisconnectReason } from '../Types/index.js';
+/**
+ * Supervises a fleet of sockets inside one process.
+ *
+ * The library builds and tears down one socket; it deliberately does not reconnect, because only
+ * the host knows which auth state to reload. With hundreds of accounts that leaves three fleet-level
+ * problems to whoever wires them up, and getting them wrong is what makes accounts drop:
+ *
+ *  - every socket reconnecting the moment the server closes it, all at once, which hammers the
+ *    endpoint and gets throttled or banned (this is what `baseDelayMs` + jitter + stagger fix);
+ *  - a permanently dead session (401/403/411/440) being reconnected forever, which is the
+ *    documented path to a ban (this is what DEAD_REASONS stops);
+ *  - unbounded parallel connects, which exhausts FDs and TLS handshakes on boot.
+ *
+ * Events are deliberately never named 'error': EventEmitter throws on an unhandled 'error', and one
+ * dead session must not take the process down.
+ *
+ * ponytail: supervision only. Every socket still shares one event loop, so this bounds reconnect
+ * storms and socket leaks but not CPU-bound crypto; past a few hundred accounts, shard by process.
+ */
+const DEAD_REASONS = new Set([
+    DisconnectReason.loggedOut,
+    DisconnectReason.forbidden,
+    DisconnectReason.multideviceMismatch,
+    DisconnectReason.badSession,
+    DisconnectReason.connectionReplaced
+]);
+export class ConnectionManager extends EventEmitter {
+    #create;
+    #sessions = new Map();
+    #maxConcurrent;
+    #active = 0;
+    #waiters = [];
+    #reconnect;
+    #baseDelayMs;
+    #maxDelayMs;
+    #maxAttempts;
+    #staggerMs;
+    #logger;
+    #started = false;
+    constructor({ create, sessions = [], maxConcurrent = 8, reconnect = true, baseDelayMs = 2000, maxDelayMs = 60000, maxAttempts = Infinity, staggerMs = 250, logger = console }) {
+        super();
+        if (typeof create !== 'function') {
+            throw new TypeError('ConnectionManager needs a create(session) function');
+        }
+        for (const session of sessions) {
+            if (!session?.id) {
+                throw new TypeError('every session needs an id');
+            }
+            if (this.#sessions.has(session.id)) {
+                throw new TypeError(`duplicate session id: ${session.id}`);
+            }
+            this.#sessions.set(session.id, {
+                id: session.id,
+                session,
+                sock: null,
+                state: 'idle',
+                attempts: 0,
+                generation: 0,
+                timer: null,
+                stopped: false,
+                lastError: null
+            });
+        }
+        this.#create = create;
+        this.#maxConcurrent = Math.max(1, maxConcurrent);
+        this.#reconnect = reconnect;
+        this.#baseDelayMs = baseDelayMs;
+        this.#maxDelayMs = maxDelayMs;
+        this.#maxAttempts = maxAttempts;
+        this.#staggerMs = staggerMs;
+        this.#logger = logger;
+    }
+    /** Connect every session, staggered so boot does not fire them all in one tick. */
+    start() {
+        if (this.#started) {
+            return this.stats();
+        }
+        this.#started = true;
+        let index = 0;
+        for (const rec of this.#sessions.values()) {
+            const delayMs = this.#staggerMs * index++;
+            if (!delayMs) {
+                void this.#connect(rec);
+            }
+            else {
+                rec.timer = setTimeout(() => {
+                    rec.timer = null;
+                    void this.#connect(rec);
+                }, delayMs);
+            }
+        }
+        return this.stats();
+    }
+    get(id) {
+        return this.#sessions.get(id)?.sock ?? null;
+    }
+    /** Stop one session for good. A close event that arrives afterwards is ignored. */
+    stop(id) {
+        const rec = this.#sessions.get(id);
+        if (!rec) {
+            return false;
+        }
+        this.#stop(rec);
+        return true;
+    }
+    /** Stop everything and wait for each socket's teardown. */
+    async close() {
+        const pending = [];
+        for (const rec of this.#sessions.values()) {
+            const sock = this.#stop(rec);
+            if (sock) {
+                pending.push(Promise.resolve(sock.end?.(undefined)).catch(() => { }));
+            }
+        }
+        await Promise.all(pending);
+        this.#started = false;
+        this.removeAllListeners();
+    }
+    stats() {
+        const counts = { total: 0, idle: 0, connecting: 0, open: 0, reconnecting: 0, closed: 0, failed: 0 };
+        for (const rec of this.#sessions.values()) {
+            counts.total += 1;
+            counts[rec.state] += 1;
+        }
+        counts.activeConnects = this.#active;
+        counts.queuedConnects = this.#waiters.length;
+        return counts;
+    }
+    #stop(rec) {
+        rec.stopped = true;
+        rec.generation += 1;
+        if (rec.timer) {
+            clearTimeout(rec.timer);
+            rec.timer = null;
+        }
+        const sock = rec.sock;
+        rec.sock = null;
+        rec.state = 'closed';
+        return sock;
+    }
+    async #connect(rec) {
+        if (rec.stopped) {
+            return;
+        }
+        if (rec.timer) {
+            clearTimeout(rec.timer);
+            rec.timer = null;
+        }
+        const generation = ++rec.generation;
+        rec.state = 'connecting';
+        await this.#acquire();
+        let sock;
+        try {
+            sock = await this.#create(rec.session);
+        }
+        catch (err) {
+            this.#release();
+            rec.lastError = err;
+            this.emit('session-error', { id: rec.id, error: err });
+            this.#scheduleReconnect(rec, err);
+            return;
+        }
+        this.#release();
+        // stop() or a newer connect won the race while this one was being created
+        if (rec.stopped || generation !== rec.generation) {
+            void sock?.end?.(undefined);
+            return;
+        }
+        rec.sock = sock;
+        try {
+            sock.ev.on('connection.update', update => this.#onUpdate(rec, sock, update));
+        }
+        catch (err) {
+            rec.lastError = err;
+            this.emit('session-error', { id: rec.id, error: err });
+            this.#scheduleReconnect(rec, err);
+        }
+    }
+    #onUpdate(rec, sock, update) {
+        // a socket that was already replaced must not drive this session any more
+        if (rec.sock !== sock) {
+            return;
+        }
+        const { connection, lastDisconnect, qr } = update;
+        if (qr) {
+            this.emit('qr', { id: rec.id, qr });
+        }
+        if (connection === 'open') {
+            rec.state = 'open';
+            rec.attempts = 0;
+            rec.lastError = null;
+            this.emit('open', { id: rec.id, sock });
+        }
+        else if (connection === 'close') {
+            const error = lastDisconnect?.error;
+            rec.sock = null;
+            rec.lastError = error;
+            this.emit('close', { id: rec.id, error, statusCode: error?.output?.statusCode });
+            this.#scheduleReconnect(rec, error);
+        }
+    }
+    #scheduleReconnect(rec, error) {
+        if (!this.#reconnect || rec.stopped) {
+            rec.state = 'closed';
+            return;
+        }
+        const statusCode = error?.output?.statusCode;
+        if (DEAD_REASONS.has(statusCode) || rec.attempts >= this.#maxAttempts) {
+            rec.state = 'failed';
+            this.#logger?.warn?.({ id: rec.id, statusCode, attempts: rec.attempts }, 'session will not be reconnected');
+            this.emit('dead', { id: rec.id, error, statusCode });
+            return;
+        }
+        // the server asks for a restart on 515; backing off there only delays the reconnect
+        const immediate = statusCode === DisconnectReason.restartRequired;
+        const backoff = Math.min(this.#maxDelayMs, this.#baseDelayMs * 2 ** rec.attempts);
+        const delayMs = immediate ? 0 : Math.round(backoff * (0.75 + Math.random() * 0.5));
+        rec.attempts += 1;
+        rec.state = 'reconnecting';
+        this.emit('reconnect', { id: rec.id, attempt: rec.attempts, delayMs, statusCode });
+        rec.timer = setTimeout(() => {
+            rec.timer = null;
+            void this.#connect(rec);
+        }, delayMs);
+    }
+    #acquire() {
+        if (this.#active < this.#maxConcurrent) {
+            this.#active += 1;
+            return Promise.resolve();
+        }
+        return new Promise(resolve => this.#waiters.push(resolve));
+    }
+    #release() {
+        const next = this.#waiters.shift();
+        if (next) {
+            // hand the slot over without touching the counter
+            next();
+        }
+        else {
+            this.#active -= 1;
+        }
+    }
+}
+export const makeConnectionManager = (options) => new ConnectionManager(options);
+/**
+ * One TLS agent shared by every socket in the fleet. `ws` opens one TCP connection per socket, so
+ * this does not multiplex them, but it does keep the agent, its DNS cache and its free-socket pool
+ * shared instead of one per account.
+ */
+export const makeWssAgent = ({ maxSockets = 256, keepAlive = true, keepAliveMsecs = 30000 } = {}) => new Agent({
+    keepAlive,
+    keepAliveMsecs,
+    maxSockets,
+    maxFreeSockets: Math.min(32, maxSockets)
+});

package/lib/Utils/event-buffer.js

@@ -400,7 +400,8 @@ eventData, logger) {
                     data.contactUpserts[contact.id] = upsert;
                 }
                 if (data.contactUpdates[contact.id]) {
-                    upsert = Object.assign(data.contactUpdates[contact.id], trimUndefined(contact));
+                    // merge into the stored upsert itself; the old code merged into a temp and lost the update
+                    Object.assign(upsert, trimUndefined(data.contactUpdates[contact.id]), trimUndefined(contact));
                     delete data.contactUpdates[contact.id];
                 }
             }
@@ -525,10 +526,8 @@ eventData, logger) {
             const groupUpdates = eventData;
             for (const update of groupUpdates) {
                 const id = update.id;
-                const groupUpdate = data.groupUpdates[id] || {};
-                if (!data.groupUpdates[id]) {
-                    data.groupUpdates[id] = Object.assign(groupUpdate, update);
-                }
+                // merge every update in the window, not just the first
+                data.groupUpdates[id] = Object.assign(data.groupUpdates[id] || {}, update);
             }
             break;
         default:

package/lib/Utils/generics.js

@@ -263,17 +263,32 @@ export const getStatusFromReceiptType = (type) => {
     }
     return status;
 };
-const CODE_MAP = {
-    conflict: DisconnectReason.connectionReplaced
-};
 /**
- * Stream errors generally provide a reason, map that to a baileys DisconnectReason
- * @param reason the string reason given, eg. "conflict"
+ * Stream errors generally provide a reason, map that to a baileys DisconnectReason.
+ * Mirrors zapo-js (src/transport/stream/parse.ts): only conflict means the session is gone;
+ * ack / xml-not-well-formed / unknown reasons are transient and must stay reconnectable.
+ * The old fallback was badSession (500), which made bots wipe healthy sessions.
  */
 export const getErrorCodeFromStreamError = (node) => {
     const [reasonNode] = getAllBinaryNodeChildren(node);
     let reason = reasonNode?.tag || 'unknown';
-    const statusCode = +(node.attrs.code || CODE_MAP[reason] || DisconnectReason.badSession);
+    let statusCode;
+    if (reason === 'conflict') {
+        // type="replaced": another client took over; any other type (device_removed): unlinked
+        statusCode = reasonNode.attrs?.type === 'replaced' || !reasonNode.attrs?.type
+            ? DisconnectReason.connectionReplaced
+            : DisconnectReason.loggedOut;
+    }
+    else if (node.attrs.code) {
+        statusCode = +node.attrs.code;
+        // 516 = server-forced logout
+        if (statusCode === 516) {
+            statusCode = DisconnectReason.loggedOut;
+        }
+    }
+    else {
+        statusCode = DisconnectReason.connectionClosed;
+    }
     if (statusCode === DisconnectReason.restartRequired) {
         reason = 'restart required';
     }

package/lib/Utils/ignore-key.js

@@ -101,7 +101,8 @@ export const buildIgnoreContext = (node, meId, meLid) => {
     const fromMe = !!author && ((!!meId && areJidsSameUser(author, meId)) || (!!meLid && areJidsSameUser(author, meLid)));
     return {
         kind: node.tag,
-        remoteJid: stripDevice(attrs.from),
+        // a 1:1 message sent from another of our devices arrives from us, with the chat in `recipient`
+        remoteJid: stripDevice(fromMe && attrs.recipient ? attrs.recipient : attrs.from),
         fromMe,
         id: attrs.id,
         participant: stripDevice(attrs.participant || attrs.participant_pn || attrs.participant_lid)
@@ -121,7 +122,8 @@ export const matchesIgnoreKey = (entry, ctx, node) => {
         return false;
     }
     const attrs = node.attrs || {};
-    if (entry.remoteJid && !entry.remoteJid.some(wanted => REMOTE_JID_ATTRS.some(attr => sameJid(attrs[attr], wanted)))) {
+    const remoteAttrs = ctx.fromMe && attrs.recipient ? ['recipient', ...REMOTE_JID_ATTRS] : REMOTE_JID_ATTRS;
+    if (entry.remoteJid && !entry.remoteJid.some(wanted => remoteAttrs.some(attr => sameJid(attrs[attr], wanted)))) {
         return false;
     }
     if (entry.participant && !PARTICIPANT_ATTRS.some(attr => sameJid(attrs[attr], entry.participant))) {

package/lib/Utils/index.d.ts

@@ -24,6 +24,7 @@ export * from "./identity-change-handler.js";
 export * from "./stanza-ack.js";
 export * from "./ignore-key.js";
 export * from "./anchor-guard.js";
+export * from "./connection-manager.js";
 export * from "./a2ui.js";
 export * from "./meta-ai-msmsg.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/Utils/index.js

@@ -18,6 +18,7 @@ export * from './event-buffer.js';
 export * from './process-message.js';
 export * from './rich-message-utils.js';
 export * from './message-retry-manager.js';
+export * from './connection-manager.js';
 export * from './browser-utils.js';
 export * from './companion-reg-client-utils.js';
 export * from './identity-change-handler.js';

package/lib/Utils/messages-media.d.ts

@@ -57,6 +57,8 @@ export interface MediaEncryptionOptions {
     };
     saveOriginalFileIfRequired?: boolean;
     opts?: MediaFetchOptions;
+    /** Reuse an existing 32-byte media key instead of generating one (e.g. sticker-pack thumbnails). */
+    mediaKey?: Uint8Array;
 }
 export interface MediaDownloadOptions {
     startByte?: number;

package/lib/Utils/messages-media.js

@@ -481,10 +481,11 @@ class SidecarAccumulator {
         this.windowOffset = SIDECAR_IV_SIZE;
     }
 }
-export const encryptedStream = async (media, mediaType, { logger, saveOriginalFileIfRequired, opts } = {}) => {
+export const encryptedStream = async (media, mediaType, { logger, saveOriginalFileIfRequired, opts, mediaKey: givenMediaKey } = {}) => {
     const { stream, type } = await getStream(media, opts);
     logger?.debug('fetched media stream');
-    const mediaKey = Crypto.randomBytes(32);
+    // sticker-pack thumbnails must reuse the pack's key, the message carries only that one
+    const mediaKey = givenMediaKey ?? Crypto.randomBytes(32);
     const { cipherKey, iv, macKey } = await getMediaKeys(mediaKey, mediaType);
     const encFilePath = join(getTmpFilesDirectory(), mediaType + generateMessageIDV2() + '-enc');
     const encFileWriteStream = createWriteStream(encFilePath);

package/lib/Utils/messages.js

@@ -105,7 +105,8 @@ export const prepareWAMessageMedia = async (message, options) => {
         if (mediaBuff) {
             logger?.debug({ cacheableKey }, 'got media cache hit');
             const obj = proto.Message.decode(mediaBuff);
-            const key = `${mediaType}Message`;
+            // ptv entries are cached after videoMessage was renamed to ptvMessage
+            const key = obj.ptvMessage ? 'ptvMessage' : `${mediaType}Message`;
             Object.assign(obj[key], { ...uploadData, media: undefined });
             return obj;
         }

package/lib/Utils/process-message.js

@@ -114,7 +114,10 @@ export const isRealMessage = (message) => {
         hasSomeContent &&
         !normalizedContent?.protocolMessage &&
         !normalizedContent?.reactionMessage &&
-        !normalizedContent?.pollUpdateMessage);
+        !normalizedContent?.pollUpdateMessage &&
+        // edit envelopes and event responses are not new chat messages (unread/timestamp bump)
+        !normalizedContent?.secretEncryptedMessage &&
+        !normalizedContent?.encEventResponseMessage);
 };
 export const shouldIncrementChatUnread = (message) => !message.key.fromMe && !message.messageStubType;
 /**

package/lib/Utils/rich-message-utils.js

@@ -236,7 +236,7 @@ export const prepareRichResponseMessage = (content) => {
             submessages.push({
                 messageType: RichSubMessageType.LATEX,
                 latexMetadata: {
-                    text,
+                    text: contentText,
                     expressions: latex
                 }
             });

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@violetix/baileys",
-   "version": "0.4.0",
+   "version": "0.5.1",
    "description": "Enhanced Baileys v7 with fixes for newsletter media uploads, plus support for interactive messages, albums, and additional message types.",
    "main": "lib/index.js",
    "types": "lib/index.d.ts",