@aunucore/baileys 1.0.79 → 1.0.81

package/lib/Socket/chats.js

@@ -884,7 +884,19 @@ export const makeChatsSocket = (config) => {
             }
             // update our pushname too
             if (msg.key.fromMe && msg.pushName && authState.creds.me?.name !== msg.pushName) {
-                ev.emit('creds.update', { me: { ...authState.creds.me, name: msg.pushName } });
+                // AunuBaileys (1.0.81, HB-257): 'creds.update' is
+                // not a bufferable event, so this emit is
+                // synchronous — and it sits BEFORE the Promise.all
+                // below, so a throwing listener used to reject
+                // upsertMessage before processMessage ever ran for
+                // this message, costing a NACK 500 on a delivered
+                // stanza. Log and continue with the message.
+                try {
+                    ev.emit('creds.update', { me: { ...authState.creds.me, name: msg.pushName } });
+                }
+                catch (err) {
+                    onUnexpectedError(err, 'creds.update (pushName)');
+                }
             }
         }
         const historyMsg = getHistoryMsg(msg.message);
@@ -917,7 +929,17 @@ export const makeChatsSocket = (config) => {
                 logger.info('App state sync complete, transitioning to Online state and flushing buffer');
                 ev.flush();
                 const accountSyncCounter = (authState.creds.accountSyncCounter || 0) + 1;
-                ev.emit('creds.update', { accountSyncCounter });
+                // AunuBaileys (1.0.81, HB-257): same guard as the
+                // pushName emit above — a throwing 'creds.update'
+                // listener must not reject the app-state sync that
+                // just completed (and skip the rest of this
+                // message's processing with it).
+                try {
+                    ev.emit('creds.update', { accountSyncCounter });
+                }
+                catch (err) {
+                    onUnexpectedError(err, 'creds.update (accountSyncCounter)');
+                }
             }
         };
         await Promise.all([

package/lib/Socket/index.js

@@ -25,6 +25,32 @@ const makeWASocket = (config) => {
         ...DEFAULT_CONNECTION_CONFIG.transactionOpts,
         ...(config?.transactionOpts ?? {})
     };
+    // AunuBaileys (1.0.80, HB-139 + HB-174 + addendum HB-139): the
+    // numeric connection config was spread raw above — an explicit
+    // undefined/NaN from the host (classically `Number(env.X)` of an
+    // unset variable) silently replaced the defaults, and every
+    // failure mode is silent: promiseTimeout(NaN) never settles (a
+    // half-open socket hangs forever), a NaN/0/negative
+    // keepAliveIntervalMs collapses setInterval to 1 ms (~850 ping
+    // IQs per second, and the dead-connection watchdog compares
+    // against NaN so it never fires), and a NaN/Infinity
+    // maxMsgRetryCount breaks both retry gates in opposite
+    // directions at once (retry receipts never capped, resends
+    // never sent). Sanitise once, here at the boundary: timeouts
+    // and intervals must be positive finite (else the documented
+    // default), the retry count must be finite (else the default),
+    // and qrTimeout — which has no Defaults entry (genPairQR falls
+    // back with `|| 60000` / `|| 20000`) — must be positive finite
+    // or absent (a negative value is truthy and would expire every
+    // QR instantly).
+    const positiveFiniteOr = (value, fallback) => (Number.isFinite(value) && value > 0 ? value : fallback);
+    newConfig.connectTimeoutMs = positiveFiniteOr(newConfig.connectTimeoutMs, DEFAULT_CONNECTION_CONFIG.connectTimeoutMs);
+    newConfig.defaultQueryTimeoutMs = positiveFiniteOr(newConfig.defaultQueryTimeoutMs, DEFAULT_CONNECTION_CONFIG.defaultQueryTimeoutMs);
+    newConfig.keepAliveIntervalMs = positiveFiniteOr(newConfig.keepAliveIntervalMs, DEFAULT_CONNECTION_CONFIG.keepAliveIntervalMs);
+    newConfig.maxMsgRetryCount = Number.isFinite(newConfig.maxMsgRetryCount) ? newConfig.maxMsgRetryCount : DEFAULT_CONNECTION_CONFIG.maxMsgRetryCount;
+    if (newConfig.qrTimeout !== undefined && !(Number.isFinite(newConfig.qrTimeout) && newConfig.qrTimeout > 0)) {
+        newConfig.qrTimeout = undefined;
+    }
     // If the user hasn't provided their own history sync function,
     // let's create a default one that respects the syncFullHistory flag.
     if (config.shouldSyncHistoryMessage === undefined) {

package/lib/Socket/interop.js

@@ -425,7 +425,18 @@ export const makeInteropSocket = (sock) => {
             throw new Error(`sendInteropMessage: not an interop JID: ${jid}`);
         }
         const sent = await sock.sendMessage(jid, content, options);
-        ev.emit('interop', { type: 'message.sent', jid, id: sent?.key?.id });
+        // AunuBaileys (1.0.81, HB-196): this emit reports a send
+        // that has ALREADY succeeded — a throwing 'interop'
+        // listener used to reject the promise anyway, so the
+        // caller saw a failure and retried, duplicating a
+        // delivered message. Log the listener error and return
+        // the send result.
+        try {
+            ev.emit('interop', { type: 'message.sent', jid, id: sent?.key?.id });
+        }
+        catch (err) {
+            logger?.error?.({ err }, 'interop: error in message.sent listener');
+        }
         return sent;
     };
     return {

package/lib/Socket/messages-recv.js

@@ -1727,25 +1727,36 @@ export const makeMessagesRecvSocket = (config) => {
         // first without a catch, so a socket that closed in that window
         // (sendNode throws Boom 'Connection Closed') swallowed the
         // status event entirely.
-        ev.emit('newsletter.status', {
-            id: from,
-            messageId: id,
-            serverId,
-            timestamp,
-            isSender,
-            ...(offlineIndex !== undefined ? { offlineIndex } : {}),
-            ...(meta ? { meta } : {}),
-            ...(viewsCount !== undefined ? { viewsCount } : {}),
-            ...(responsesCount !== undefined ? { responsesCount } : {}),
-            ...(reactionCounts.length ? { reactionCounts } : {}),
-            content
-        });
-        const ackType = type === 'reaction' ? 'reaction' : edit ? 'revoke' : type;
-        await sendNode({
-            tag: 'ack',
-            attrs: { id, to: from, class: 'status', type: ackType || 'text' },
-            content: undefined
-        }).catch((err) => logger.warn({ err }, 'failed to ack newsletter status'));
+        // AunuBaileys (1.0.81, HB-192): the ack now sits in a
+        // finally. The emit-first order is unchanged (HB-59), but
+        // a throwing 'newsletter.status' listener can no longer
+        // take the ack down with it — an un-acked <status> stanza
+        // is redelivered (or the status lost) for the sake of a
+        // host bug. The throw itself still propagates to the
+        // CB:status registration's catch, as before.
+        try {
+            ev.emit('newsletter.status', {
+                id: from,
+                messageId: id,
+                serverId,
+                timestamp,
+                isSender,
+                ...(offlineIndex !== undefined ? { offlineIndex } : {}),
+                ...(meta ? { meta } : {}),
+                ...(viewsCount !== undefined ? { viewsCount } : {}),
+                ...(responsesCount !== undefined ? { responsesCount } : {}),
+                ...(reactionCounts.length ? { reactionCounts } : {}),
+                content
+            });
+        }
+        finally {
+            const ackType = type === 'reaction' ? 'reaction' : edit ? 'revoke' : type;
+            await sendNode({
+                tag: 'ack',
+                attrs: { id, to: from, class: 'status', type: ackType || 'text' },
+                content: undefined
+            }).catch((err) => logger.warn({ err }, 'failed to ack newsletter status'));
+        }
     };
     // recv a message
     ws.on('CB:message', (node) => {

package/lib/Socket/socket.js

@@ -367,13 +367,30 @@ export const makeSocket = (config) => {
             }
             catch { }
         }
-        ev.emit('connection.update', {
-            connection: 'close',
-            lastDisconnect: {
-                error,
-                date: new Date()
-            }
-        });
+        // AunuBaileys (1.0.81, HB-138): this emit sits BEFORE the
+        // socket-end handlers and ev.destroy() below — cleanup the
+        // lib owns (watchdog stop, offline-drain stop, scheduled-
+        // task cleanup). A throwing host 'connection.update'
+        // listener used to unwind straight out of end() — and,
+        // via the ws 'error'/'close' handlers that call end(),
+        // out of the ws emit chain into an uncaught exception —
+        // skipping all of it, with no recovery path: `closed` is
+        // already true, so a second end() is a no-op. The
+        // event-buffer dispatcher already logs listener errors
+        // (1.0.81); this guard keeps end()'s own cleanup
+        // unconditional regardless of the emit path.
+        try {
+            ev.emit('connection.update', {
+                connection: 'close',
+                lastDisconnect: {
+                    error,
+                    date: new Date()
+                }
+            });
+        }
+        catch (err) {
+            logger.error({ err }, 'error emitting connection close update');
+        }
         for (const handler of socketEndHandlers) {
             try {
                 handler();

package/lib/Utils/bounded-cache.js

@@ -13,7 +13,15 @@
  * the receive path uses.
  */
 export const makeBoundedTTLCache = ({ ttlSeconds = 3600, maxEntries = 1000 } = {}) => {
-    const ttlMs = Math.max(1, ttlSeconds * 1000);
+    // AunuBaileys (1.0.80, HB-145): NaN/Infinity config defeated
+    // both bounds — `size > NaN` is always false (no eviction,
+    // ever) and a NaN ttlMs made expiresAt NaN, which never
+    // compares <= now, so entries lived forever. Sanitise at the
+    // boundary: finite values keep their exact meaning (counts
+    // are floored and clamped at 0), non-finite values fall back
+    // to the documented defaults (3600 s / 1000 entries).
+    const ttlMs = Number.isFinite(ttlSeconds) ? Math.max(1, ttlSeconds * 1000) : 3600 * 1000;
+    const limit = Number.isFinite(maxEntries) ? Math.max(0, Math.floor(maxEntries)) : 1000;
     const map = new Map();
     return {
         get(key) {
@@ -28,11 +36,20 @@ export const makeBoundedTTLCache = ({ ttlSeconds = 3600, maxEntries = 1000 } = {
         },
         set(key, value) {
             map.set(key, { value, expiresAt: Date.now() + ttlMs });
-            while (map.size > maxEntries) {
-                const oldest = map.keys().next().value;
-                if (oldest === undefined)
+            // AunuBaileys (1.0.80, HB-226): the old guard broke out
+            // when the oldest KEY was `undefined` — but a Map can
+            // legitimately HOLD undefined as a key (two in-tree
+            // callers can produce one: a call offer without a
+            // call-id, a placeholder resend without a message id),
+            // and one such entry silently disabled the ceiling
+            // until it expired. The iterator's `done` flag is the
+            // real "map is empty" signal; deleting an undefined
+            // key is perfectly safe.
+            while (map.size > limit) {
+                const oldest = map.keys().next();
+                if (oldest.done)
                     break;
-                map.delete(oldest);
+                map.delete(oldest.value);
             }
         },
         del(key) {

package/lib/Utils/event-buffer.js

@@ -32,7 +32,25 @@ export const makeEventBuffer = (logger) => {
     // take the generic event and fire it as a baileys event
     ev.on('event', (map) => {
         for (const event in map) {
-            ev.emit(event, map[event]);
+            // AunuBaileys (1.0.81, HB-227/HB-228/HB-229): a host
+            // listener that throws must never escape this
+            // dispatcher. In the host's own call stack a throw is
+            // the host's to catch — but most emits originate inside
+            // lib timers and async callbacks (the nextTick
+            // 'connecting' update, QR cycles, the session
+            // watchdog's interval, PDO resend timeouts, ws
+            // handlers), where no host frame exists to catch it:
+            // the throw became an uncaught exception and killed
+            // the process, or unwound past lib cleanup that still
+            // had to run. Log the error and keep dispatching the
+            // remaining events of the batch; the event itself
+            // still fired, with its payload unchanged.
+            try {
+                ev.emit(event, map[event]);
+            }
+            catch (err) {
+                logger.error({ err, event }, 'error in event listener — dispatch continues');
+            }
         }
     });
     function buffer() {
@@ -58,10 +76,29 @@ export const makeEventBuffer = (logger) => {
             }
         }
         const consolidatedData = consolidateEvents(data);
+        // AunuBaileys (1.0.81, HB-166 + HB-224): swap the fresh
+        // buffer in BEFORE emitting, and guard the emit. The old
+        // order assigned `data = newData` after the emit, so
+        // (a) an event a listener re-buffered during the flush
+        // emit landed in the OLD buffer object and was silently
+        // discarded with it, and (b) a throw mid-emit left the
+        // whole batch in `data`, to be delivered a second time by
+        // the next flush. With the swap first, re-buffered events
+        // survive to the next flush and the emitted batch is
+        // detached no matter what a listener does. The guard
+        // matters because flush() is called from timer callbacks
+        // (chats.js history-sync transitions) and fire-and-forget
+        // paths (processNodeWithBuffer), where a throw became an
+        // uncaught exception / unhandled rejection.
+        data = newData;
         if (Object.keys(consolidatedData).length) {
-            ev.emit('event', consolidatedData);
+            try {
+                ev.emit('event', consolidatedData);
+            }
+            catch (err) {
+                logger.error({ err }, 'error emitting flushed events');
+            }
         }
-        data = newData;
         logger.trace({ conditionalChatUpdatesLeft }, 'released buffered events');
         return true;
     }

package/lib/Utils/lid-store.js

@@ -15,7 +15,16 @@ import { jidNormalizedUser, isJidUser, isLidUser } from '../WABinary/jid-utils.j
  * fed manually via `learnFromMessage` / `addPair`.
  */
 export const makeLIDStore = (options = {}) => {
-    const maxEntries = options.maxEntries ?? 5000;
+    // AunuBaileys (1.0.80, HB-190 + addendum HB-145): `?? 5000`
+    // let NaN through (the eviction comparison `size > NaN` is
+    // always false — the store grew without bound) and let
+    // negatives through (evictIfNeeded's while loop then spun
+    // forever on an empty map: `size > -1` stays true while
+    // delete(undefined) is a no-op — a wedged process, no error).
+    // Sanitise at the boundary: finite values are floored and
+    // clamped at 0 (0 = store nothing, which terminates),
+    // non-finite values fall back to the default 5000.
+    const maxEntries = Number.isFinite(options.maxEntries) ? Math.max(0, Math.floor(options.maxEntries)) : 5000;
     // AunuBaileys (1.0.71): optional listener fired when a genuinely
     // NEW or changed PN<->LID pair is learned (re-learning an already
     // known pair does not fire). The socket wires it to 'lid-mapping.update'.
@@ -29,7 +38,17 @@ export const makeLIDStore = (options = {}) => {
     };
     const evictIfNeeded = () => {
         while (pnToLid.size > maxEntries) {
-            const oldestPn = pnToLid.keys().next().value;
+            // AunuBaileys (1.0.80, HB-190 defence in depth): with a
+            // sanitised maxEntries (>= 0) this loop always
+            // terminates, but never trust a loop whose only exit is
+            // a size comparison — bail out if the map is somehow
+            // already empty (the iterator's `done`, not the key's
+            // value, is the empty signal).
+            const oldest = pnToLid.keys().next();
+            if (oldest.done) {
+                break;
+            }
+            const oldestPn = oldest.value;
             const lid = pnToLid.get(oldestPn);
             pnToLid.delete(oldestPn);
             if (lid) {

package/lib/Utils/sent-message-cache.js

@@ -15,6 +15,14 @@
  * `sentMessagesCacheSize: 0` in the socket config to disable.
  */
 export const makeSentMessageCache = (maxEntries = 256, resolveAlternateJid) => {
+    // AunuBaileys (1.0.80, HB-145): a NaN cap (host config from an
+    // unset env var — sentMessageCacheFor's typeof check passes NaN
+    // straight through) made `cache.size > NaN` false forever, so
+    // the cache grew without bound; Infinity did the same.
+    // Sanitise at the boundary: finite values are floored and
+    // clamped at 0 (0 keeps its documented meaning — the cache is
+    // disabled), non-finite values fall back to the default 256.
+    const limit = Number.isFinite(maxEntries) ? Math.max(0, Math.floor(maxEntries)) : 256;
     const cache = new Map();
     const keyOf = (remoteJid, id) => `${remoteJid}:${id}`;
     let altResolver = typeof resolveAlternateJid === 'function' ? resolveAlternateJid : undefined;
@@ -30,13 +38,13 @@ export const makeSentMessageCache = (maxEntries = 256, resolveAlternateJid) => {
             }
         },
         add: (remoteJid, id, message) => {
-            if (!remoteJid || !id || !message || maxEntries <= 0) {
+            if (!remoteJid || !id || !message || limit <= 0) {
                 return;
             }
             const key = keyOf(remoteJid, id);
             cache.delete(key);
             cache.set(key, message);
-            while (cache.size > maxEntries) {
+            while (cache.size > limit) {
                 cache.delete(cache.keys().next().value);
             }
         },

package/lib/Utils/signal.js

@@ -35,6 +35,19 @@ export const generateOrGetPreKeys = (creds, range) => {
         throw new Error('AunuBaileys: creds.nextPreKeyId / creds.firstUnuploadedPreKeyId are missing — the auth state is incomplete or corrupt; restore a full backup or pair again');
     }
     const avaliable = creds.nextPreKeyId - creds.firstUnuploadedPreKeyId;
+    // AunuBaileys (1.0.80, HB-140 + HB-225): finite-but-INVERTED
+    // counters (firstUnuploadedPreKeyId > nextPreKeyId — hand-edited
+    // or partially restored creds) made `remaining` exceed `range`
+    // by the size of the gap, so the loop below generated keys for
+    // the GAP, not the request: gap 50k ≈ 5 s and +48 MB, gap 200k
+    // ≈ 21 s and +238 MB, and a ~2^31 gap would freeze the process
+    // outright — synchronously, inside the keys transaction, at
+    // every login. Same class as HB-84 above (corrupt counters),
+    // same answer: refuse descriptively. With consistent counters
+    // `remaining` can never exceed `range` by construction.
+    if (avaliable < 0) {
+        throw new Error('AunuBaileys: creds pre-key counters are inverted (firstUnuploadedPreKeyId > nextPreKeyId) — the auth state is corrupt; restore a full backup or pair again');
+    }
     const remaining = range - avaliable;
     const lastPreKeyId = creds.nextPreKeyId + remaining - 1;
     const newPreKeys = {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aunucore/baileys",
   "type": "module",
-  "version": "1.0.79",
+  "version": "1.0.81",
   "description": "AunuBaileys — the self-healing WhatsApp Web API for Node.js. Bad MAC and \"2000 messages into the future\" errors repair themselves, LID and phone-number identities stay in sync, anti-ban is built in, pairing codes are custom — plus 29 experimental features no other Baileys fork ships: invisible watermarks, per-person tag-all cards, side-profile text, ghost mentions and more. ESM, CJS and full TypeScript types.",
   "keywords": [
     "whatsapp",