@aunucore/baileys 1.0.80 → 1.0.82

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

@@ -44,6 +44,14 @@ export const makeMessagesRecvSocket = (config) => {
      * upstream Baileys retries forever against the same stale session. */
     const decryptFailCounts = new Map();
     const DECRYPT_FAIL_SESSION_RESET_LIMIT = 3;
+    /** AunuBaileys (1.0.82, HB-153): upstream v7 skips the retry for
+     * status broadcasts older than this — the peer has already
+     * deleted the expired status, so a resend can never be honoured
+     * and the failure says nothing about the session. */
+    const STATUS_EXPIRY_SECONDS = 86400;
+    /** AunuBaileys (1.0.82, HB-152): upstream v7 only asks the phone
+     * to resend a placeholder for messages younger than this. */
+    const PLACEHOLDER_MAX_AGE_SECONDS = 14 * 86400;
     /** this mutex ensures that each retryRequest will wait for the previous one to finish */
     const retryMutex = makeMutex();
     // AunuBaileys: bounded by default (see bounded-cache.js) — a TTL
@@ -238,8 +246,28 @@ export const makeMessagesRecvSocket = (config) => {
             }
             if (retryCount > 1 || forceIncludeKeys) {
                 const { update, preKeys } = await getNextPreKeys(authState, 1);
-                const [keyId] = Object.keys(preKeys);
-                const key = preKeys[+keyId];
+                let [keyId] = Object.keys(preKeys);
+                let key = preKeys[+keyId];
+                if (!key) {
+                    // AunuBaileys (1.0.82, HB-154 + addendum): the
+                    // stored head pre-key is missing entirely (store
+                    // cleaned / partial restore) or was filtered out
+                    // as corrupt by getNextPreKeys ({} / wrong-typed
+                    // material, HB-83/98 filter) — the map came back
+                    // empty and the bare deref below used to throw a
+                    // TypeError inside this transaction: the receipt
+                    // was never built, yet the retry counter above
+                    // was already spent. Generate a fresh pair into
+                    // the dead head slot instead: `update` advances
+                    // firstUnuploadedPreKeyId past exactly this id,
+                    // and the write joins this transaction, so the
+                    // private half is persisted before the receipt
+                    // carrying its public half is sent.
+                    keyId = `${authState.creds.firstUnuploadedPreKeyId}`;
+                    key = Curve.generateKeyPair();
+                    await authState.keys.set({ 'pre-key': { [keyId]: key } });
+                    logger.warn({ keyId }, 'aunu: no usable stored pre-key for the retry receipt; generated a fresh one into the head slot');
+                }
                 const content = receipt.content;
                 content.push({
                     tag: 'keys',
@@ -670,7 +698,21 @@ export const makeMessagesRecvSocket = (config) => {
         msgRetryCache.set(key, newValue);
     };
     const sendMessagesAgain = async (key, ids, retryNode, sessionPreInjected = false) => {
-        const msgs = await Promise.all(ids.map(async (id) => (await getMessage({ ...key, id })) ?? sentMessageCacheFor(config, (jid) => aunuLid?.getAltJid?.(jid)).get(key.remoteJid, id)));
+        // AunuBaileys (1.0.82, HB-107): per-id isolation at the FETCH
+        // stage, mirroring HB-61 at the relay stage below. getMessage
+        // is host code (a DB/file store can throw); one throwing id
+        // used to reject the whole Promise.all, so NO id in the batch
+        // was resent this round and no retry counter advanced — the
+        // next peer receipt walked into the same wall.
+        const msgs = await Promise.all(ids.map(async (id) => {
+            try {
+                return (await getMessage({ ...key, id })) ?? sentMessageCacheFor(config, (jid) => aunuLid?.getAltJid?.(jid)).get(key.remoteJid, id);
+            }
+            catch (err) {
+                logger.warn({ err, jid: key.remoteJid, id }, 'aunu: getMessage failed for one id in a retry batch; treating it as unavailable and continuing with the rest');
+                return undefined;
+            }
+        }));
         const remoteJid = key.remoteJid;
         const participant = key.participant || remoteJid;
         // if it's the primary jid sending the request
@@ -775,7 +817,18 @@ export const makeMessagesRecvSocket = (config) => {
                         // correctly set who is asking for the retry
                         key.participant = key.participant || attrs.from;
                         const retryNode = getBinaryNodeChild(node, 'retry');
-                        if (willSendMessageAgain(ids[0], key.participant)) {
+                        // AunuBaileys (1.0.82, HB-160): the gate used
+                        // to check ids[0] ALONE — a capped first id
+                        // starved the fresh ids behind it, and a
+                        // fresh first id let capped ids behind it be
+                        // resent past the cap without limit. Filter
+                        // per id; the loop below only ever sees ids
+                        // that still have budget.
+                        const eligibleIds = ids.filter(id => willSendMessageAgain(id, key.participant));
+                        if (eligibleIds.length < ids.length) {
+                            logger.debug({ skipped: ids.filter(id => !eligibleIds.includes(id)), participant: key.participant }, 'aunu: some ids in the retry receipt are at the resend cap; resending only the rest');
+                        }
+                        if (eligibleIds.length) {
                             if (key.fromMe) {
                                 try {
                                     logger.debug({ attrs, key }, 'recv retry request');
@@ -796,7 +849,7 @@ export const makeMessagesRecvSocket = (config) => {
                                             logger.debug({ err: injErr }, 'aunu: retry receipt bundle injection failed; falling back to server fetch');
                                         }
                                     }
-                                    await sendMessagesAgain(key, ids, retryNode, sessionPreInjected);
+                                    await sendMessagesAgain(key, eligibleIds, retryNode, sessionPreInjected);
                                 }
                                 catch (error) {
                                     logger.error({ key, ids, trace: error.stack }, 'error in sending message again');
@@ -880,13 +933,37 @@ export const makeMessagesRecvSocket = (config) => {
         let response;
         if (getBinaryNodeChild(node, 'unavailable') && !encNode) {
             await sendMessageAck(node);
-            const { key } = decodeMessageNode(node, authState.creds.me?.id, authState.creds.me?.lid || '').fullMessage;
+            // AunuBaileys (1.0.82, HB-146): this decode sat OUTSIDE
+            // any try (the HB-1 fix covered only the decrypt path
+            // below). A stanza whose `from` is not a recognised JID
+            // type — malformed today, a future JID domain tomorrow —
+            // threw 'Unknown message type' after the ack had already
+            // gone out: only logged by the caller, and the
+            // placeholder was never resent nor upserted. Classify
+            // and drop it here, like the main decode path.
+            let key;
+            try {
+                key = decodeMessageNode(node, authState.creds.me?.id, authState.creds.me?.lid || '').fullMessage.key;
+            }
+            catch (decodeErr) {
+                logger.error({ error: decodeErr, node }, 'aunu: error decoding unavailable message node; acked, skipping placeholder resend');
+                return;
+            }
             // AunuBaileys: bot / hosted / view_once placeholders can never
             // be resent by the phone — don't burn a resend request on
             // them (behaviour learned from @violetix/baileys).
             if (isUnrecoverableUnavailable(node)) {
                 logger.debug({ msgId: key.id, unavailableType: unavailablePlaceholderType(node) }, 'unavailable placeholder cannot be resent; skipping resend request');
             }
+            else if (!authState.creds.me?.id) {
+                // AunuBaileys (1.0.82, HB-106): requestPlaceholderResend
+                // throws Boom 'Not authenticated' in the pre-success
+                // window — and because the ack above has ALREADY gone
+                // out, the throw (caught only by the caller's logger)
+                // lost the placeholder silently: no resend, no upsert.
+                // Skip cleanly, like sendRetryRequest does (HB-6).
+                logger.warn({ msgId: key.id }, 'aunu: cannot request placeholder resend before pairing completes; skipping');
+            }
             else {
                 response = await requestPlaceholderResend(key);
             }
@@ -941,14 +1018,85 @@ export const makeMessagesRecvSocket = (config) => {
                     }
                     // message failed to decrypt
                     if (msg.messageStubType === proto.WebMessageInfo.StubType.CIPHERTEXT) {
-                        if (msg?.messageStubParameters?.[0] === MISSING_KEYS_ERROR_TEXT) {
-                            return sendMessageAck(node, NACK_REASONS.ParsingError);
+                        const stubParam = msg?.messageStubParameters?.[0];
+                        const isMissingKeysFailure = stubParam === MISSING_KEYS_ERROR_TEXT;
+                        const isNoMessageFailure = stubParam === NO_MESSAGE_FOUND_ERROR_TEXT;
+                        // AunuBaileys (1.0.82, HB-170): an msmsg (Meta
+                        // AI) failure is a message-SECRET problem, not
+                        // an E2E session problem — @bot has no resend
+                        // path, so a retry receipt only burns budget
+                        // and the fail counter marched toward a
+                        // pointless @bot session reset.
+                        const isMsmsgFailure = encNode?.attrs?.type === 'msmsg' ||
+                            (typeof stubParam === 'string' && stubParam.startsWith('msmsg'));
+                        // AunuBaileys (1.0.82, HB-153): a status that
+                        // expired on the peer can never be resent.
+                        const isExpiredStatusFailure = !isNoMessageFailure &&
+                            isJidStatusBroadcast(msg.key.remoteJid) &&
+                            Number.isFinite(+node.attrs.t) &&
+                            (unixTimestampSeconds() - +node.attrs.t) > STATUS_EXPIRY_SECONDS;
+                        if (isMissingKeysFailure) {
+                            // AunuBaileys (1.0.82, HB-206): the 487
+                            // NACK stays, but the early return is
+                            // gone. 'Key used already or never filled'
+                            // is a SESSION-layer failure, so it now
+                            // flows through the counting / self-heal
+                            // machinery below and the stub upsert at
+                            // the end of this branch, like every other
+                            // decrypt failure — only the retry receipt
+                            // is skipped (a resend of the same
+                            // ciphertext cannot restore a message key
+                            // our ratchet no longer holds).
+                            await sendMessageAck(node, NACK_REASONS.ParsingError);
+                        }
+                        if (isNoMessageFailure) {
+                            // AunuBaileys (1.0.82, HB-152): the stanza
+                            // carried no encrypted content at all —
+                            // there is nothing to re-decrypt and
+                            // nothing wrong with the session, so no
+                            // retry receipt and no fail count (three
+                            // of these used to reset a healthy
+                            // session). Ask the phone for a placeholder
+                            // resend when eligible (v7 policy:
+                            // recoverable type, fresh enough) and let
+                            // the stub upsert below stand as the
+                            // trace. Fire-and-forget: the resend waits
+                            // 5 s and must not hold the processing
+                            // mutex (see the 1.0.70 note in
+                            // sendRetryRequest).
+                            if (!response && !msg.key.fromMe && !isUnrecoverableUnavailable(node) &&
+                                Number.isFinite(+node.attrs.t) &&
+                                (unixTimestampSeconds() - +node.attrs.t) <= PLACEHOLDER_MAX_AGE_SECONDS) {
+                                requestPlaceholderResend(msg.key).then(
+                                    (resendId) => logger.debug({ resendId }, 'aunu: requested placeholder resend for a message with no encrypted content'),
+                                    (err) => logger.debug({ err }, 'aunu: placeholder resend for a message with no encrypted content failed')
+                                );
+                            }
+                            logger.debug({ msgId: msg.key.id, author }, 'aunu: message stanza carried no encrypted content; no retry receipt, no session failure counted');
                         }
-                        retryMutex.mutex(async () => {
+                        else if (isMsmsgFailure) {
+                            logger.debug({ msgId: msg.key.id, author, stubParam }, 'aunu: msmsg decrypt failure; no retry receipt and no session failure counted (a secret problem, not a session problem)');
+                        }
+                        else if (isExpiredStatusFailure) {
+                            logger.debug({ msgId: msg.key.id, author, ageSeconds: unixTimestampSeconds() - +node.attrs.t }, 'aunu: decrypt failure for an expired status; no retry receipt and no session failure counted');
+                        }
+                        else retryMutex.mutex(async () => {
                             if (ws.isOpen) {
-                                if (getBinaryNodeChild(node, 'unavailable')) {
-                                    return;
-                                }
+                                // AunuBaileys (1.0.82, HB-183): the
+                                // blanket early return for stanzas
+                                // carrying an <unavailable> child is
+                                // gone — it suppressed the retry
+                                // receipt, the fail counting, the
+                                // self-heal AND the decrypt-failure
+                                // event for every enc-bearing failure
+                                // that rode along with one (view-once
+                                // above all), leaving the content
+                                // unrecoverable and the rotten session
+                                // uncounted. Upstream v7 has no such
+                                // guard on this path; the placeholder
+                                // choice for unavailable types lives in
+                                // the no-enc branch and in HB-152's
+                                // classification above.
                                 const encNode = getBinaryNodeChild(node, 'enc');
                                 let forceIncludeKeys = !encNode;
                                 if (author) {
@@ -1058,7 +1206,7 @@ export const makeMessagesRecvSocket = (config) => {
                                 // under that device's session; a retry
                                 // receipt would ask ourselves to resend to
                                 // ourselves.
-                                if (!msg.key.fromMe) {
+                                if (!msg.key.fromMe && !isMissingKeysFailure) {
                                     await sendRetryRequest(node, forceIncludeKeys);
                                     if (retryRequestDelayMs) {
                                         await delay(retryRequestDelayMs);
@@ -1474,12 +1622,16 @@ export const makeMessagesRecvSocket = (config) => {
     const offlineNodeProcessor = makeOfflineNodeProcessor();
     const processNode = (type, node, identifier, exec) => {
         // AunuBaileys: ignoreKey filter — a matching stanza is dropped
-        // before any handling (no decryption, no persistence); messages
+        // before any handling (no decryption, no persistence); stanzas
         // are still acked so the server stops redelivering them.
+        // AunuBaileys (1.0.82, HB-210): the ack used to cover only
+        // type 'message' — a dropped receipt/notification/call was
+        // never acked, so the server redelivered it forever while the
+        // rule stayed active (all four real handlers ack in a
+        // finally; the drop bypassed every one of them, against the
+        // filter's own documented intent).
         if (sock.aunuIgnoreFilter?.shouldDrop(type, node, [authState.creds.me?.id, authState.creds.me?.lid].filter(Boolean))) {
-            if (type === 'message') {
-                sendMessageAck(node).catch(() => { });
-            }
+            sendMessageAck(node).catch(() => { });
             logger.debug({ type, from: node.attrs.from, id: node.attrs.id }, 'aunu: stanza dropped by ignoreKey');
             return;
         }
@@ -1727,25 +1879,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/decode-wa-message.js

@@ -287,6 +287,17 @@ export const decryptMessageNode = (stanza, meId, meLid, repository, logger) => {
                                 // 'last' = complete response, 'first' =
                                 // streaming partial, intentionally skipped.
                                 if (botType !== null && !['full', 'last'].includes(botType)) {
+                                    // AunuBaileys (1.0.82, HB-171
+                                    // addendum): the skip used to leave
+                                    // no trace at all — the caller took
+                                    // the SUCCESS branch, sent a
+                                    // 'delivered' receipt and upserted
+                                    // an empty message for content that
+                                    // was never read. Leave a CIPHERTEXT
+                                    // stub, like any other undecrypted
+                                    // content.
+                                    fullMessage.messageStubType = proto.WebMessageInfo.StubType.CIPHERTEXT;
+                                    fullMessage.messageStubParameters = [`msmsg streaming partial skipped (edit=${botType})`];
                                     break;
                                 }
                                 const secretIdCandidates = [botEditTargetId, metaTargetId, fullMessage.key?.id].filter(Boolean);
@@ -315,6 +326,16 @@ export const decryptMessageNode = (stanza, meId, meLid, repository, logger) => {
                                 }
                                 if (!secretCandidates.length) {
                                     logger.warn({ metaTargetId, botType, secretIdCandidates }, 'msmsg: no candidate messageSecret found, skipping');
+                                    // AunuBaileys (1.0.82, HB-171): same
+                                    // false-success as the partial skip
+                                    // above — without a stub the caller
+                                    // receipts this as delivered and
+                                    // stores an empty message. The stub
+                                    // is the trace; messages-recv
+                                    // excludes the msmsg class from
+                                    // retry/fail counting (HB-170).
+                                    fullMessage.messageStubType = proto.WebMessageInfo.StubType.CIPHERTEXT;
+                                    fullMessage.messageStubParameters = ['msmsg: no candidate messageSecret found'];
                                     break;
                                 }
                                 const msMsg = proto.MessageSecretMessage.decode(content);

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.82",
   "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",