@aunucore/baileys 1.0.80 → 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/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/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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aunucore/baileys",
   "type": "module",
-  "version": "1.0.80",
+  "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",