@aunucore/baileys 1.0.85 → 1.0.87

package/lib/Socket/aunu-experimental.js

@@ -5,6 +5,10 @@ import { generateWAMessageFromContent, prepareWAMessageMedia } from '../Utils/me
 import { proto } from '../../WAProto/index.js';
 import { randomBytes } from 'crypto';
 const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+// AunuBaileys (1.0.86, HB-112 short series): Node clamps any
+// setTimeout delay above 2^31-1 ms (~24.8 days) down to 1 ms, so
+// a longer delay must be armed in slices of at most this size.
+const MAX_TIMER_DELAY_MS = 2 ** 31 - 1;
 /**
  * AunuBaileys EXPERIMENTAL socket features — these exist only in
  * AunuBaileys and may change or disappear in any release:
@@ -125,7 +129,8 @@ export const attachAunuExperimental = (sock) => {
     sock.aunuSchedule = (jid, content, when, options = {}) => {
         const at = when instanceof Date ? when.getTime() : Date.now() + Math.max(0, Number(when) || 0);
         const id = `aunu-sched-${++seq}`;
-        const timer = setTimeout(() => {
+        const entry = { jid, at, timer: undefined };
+        const fire = () => {
             scheduled.delete(id);
             // AunuBaileys (1.0.72): failures used to be swallowed by
             // an empty catch — a scheduled message that failed (socket
@@ -133,9 +138,23 @@ export const attachAunuExperimental = (sock) => {
             Promise.resolve(sock.sendMessage(jid, content, options)).catch((err) => {
                 logger?.warn?.({ err, jid, id }, 'aunu: scheduled message failed to send');
             });
-        }, Math.max(0, at - Date.now()));
-        timer.unref?.();
-        scheduled.set(id, { jid, at, timer });
+        };
+        // AunuBaileys (1.0.86, HB-112 short series): arm in slices.
+        // A single setTimeout for a send scheduled more than ~24.8
+        // days out used to be clamped by Node to 1 ms, so the
+        // message fired IMMEDIATELY and the entry vanished as if
+        // sent on schedule. entry.timer always holds the CURRENT
+        // slice's handle, so cancel and socket-end cleanup (which
+        // read entry.timer) keep working unchanged.
+        const arm = () => {
+            const remaining = at - Date.now();
+            entry.timer = remaining > MAX_TIMER_DELAY_MS
+                ? setTimeout(arm, MAX_TIMER_DELAY_MS)
+                : setTimeout(fire, Math.max(0, remaining));
+            entry.timer.unref?.();
+        };
+        arm();
+        scheduled.set(id, entry);
         return { id, at, cancel: () => sock.aunuCancelScheduled(id) };
     };
     sock.aunuCancelScheduled = (id) => {
@@ -152,14 +171,29 @@ export const attachAunuExperimental = (sock) => {
         const sent = await sock.sendMessage(jid, content, options);
         const key = sent?.key;
         if (key?.id) {
-            const timer = setTimeout(() => {
+            // AunuBaileys (1.0.86, HB-112 short series): same
+            // slice-arming as aunuSchedule — a self-destruct set
+            // more than ~24.8 days out used to be clamped by Node
+            // to 1 ms and deleted the message almost immediately
+            // after it was sent. The map always holds the current
+            // slice's handle, so cancel and socket-end cleanup are
+            // unchanged.
+            const fireAt = Date.now() + Math.max(0.05, Number(seconds) || 0) * 1000;
+            const fire = () => {
                 destructs.delete(key.id);
                 Promise.resolve(sock.sendMessage(jid, { delete: key })).catch((err) => {
                     logger?.warn?.({ err, jid, id: key.id }, 'aunu: self-destruct delete failed');
                 });
-            }, Math.max(0.05, Number(seconds) || 0) * 1000);
-            timer.unref?.();
-            destructs.set(key.id, timer);
+            };
+            const arm = () => {
+                const remaining = fireAt - Date.now();
+                const timer = remaining > MAX_TIMER_DELAY_MS
+                    ? setTimeout(arm, MAX_TIMER_DELAY_MS)
+                    : setTimeout(fire, Math.max(0, remaining));
+                timer.unref?.();
+                destructs.set(key.id, timer);
+            };
+            arm();
         }
         return sent;
     };

package/lib/Socket/chats.js

@@ -82,8 +82,30 @@ export const makeChatsSocket = (config) => {
         // AunuBaileys (1.0.71): a privacy change is a settings change —
         // refetch the full set (the cached copy is now stale) and publish
         // it (donor event: violetix 'privacy.update' on account_sync).
-        privacySettings = await fetchPrivacySettings(true);
-        ev.emit('privacy.update', privacySettings);
+        // AunuBaileys (1.0.87, HB-163): the SET above has already
+        // been applied by the server when this refetch runs. A
+        // refetch failure used to reject the whole privacyQuery —
+        // the caller saw a failed update that had in fact taken
+        // effect, the cache kept the OLD value, and readMessages
+        // derived its receipt type from that stale cache (sending
+        // 'read' receipts against a receipts setting the user had
+        // just switched off). Make the refetch best-effort: on
+        // failure, fold the applied change into the cached copy so
+        // cache and event reflect what the server now holds for
+        // this key. Never fabricate a partial cache when none
+        // exists — that would suppress the next full fetch.
+        try {
+            privacySettings = await fetchPrivacySettings(true);
+        }
+        catch (err) {
+            logger.warn({ err, name, value }, 'failed to refetch privacy settings after a successful set; folding the change into the cached copy');
+            if (privacySettings) {
+                privacySettings = { ...privacySettings, [name]: value };
+            }
+        }
+        if (privacySettings) {
+            ev.emit('privacy.update', privacySettings);
+        }
     };
     const updateMessagesPrivacy = async (value) => {
         await privacyQuery('messages', value);
@@ -906,16 +928,33 @@ export const makeChatsSocket = (config) => {
             }
         }
         const historyMsg = getHistoryMsg(msg.message);
-        const shouldProcessHistoryMsg = historyMsg
+        // AunuBaileys (1.0.86, HB-113 short series): the
+        // shouldSyncHistoryMessage preference governs PASSIVE sync
+        // only. An ON_DEMAND payload is the answer to an explicit
+        // host request (fetchMessageHistory /
+        // requestPlaceholderResend); the single shared gate used
+        // to discard it silently whenever the preference was off
+        // — including the syncFullHistory:false default — so the
+        // host's request vanished without an error and without
+        // the messaging-history.set event. The initial-sync state
+        // machine below keeps the preference-based predicate
+        // (syncPreferenceAllows): on-demand responses must not
+        // drive it. For every non-ON_DEMAND input, and for
+        // ON_DEMAND with the preference on, syncPreferenceAllows
+        // equals the old gate exactly.
+        const syncPreferenceAllows = historyMsg
             ? shouldSyncHistoryMessage(historyMsg) && PROCESSABLE_HISTORY_TYPES.includes(historyMsg.syncType)
             : false;
+        const shouldProcessHistoryMsg = historyMsg?.syncType === proto.HistorySync.HistorySyncType.ON_DEMAND
+            ? true
+            : syncPreferenceAllows;
         // State machine: decide on sync and flush
         if (historyMsg && syncState === SyncState.AwaitingInitialSync) {
             if (awaitingSyncTimeout) {
                 clearTimeout(awaitingSyncTimeout);
                 awaitingSyncTimeout = undefined;
             }
-            if (shouldProcessHistoryMsg) {
+            if (syncPreferenceAllows) {
                 syncState = SyncState.Syncing;
                 logger.info('Transitioned to Syncing state');
                 // Let doAppStateSync handle the final flush after it's done
@@ -929,11 +968,35 @@ export const makeChatsSocket = (config) => {
         const doAppStateSync = async () => {
             if (syncState === SyncState.Syncing) {
                 logger.info('Doing app state sync');
-                await resyncAppState(ALL_WA_PATCH_NAMES, true);
-                // Sync is complete, go online and flush everything
+                // AunuBaileys (1.0.87, HB-241): resyncAppState can
+                // throw OUTSIDE its per-collection handling — the
+                // sync IQ itself, a malformed blob in
+                // extractSyncdPatches, the resync-round cap. That
+                // throw used to reject upsertMessage and leave
+                // syncState at Syncing for the rest of the session:
+                // the full initial sync was never retried (nothing
+                // re-triggers it) and the state machine never
+                // reached Online. A failed sync must END the
+                // Syncing state, not freeze it — go Online and
+                // flush either way, and only count the sync as
+                // complete (the accountSyncCounter advance below)
+                // when it actually succeeded.
+                let syncFailed = false;
+                try {
+                    await resyncAppState(ALL_WA_PATCH_NAMES, true);
+                }
+                catch (err) {
+                    syncFailed = true;
+                    logger.error({ err }, 'app state sync failed; transitioning to Online state anyway');
+                }
+                // Sync ran its course, go online and flush everything
                 syncState = SyncState.Online;
                 logger.info('App state sync complete, transitioning to Online state and flushing buffer');
                 ev.flush();
+                // (HB-241) a failed sync is not a completed one:
+                // do not advance the counter that signals the
+                // initial sync finished.
+                if (!syncFailed) {
                 const accountSyncCounter = (authState.creds.accountSyncCounter || 0) + 1;
                 // AunuBaileys (1.0.81, HB-257): same guard as the
                 // pushName emit above — a throwing 'creds.update'
@@ -946,6 +1009,7 @@ export const makeChatsSocket = (config) => {
                 catch (err) {
                     onUnexpectedError(err, 'creds.update (accountSyncCounter)');
                 }
+                }
             }
         };
         await Promise.all([

package/lib/Socket/messages-recv.js

@@ -1771,7 +1771,14 @@ export const makeMessagesRecvSocket = (config) => {
         }
         const operation = data?.operation;
         const updates = data?.updates;
-        if (!updates || !operation) {
+        // AunuBaileys (1.0.87, HB-121): this guard used to be a
+        // truthiness check only — a MEX payload whose `updates`
+        // is a non-array (object/number/boolean) passed it, and
+        // the for...of loops in every switch branch below threw a
+        // TypeError, silently dropping the whole notification
+        // (handleNotification acks the stanza in its finally
+        // either way, so nothing ever retried it).
+        if (!Array.isArray(updates) || !operation) {
             logger.warn({ data }, 'Invalid mex newsletter notification content');
             return;
         }
@@ -1986,9 +1993,22 @@ export const makeMessagesRecvSocket = (config) => {
                     msg.messageStubType = call.isVideo ? WAMessageStubType.CALL_MISSED_VIDEO : WAMessageStubType.CALL_MISSED_VOICE;
                 }
             }
-            else {
+            else if (call.id) {
                 msg.message = { call: { callKey: Buffer.from(call.id) } };
             }
+            else {
+                // AunuBaileys (1.0.86, HB-216): a group call offer
+                // without a call-id (an optional stanza attr the
+                // decoder does not validate) made Buffer.from throw
+                // a raw TypeError inside this listener; the throw
+                // unwound the whole 'call' emit, so host listeners
+                // registered after this one never saw the offer at
+                // all. There is no call key to reference and the
+                // message key would carry no id either — skip the
+                // notification message; the 'call' event itself
+                // still reaches every listener.
+                return;
+            }
             const protoMsg = proto.WebMessageInfo.fromObject(msg);
             // AunuBaileys: this floated unawaited and uncaught — a
             // rejection here was an unhandledRejection that could kill

package/lib/Socket/messages-send.js

@@ -279,7 +279,17 @@ export const makeMessagesSocket = (config) => {
             try {
             const { recipientJid: jid, ...patchedMessage } = patchedMessageWithJid;
             if (!jid) {
-                return {};
+                // AunuBaileys (1.0.86, HB-136): this used to return
+                // {} — truthy, so it passed the filter below and
+                // counted as a SUCCESSFUL node. A patch whose every
+                // entry lacked a recipientJid therefore "sent" a
+                // stanza with an empty <participants> list and
+                // relayMessage resolved, instead of failing with
+                // 'All encryptions failed' (the encoder silently
+                // drops tag-less children, so the stanza really
+                // went out). Upstream returns null here — the same
+                // value the per-recipient catch below already uses.
+                return null;
             }
             const bytes = encodeWAMessage(patchedMessage);
             let encResult;

package/lib/Socket/mex.js

@@ -22,11 +22,29 @@ export const executeWMexQuery = async (variables, queryId, dataPath, query, gene
     const result = await wMexQuery(variables, queryId, query, generateMessageTag);
     const child = getBinaryNodeChild(result, 'result');
     if (child?.content) {
-        const data = JSON.parse(child.content.toString());
+        // AunuBaileys (1.0.87, HB-211): a <result> that is not JSON
+        // (including a child-node array body, which stringifies to
+        // "[object Object]") used to reject with a raw SyntaxError
+        // the host could not classify.
+        let data;
+        try {
+            data = JSON.parse(child.content.toString());
+        }
+        catch (err) {
+            throw new Boom('GraphQL server error: unparseable response', { statusCode: 400, data: result });
+        }
         if (data.errors && data.errors.length > 0) {
             const errorMessages = data.errors.map((err) => err.message || 'Unknown error').join(', ');
             const firstError = data.errors[0];
-            const errorCode = firstError.extensions?.error_code || 400;
+            // AunuBaileys (1.0.87, HB-211): the server's error_code
+            // went into the Boom constructor unsanitised — a string
+            // code ('RATE_LIMITED') or an out-of-range one (200)
+            // made `new Boom` itself throw a non-Boom TypeError,
+            // and the server's actual error message was lost with
+            // it. Same sanitation as HB-42: only a numeric HTTP
+            // error code survives, everything else becomes 400.
+            const rawErrorCode = firstError.extensions?.error_code;
+            const errorCode = typeof rawErrorCode === 'number' && rawErrorCode >= 400 && rawErrorCode <= 599 ? rawErrorCode : 400;
             throw new Boom(`GraphQL server error: ${errorMessages}`, { statusCode: errorCode, data: firstError });
         }
         const response = dataPath ? data?.data?.[dataPath] : data?.data;

package/lib/Socket/newsletter.d.ts

@@ -22,7 +22,7 @@ export declare const makeNewsletterSocket: (sock: GroupsSocket) => {
     subscribeNewsletterUpdates: (jid: string) => Promise<{
         duration: string;
     } | null>;
-    newsletterAdminCount: (jid: string) => Promise<number>;
+    newsletterAdminCount: (jid: string) => Promise<number | undefined>;
     newsletterChangeOwner: (jid: string, newOwnerJid: string) => Promise<void>;
     newsletterDemote: (jid: string, userJid: string) => Promise<void>;
     newsletterDelete: (jid: string) => Promise<void>;

package/lib/Socket/newsletter.js

@@ -181,7 +181,13 @@ export const makeNewsletterSocket = (sock) => {
         },
         newsletterAdminCount: async (jid) => {
             const response = await executeWMexQuery({ newsletter_id: jid }, QueryIds.ADMIN_COUNT, XWAPaths.xwa2_newsletter_admin_count);
-            return response.admin_count;
+            // AunuBaileys (1.0.86, HB-111 short series): the guard in
+            // executeWMexQuery only rejects an UNDEFINED response —
+            // a GraphQL null for the admin path passes through
+            // verbatim, and this bare deref threw a raw TypeError at
+            // the host. A channel without admin info simply has no
+            // count to report.
+            return response?.admin_count;
         },
         newsletterChangeOwner: async (jid, newOwnerJid) => {
             await executeWMexQuery({ newsletter_id: jid, user_id: newOwnerJid }, QueryIds.CHANGE_OWNER, XWAPaths.xwa2_newsletter_change_owner);

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

@@ -306,6 +306,13 @@ const makeInMemoryStore = ({ logger: _logger, chatKey, labelAssociationKey }) =>
         });
         ev.on('messages.reaction', (reactions) => {
             for (const { key, reaction } of reactions) {
+                // AunuBaileys (1.0.86, HB-187 addendum): a key-less
+                // reaction (host-emitted, or delivered unbuffered)
+                // dereferenced key.remoteJid bare here and threw
+                // inside the listener. It has no target; skip it.
+                if (!key?.remoteJid) {
+                    continue;
+                }
                 const obj = messages[key.remoteJid];
                 const msg = obj === null || obj === void 0 ? void 0 : obj.get(key.id);
                 if (msg) {

package/lib/Utils/aunu-message-inspect.js

@@ -37,31 +37,37 @@ import { jidDecode } from '../WABinary/index.js';
 import { getKeyAuthor } from './generics.js';
 import { getAggregateVotesInPollMessage, normalizeMessageContent } from './messages.js';
 
+// AunuBaileys (1.0.87, HB-218): every operand is optional-chained,
+// exactly like the base getFutureProofMessage in messages.js. A
+// wrapper whose `message` field is absent decodes with message ===
+// null; the bare derefs used to throw a raw TypeError on the next
+// loop iteration of normalizeAunuMessageContentExtended (and in
+// getAggregateVotesInPollMessageExtended downstream of it).
 const getFutureProofMessageExtended = (message) => (
-    message.ephemeralMessage ||
-    message.viewOnceMessage ||
-    message.documentWithCaptionMessage ||
-    message.viewOnceMessageV2 ||
-    message.viewOnceMessageV2Extension ||
-    message.editedMessage ||
-    message.groupMentionedMessage ||
-    message.botInvokeMessage ||
-    message.lottieStickerMessage ||
-    message.eventCoverImage ||
-    message.statusMentionMessage ||
-    message.pollCreationOptionImageMessage ||
-    message.associatedChildMessage ||
-    message.groupStatusMentionMessage ||
-    message.pollCreationMessageV4 ||
-    message.pollCreationMessageV5 ||
-    message.statusAddYours ||
-    message.groupStatusMessage ||
-    message.limitSharingMessage ||
-    message.botTaskMessage ||
-    message.questionMessage ||
-    message.groupStatusMessageV2 ||
-    message.botForwardedMessage ||
-    message.spoilerMessage
+    message?.ephemeralMessage ||
+    message?.viewOnceMessage ||
+    message?.documentWithCaptionMessage ||
+    message?.viewOnceMessageV2 ||
+    message?.viewOnceMessageV2Extension ||
+    message?.editedMessage ||
+    message?.groupMentionedMessage ||
+    message?.botInvokeMessage ||
+    message?.lottieStickerMessage ||
+    message?.eventCoverImage ||
+    message?.statusMentionMessage ||
+    message?.pollCreationOptionImageMessage ||
+    message?.associatedChildMessage ||
+    message?.groupStatusMentionMessage ||
+    message?.pollCreationMessageV4 ||
+    message?.pollCreationMessageV5 ||
+    message?.statusAddYours ||
+    message?.groupStatusMessage ||
+    message?.limitSharingMessage ||
+    message?.botTaskMessage ||
+    message?.questionMessage ||
+    message?.groupStatusMessageV2 ||
+    message?.botForwardedMessage ||
+    message?.spoilerMessage
 );
 
 /**

package/lib/Utils/chat-utils.js

@@ -286,6 +286,22 @@ export const decodePatches = async (name, syncds, initial, getAppStateSyncKey, o
     };
     const mutationMap = {};
     for (const syncd of syncds) {
+      // AunuBaileys (1.0.87, HB-141 + HB-149): snapshot the state
+      // before this patch. The version assignment inside the try
+      // runs BEFORE the patch is decoded, so a patch that failed
+      // (bad content HMAC, missing key, snapshot-MAC mismatch)
+      // still advanced the persisted version past itself — its
+      // mutations were never re-sent by the server, and the LT
+      // hash diverged from the true state permanently: every
+      // later snapshot-MAC check failed while the log claimed the
+      // patch had merely been "skipped". decodeSyncdPatch never
+      // mutates newState in place (the LT-hash generator copies
+      // the index map and returns fresh state), so restoring
+      // these three references in the catch is an exact rollback.
+      const prevVersion = newState.version;
+      const prevHash = newState.hash;
+      const prevIndexValueMap = newState.indexValueMap;
+      const appliedMutations = [];
       try {
         const { version, keyId, snapshotMac } = syncd;
         if (syncd.externalMutations) {
@@ -300,6 +316,11 @@ export const decodePatches = async (name, syncds, initial, getAppStateSyncKey, o
         const decodeResult = await decodeSyncdPatch(syncd, name, newState, getAppStateSyncKey, shouldMutate
             ? mutation => {
                 const index = mutation.syncAction.index?.toString();
+                // (HB-141 + HB-149) record for rollback: a patch
+                // whose snapshot-MAC check fails below has already
+                // delivered its mutations here — they must not
+                // survive being "skipped" either.
+                appliedMutations.push({ index, had: index in mutationMap, prev: mutationMap[index] });
                 mutationMap[index] = mutation;
             }
             : () => { }, true);
@@ -324,6 +345,28 @@ export const decodePatches = async (name, syncds, initial, getAppStateSyncKey, o
         // AunuBaileys: satu patch rusak tidak membunuh seluruh sinkronisasi
         logger?.warn({ err, name, version: syncd.version }, 'skipping undecodable app state patch');
         syncd.mutations = [];
+        // AunuBaileys (1.0.87, HB-141 + HB-149): roll the failed
+        // patch back completely, then stop this batch — later
+        // patches build on this one's state, and letting one of
+        // them advance the persisted version past the hole would
+        // cement the loss. The version stays at the last good
+        // patch, so the next resync re-requests the failed patch
+        // instead of reporting a version that silently skips it;
+        // a transient cause (failed external download, a sync key
+        // that had not arrived yet) now self-heals.
+        newState.version = prevVersion;
+        newState.hash = prevHash;
+        newState.indexValueMap = prevIndexValueMap;
+        for (let i = appliedMutations.length - 1; i >= 0; i--) {
+            const { index, had, prev } = appliedMutations[i];
+            if (had) {
+                mutationMap[index] = prev;
+            }
+            else {
+                delete mutationMap[index];
+            }
+        }
+        break;
       }
     }
     return { state: newState, mutationMap };

package/lib/Utils/event-buffer.js

@@ -100,7 +100,7 @@ export const makeEventBuffer = (logger) => {
                 delete data.chatUpdates[update.id];
             }
         }
-        const consolidatedData = consolidateEvents(data);
+        const consolidatedMaps = 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
@@ -116,12 +116,14 @@ export const makeEventBuffer = (logger) => {
         // paths (processNodeWithBuffer), where a throw became an
         // uncaught exception / unhandled rejection.
         data = newData;
-        if (Object.keys(consolidatedData).length) {
-            try {
-                ev.emit('event', consolidatedData);
-            }
-            catch (err) {
-                logger.error({ err }, 'error emitting flushed events');
+        for (const consolidatedData of consolidatedMaps) {
+            if (Object.keys(consolidatedData).length) {
+                try {
+                    ev.emit('event', consolidatedData);
+                }
+                catch (err) {
+                    logger.error({ err }, 'error emitting flushed events');
+                }
             }
         }
         logger.trace({ conditionalChatUpdatesLeft }, 'released buffered events');
@@ -433,6 +435,17 @@ eventData, logger) {
         case 'messages.reaction':
             const reactions = eventData;
             for (const { key, reaction } of reactions) {
+                // AunuBaileys (1.0.86, HB-187): a reaction whose
+                // target key is missing (an optional proto field)
+                // used to throw a raw TypeError inside
+                // stringifyMessageKey — inside upsertMessage, after
+                // the delivery receipt had already been sent, so
+                // the stanza ALSO earned a NACK 500 and the
+                // reaction was lost. A key-less reaction has no
+                // target to attach to; skip it.
+                if (!key) {
+                    continue;
+                }
                 const keyStr = stringifyMessageKey(key);
                 const existing = data.messageUpserts[keyStr];
                 if (existing) {
@@ -462,10 +475,15 @@ 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);
-                }
+                // AunuBaileys (1.0.86, HB-176): a second update for
+                // the same group inside one buffer window used to
+                // be discarded whole — the merge only ran when no
+                // update was stored yet, so a subject change
+                // followed by a description change delivered only
+                // the subject and the store kept stale metadata.
+                // Merge into the stored update, like chats.update
+                // and contacts.update already do.
+                data.groupUpdates[id] = Object.assign(data.groupUpdates[id] || {}, update);
             }
             break;
         default:
@@ -507,6 +525,11 @@ eventData, logger) {
 }
 function consolidateEvents(data) {
     const map = {};
+    // AunuBaileys (1.0.86, HB-159): extra maps emitted right after
+    // the main one (see the messages.upsert grouping below). The
+    // common single-type case leaves this empty and behaviour is
+    // exactly what it was before.
+    const extraMaps = [];
     if (!data.historySets.empty) {
         map['messaging-history.set'] = {
             chats: Object.values(data.historySets.chats),
@@ -532,11 +555,40 @@ function consolidateEvents(data) {
     }
     const messageUpsertList = Object.values(data.messageUpserts);
     if (messageUpsertList.length) {
-        const type = messageUpsertList[0].type;
+        // AunuBaileys (1.0.86, HB-159): the whole batch used to
+        // take the FIRST message's type. A live 'notify' message
+        // buffered behind offline 'append' messages (the initial
+        // offline drain, or a history resync racing live traffic)
+        // was delivered as 'append' — the store never created its
+        // chat, the unread count vanished, and hosts that only act
+        // on 'notify' never saw a live message. Group by type
+        // instead: same-type batches keep the single consolidated
+        // event; a mixed batch emits one messages.upsert per type
+        // (the extra maps flush right after the main one), every
+        // message keeping its own type, in arrival order.
+        const messagesByType = new Map();
+        for (const entry of messageUpsertList) {
+            const list = messagesByType.get(entry.type);
+            if (list) {
+                list.push(entry.message);
+            }
+            else {
+                messagesByType.set(entry.type, [entry.message]);
+            }
+        }
+        const [firstType, ...otherTypes] = [...messagesByType.keys()];
         map['messages.upsert'] = {
-            messages: messageUpsertList.map(m => m.message),
-            type
+            messages: messagesByType.get(firstType),
+            type: firstType
         };
+        for (const type of otherTypes) {
+            extraMaps.push({
+                'messages.upsert': {
+                    messages: messagesByType.get(type),
+                    type
+                }
+            });
+        }
     }
     const messageUpdateList = Object.values(data.messageUpdates);
     if (messageUpdateList.length) {
@@ -566,7 +618,7 @@ function consolidateEvents(data) {
     if (groupUpdateList.length) {
         map['groups.update'] = groupUpdateList;
     }
-    return map;
+    return [map, ...extraMaps];
 }
 function concatChats(a, b) {
     if (b.unreadCount === null && // neutralize unread counter

package/lib/Utils/history.js

@@ -39,6 +39,17 @@ export const processHistoryMessage = (item) => {
                 delete chat.messages;
                 for (const item of msgs) {
                     const message = item.message;
+                    // AunuBaileys (1.0.86, HB-181): HistorySyncMsg.
+                    // message is an OPTIONAL proto field — a wrapper
+                    // carrying only msgOrderId decodes with message
+                    // === null, and the bare derefs below (starting
+                    // at message.key) threw a TypeError that cost
+                    // the WHOLE history chunk (every conversation
+                    // in the blob was NACKed and lost), not just the
+                    // empty entry. Skip the entry.
+                    if (!message) {
+                        continue;
+                    }
                     messages.push(message);
                     if (!chat.messages?.length) {
                         // keep only the most recent message in the chat array

package/lib/Utils/messages.js

@@ -1334,6 +1334,15 @@ export const generateWAMessageFromContent = (jid, message, options) => {
     }
     const innerMessage = normalizeMessageContent(message);
     const key = getContentType(innerMessage);
+    // AunuBaileys (1.0.86, HB-122): on the raw path the content
+    // value can be a bare string ('conversation') or absent
+    // entirely (key undefined). Quote and ephemeral contextInfo
+    // can only be attached to an object-shaped value — the `in`
+    // check and the property assignment below both threw raw
+    // TypeErrors otherwise (Cannot use 'in' operator... /
+    // Cannot create property 'contextInfo' on string...).
+    const contextTarget = key ? innerMessage[key] : undefined;
+    const canAttachContext = !!contextTarget && typeof contextTarget === 'object';
     const timestamp = unixTimestampSeconds(options.timestamp);
     const { quoted, userJid } = options;
     if (quoted) {
@@ -1348,7 +1357,7 @@ export const generateWAMessageFromContent = (jid, message, options) => {
         if (typeof quotedContent === 'object' && quotedContent && 'contextInfo' in quotedContent) {
             delete quotedContent.contextInfo;
         }
-        const contextInfo = ('contextInfo' in innerMessage[key] && innerMessage[key]?.contextInfo) || {};
+        const contextInfo = (canAttachContext && 'contextInfo' in contextTarget && contextTarget.contextInfo) || {};
         contextInfo.participant = jidNormalizedUser(participant);
         contextInfo.stanzaId = quoted.key.id;
         contextInfo.quotedMessage = quotedMsg;
@@ -1360,9 +1369,9 @@ export const generateWAMessageFromContent = (jid, message, options) => {
         if (!isJidNewsletter(jid) && jid !== quoted.key.remoteJid) {
             contextInfo.remoteJid = quoted.key.remoteJid;
         }
-        if (contextInfo && innerMessage[key]) {
+        if (contextInfo && canAttachContext) {
             /* @ts-ignore */
-            innerMessage[key].contextInfo = contextInfo;
+            contextTarget.contextInfo = contextInfo;
         }
     }
     if (
@@ -1373,7 +1382,9 @@ export const generateWAMessageFromContent = (jid, message, options) => {
         // already not converted to disappearing message
         key !== 'ephemeralMessage' &&
         // newsletters don't support ephemeral messages
-        !isJidNewsletter(jid)) {
+        !isJidNewsletter(jid) &&
+        // and a string/absent content value cannot carry one (HB-122)
+        canAttachContext) {
         /* @ts-ignore */
         innerMessage[key].contextInfo = {
             ...(innerMessage[key].contextInfo || {}),

package/lib/Utils/process-message.js

@@ -284,12 +284,24 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
             ...content.reactionMessage,
             key: message.key
         };
-        ev.emit('messages.reaction', [
-            {
-                reaction,
-                key: content.reactionMessage?.key
-            }
-        ]);
+        // AunuBaileys (1.0.86, HB-187): reactionMessage.key is an
+        // optional proto field — a reaction without it used to be
+        // emitted with key === undefined and detonated downstream
+        // (the event-buffer append and the in-memory store both
+        // deref key.remoteJid) with a raw TypeError, AFTER the
+        // delivery receipt had already been sent: the stanza
+        // earned a NACK 500 on top of its receipt and the reaction
+        // was lost on every redelivery. The reaction has no
+        // target message, so there is nothing to attach it to —
+        // do not emit it at all.
+        if (content.reactionMessage.key) {
+            ev.emit('messages.reaction', [
+                {
+                    reaction,
+                    key: content.reactionMessage.key
+                }
+            ]);
+        }
     }
     else if (message.messageStubType) {
         const jid = message.key?.remoteJid;

package/lib/WAUSync/USyncQuery.js

@@ -110,7 +110,22 @@ export class USyncQuery {
                                 if (errCode === 401 || errCode === 403 || errCode === 405) {
                                     return ['isBlockedByContact', true];
                                 }
-                                throw err;
+                                // AunuBaileys (1.0.87, HB-175): any
+                                // OTHER per-user parser error — the
+                                // protocol node carried an <error>
+                                // child with e.g. a 404 — used to be
+                                // rethrown, aborting the parse of
+                                // the ENTIRE batch: one user's error
+                                // cost every other user's devices /
+                                // contacts, and downstream sends that
+                                // depend on the device list failed
+                                // outright. Treat it the way the
+                                // business parser treats an error
+                                // child: this user simply has no data
+                                // for this protocol (the null is
+                                // dropped by the filter below); the
+                                // rest of the batch continues.
+                                return [protocol, null];
                             }
                         }
                         else {

package/package.json

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