@zervonex/baileys 0.0.0-stage → 3.0.1

package/lib/Utils/decode-wa-message.js

@@ -0,0 +1,197 @@
+import { Boom } from '@hapi/boom'
+import { proto } from '../../WAProto/index.js'
+import { areJidsSameUser, isHostedLidUser, isHostedPnUser, isJidBroadcast, isJidGroup, isJidMetaAI, isJidNewsletter, isJidStatusBroadcast, isLidUser, isPnUser } from '../WABinary/index.js'
+import { unpadRandomMax16 } from './generics.js'
+
+export const NO_MESSAGE_FOUND_ERROR_TEXT = 'Message absent from node'
+export const MISSING_KEYS_ERROR_TEXT = 'Key used already or never filled'
+export const ACCOUNT_RESTRICTED_TEXT = 'Your account has been restricted'
+
+export const DECRYPTION_RETRY_CONFIG = { maxRetries: 3, baseDelayMs: 100, sessionRecordErrors: ['No session record', 'SessionError: No session record'] }
+
+export const NACK_REASONS = {
+  ParsingError: 487, UnrecognizedStanza: 488, UnrecognizedStanzaClass: 489, UnrecognizedStanzaType: 490,
+  InvalidProtobuf: 491, InvalidHostedCompanionStanza: 493, MissingMessageSecret: 495,
+  SignalErrorOldCounter: 496, MessageDeletedOnPeer: 499, UnhandledError: 500,
+  UnsupportedAdminRevoke: 550, UnsupportedLIDGroup: 551, DBOperationFailed: 552
+}
+
+export const SERVER_ERROR_CODES = { MessageAccountRestriction: '463', SmaxInvalid: '479' }
+
+export const getDecryptionJid = async (sender, repository, logger) => {
+  if (isJidNewsletter(sender) || isJidStatusBroadcast(sender) || isJidMetaAI(sender)) return sender
+  if (isLidUser(sender) || isHostedLidUser(sender)) return sender
+  return (await repository.lidMapping.getLIDForPN(sender)) || sender
+}
+
+const storeMappingFromEnvelope = async (stanza, sender, repository, decryptionJid, logger, meId, meLid) => {
+  const { senderAlt } = extractAddressingContext(stanza)
+  if (!senderAlt) return
+  if (isLidUser(senderAlt) && isPnUser(sender) && decryptionJid === sender) {
+    if (areJidsSameUser(sender, meId) || areJidsSameUser(senderAlt, meLid)) return
+    try {
+      await repository.lidMapping.storeLIDPNMappings([{ lid: senderAlt, pn: sender }])
+      repository.migrateSession(sender, senderAlt).catch(err => logger?.warn?.({ sender, senderAlt, err }, 'Failed to migrate session (PN→LID)'))
+      logger.debug({ sender, senderAlt }, 'Stored LID mapping from envelope (PN→LID)')
+    } catch (error) { logger.warn({ sender, senderAlt, error }, 'Failed to store LID mapping (PN→LID)') }
+  } else if (isPnUser(senderAlt) && isLidUser(sender)) {
+    if (areJidsSameUser(sender, meLid) || areJidsSameUser(senderAlt, meId)) return
+    try {
+      await repository.lidMapping.storeLIDPNMappings([{ lid: sender, pn: senderAlt }])
+      repository.migrateSession(senderAlt, sender).catch(err => logger?.warn?.({ sender, senderAlt, err }, 'Failed to migrate session (LID→PN)'))
+      logger.debug({ sender, senderAlt }, 'Stored LID mapping from envelope (LID→PN)')
+    } catch (error) { logger.warn({ sender, senderAlt, error }, 'Failed to store LID mapping (LID→PN)') }
+  }
+}
+
+export const extractAddressingContext = stanza => {
+  const sender = stanza.attrs.participant || stanza.attrs.from
+  const addressingMode = stanza.attrs.addressing_mode || (sender?.endsWith('lid') ? 'lid' : 'pn')
+  let senderAlt, recipientAlt
+  if (addressingMode === 'lid') {
+    senderAlt = stanza.attrs.participant_pn || stanza.attrs.sender_pn || stanza.attrs.peer_recipient_pn
+    recipientAlt = stanza.attrs.recipient_pn
+  } else {
+    senderAlt = stanza.attrs.participant_lid || stanza.attrs.sender_lid || stanza.attrs.peer_recipient_lid
+    recipientAlt = stanza.attrs.recipient_lid
+  }
+  return { addressingMode, senderAlt, recipientAlt }
+}
+
+const findChildByTag = (node, tag) => Array.isArray(node?.content) ? node.content.find(c => c?.tag === tag) : undefined
+
+export const extractNewsletterMessageMeta = stanza => {
+  const meta = findChildByTag(stanza, 'meta')
+  if (!meta) return undefined
+  const result = {}
+  const adminProfile = findChildByTag(meta, 'admin_profile')
+  if (adminProfile) {
+    const name = findChildByTag(adminProfile, 'name')
+    const picture = findChildByTag(adminProfile, 'picture')
+    const content = name?.content
+    result.adminProfile = {
+      id: adminProfile.attrs?.id,
+      name: typeof content === 'string' ? content : content instanceof Uint8Array ? Buffer.from(content).toString('utf-8') : undefined,
+      pictureId: picture?.attrs?.id,
+      pictureDirectPath: picture?.attrs?.direct_path
+    }
+  }
+  if (findChildByTag(meta, 'paid_partnership')) result.paidPartnership = true
+  if (findChildByTag(meta, 'ai_content')) result.aiContent = true
+  return result
+}
+
+export const decodeMessageNode = (stanza, meId, meLid) => {
+  let msgType, chatId, author, fromMe = false
+  const { id: msgId, from, participant, recipient } = stanza.attrs
+  const addressingContext = extractAddressingContext(stanza)
+  const isMe = jid => areJidsSameUser(jid, meId)
+  const isMeLid = jid => areJidsSameUser(jid, meLid)
+
+  if (isPnUser(from) || isLidUser(from) || isHostedLidUser(from) || isHostedPnUser(from)) {
+    if (isMe(from) || isMeLid(from)) fromMe = true
+    chatId = (recipient && !isJidMetaAI(recipient)) ? (fromMe ? recipient : (() => { throw new Boom('recipient present, but msg not from me', { data: stanza }) })()) : from
+    msgType = 'chat'; author = from
+  } else if (isJidGroup(from)) {
+    if (!participant) throw new Boom('No participant in group message')
+    if (isMe(participant) || isMeLid(participant)) fromMe = true
+    msgType = 'group'; author = participant; chatId = from
+  } else if (isJidBroadcast(from)) {
+    if (!participant) throw new Boom('No participant in group message')
+    const isParticipantMe = isMe(participant)
+    msgType = isJidStatusBroadcast(from) ? (isParticipantMe ? 'direct_peer_status' : 'other_status') : (isParticipantMe ? 'peer_broadcast' : 'other_broadcast')
+    fromMe = isParticipantMe; chatId = from; author = participant
+  } else if (isJidNewsletter(from)) {
+    msgType = 'newsletter'; chatId = from; author = from
+    if (isMe(from) || isMeLid(from)) fromMe = true
+  } else throw new Boom('Unknown message type', { data: stanza })
+
+  const key = {
+    remoteJid: chatId,
+    remoteJidAlt: !isJidGroup(chatId) ? addressingContext.senderAlt : undefined,
+    fromMe, id: msgId, participant,
+    participantAlt: isJidGroup(chatId) ? addressingContext.senderAlt : undefined,
+    addressingMode: addressingContext.addressingMode,
+    ...(msgType === 'newsletter' && stanza.attrs.server_id ? { server_id: stanza.attrs.server_id } : {})
+  }
+  const fullMessage = { key, messageTimestamp: +stanza.attrs.t, pushName: stanza.attrs?.notify, broadcast: isJidBroadcast(from) }
+  if (key.fromMe) fullMessage.status = proto.WebMessageInfo.Status.SERVER_ACK
+  return { fullMessage, author, sender: msgType === 'chat' ? author : chatId }
+}
+
+export const decryptMessageNode = (stanza, meId, meLid, repository, logger) => {
+  const { fullMessage, author, sender } = decodeMessageNode(stanza, meId, meLid)
+  return {
+    fullMessage,
+    category: stanza.attrs.category,
+    author,
+    async decrypt() {
+      let decryptables = 0
+      if (Array.isArray(stanza.content)) {
+        for (const { tag, attrs, content } of stanza.content) {
+          if (tag === 'verified_name' && content instanceof Uint8Array) {
+            const cert = proto.VerifiedNameCertificate.decode(content)
+            fullMessage.verifiedBizName = proto.VerifiedNameCertificate.Details.decode(cert.details).verifiedName
+          }
+          if (tag === 'unavailable' && attrs.type === 'view_once') fullMessage.key.isViewOnce = true
+          if (tag !== 'enc' && tag !== 'plaintext') continue
+          if (!(content instanceof Uint8Array)) continue
+          decryptables++
+          const decryptionJid = await getDecryptionJid(author, repository, logger)
+          const { senderAlt } = extractAddressingContext(stanza)
+          const decryptionAltJid = senderAlt ? await getDecryptionJid(senderAlt, repository, logger) : null
+          if (tag !== 'plaintext') storeMappingFromEnvelope(stanza, author, repository, decryptionJid, logger, meId, meLid).catch(err => logger?.warn?.({ err }, 'storeMappingFromEnvelope failed'))
+          try {
+            const e2eType = tag === 'plaintext' ? 'plaintext' : attrs.type
+            switch (e2eType) {
+              case 'skmsg':
+                try {
+                  fullMessage._msgBuffer = await repository.decryptGroupMessage({ group: sender, authorJid: author, msg: content })
+                } catch (decryptErr) {
+                  const errMsg = decryptErr?.message || decryptErr?.toString() || ''
+                  if (errMsg.includes('memory access out of bounds')) {
+                    console.error('[Signal] Stale sender key — group:', sender, 'author:', author, 'err:', errMsg)
+                    await repository.deleteSenderKey(sender, author).catch(e => console.error('[Signal] Failed to delete sender key:', e))
+                  }
+                  throw decryptErr
+                }
+                break
+              case 'pkmsg':
+              case 'msg': {
+                const buf = await repository.decryptMessage({ jid: decryptionJid, type: e2eType, ciphertext: content })
+                if (buf === null) return // DuplicatedMessage — libsignal handled silently
+                fullMessage._msgBuffer = buf
+                break
+              }
+              case 'plaintext':
+                fullMessage._msgBuffer = content
+                break
+              case 'msmsg':
+                if (!stanza.attrs._msmsgDecrypted) throw new Error('msmsg type but no pre-decrypted message available')
+                { let msg = stanza.attrs._msmsgDecrypted; msg = msg.deviceSentMessage?.message || msg; fullMessage.message ? Object.assign(fullMessage.message, msg) : (fullMessage.message = msg) }
+                continue
+              default:
+                throw new Error(`Unknown e2e type: ${e2eType}`)
+            }
+            let msg = proto.Message.decode(e2eType !== 'plaintext' ? unpadRandomMax16(fullMessage._msgBuffer) : fullMessage._msgBuffer)
+            msg = msg.deviceSentMessage?.message || msg
+            if (msg.senderKeyDistributionMessage) {
+              await repository.processSenderKeyDistributionMessage({ authorJid: author, item: msg.senderKeyDistributionMessage })
+                .catch(err => logger.error({ key: fullMessage.key, err }, 'failed to process sender key distribution message'))
+            }
+            fullMessage.message ? Object.assign(fullMessage.message, msg) : (fullMessage.message = msg)
+            const viewOnceInner = msg?.viewOnceMessage?.message || msg?.viewOnceMessageV2?.message || msg?.viewOnceMessageV2Extension?.message
+            if (viewOnceInner?.imageMessage?.viewOnce || viewOnceInner?.videoMessage?.viewOnce || viewOnceInner?.audioMessage?.viewOnce) fullMessage.key.isViewOnce = true
+          } catch (err) {
+            const errStr = err?.message || (typeof err === 'string' ? err : '') || ''
+            const isExpected = errStr.includes('InvalidPreKeyId') || errStr.includes('SessionNotFound') || errStr.includes('InvalidMessage') || errStr.includes('no sender key state') || errStr.includes('memory access out of bounds') || errStr.includes('old counter') || errStr.includes('DuplicatedMessage') || errStr.includes('BadMac')
+              ; (isExpected ? logger?.debug?.bind(logger) : logger?.error?.bind(logger))?.({ key: fullMessage.key, err, errStr, messageType: tag === 'plaintext' ? 'plaintext' : attrs.type, sender, author }, 'failed to decrypt message')
+            fullMessage.messageStubType = proto.WebMessageInfo.StubType.CIPHERTEXT
+            fullMessage.messageStubParameters = [errStr]
+          }
+        }
+      }
+      if (!decryptables) { fullMessage.messageStubType = proto.WebMessageInfo.StubType.CIPHERTEXT; fullMessage.messageStubParameters = [NO_MESSAGE_FOUND_ERROR_TEXT] }
+    }
+  }
+}

package/lib/Utils/event-buffer.js

@@ -0,0 +1,273 @@
+import EventEmitter from 'events'
+import { WAMessageStatus } from '../Types/index.js'
+import { trimUndefined } from './generics.js'
+import { updateMessageWithReaction, updateMessageWithReceipt } from './messages.js'
+import { isRealMessage, shouldIncrementChatUnread } from './process-message.js'
+
+const BUFFERABLE_EVENT = ['messaging-history.set', 'chats.upsert', 'chats.update', 'chats.delete', 'contacts.upsert', 'contacts.update', 'messages.upsert', 'messages.update', 'messages.delete', 'messages.reaction', 'message-receipt.update', 'groups.update']
+const BUFFERABLE_EVENT_SET = new Set(BUFFERABLE_EVENT)
+
+const BUFFER_TIMEOUT_MS = 30000
+const MAX_HISTORY_CACHE_SIZE = 10000
+
+const makeBufferData = () => ({
+  historySets: { chats: {}, messages: {}, contacts: {}, isLatest: false, empty: true },
+  chatUpserts: {}, chatUpdates: {}, chatDeletes: new Set(),
+  contactUpserts: {}, contactUpdates: {},
+  messageUpserts: {}, messageUpdates: {}, messageReactions: {}, messageDeletes: {}, messageReceipts: {},
+  groupUpdates: {}
+})
+
+const stringifyMessageKey = key => `${key.remoteJid},${key.id},${key.fromMe ? '1' : '0'}`
+
+export const makeEventBuffer = logger => {
+  const ev = new EventEmitter()
+  const historyCache = new Set()
+  let data = makeBufferData()
+  let isBuffering = false
+  let bufferTimeout = null
+  let bufferCount = 0
+
+  ev.on('event', map => { for (const event in map) ev.emit(event, map[event]) })
+
+  function buffer() {
+    bufferCount++
+    if (isBuffering) return
+    logger.debug('Event buffer activated')
+    isBuffering = true
+    if (bufferTimeout) clearTimeout(bufferTimeout)
+    bufferTimeout = setTimeout(() => { if (isBuffering) { logger.warn('Buffer timeout reached, auto-flushing'); flush() } }, BUFFER_TIMEOUT_MS)
+  }
+
+  function flush() {
+    if (!isBuffering) return false
+    logger.debug({ bufferCount }, 'Flushing event buffer')
+    isBuffering = false
+    bufferCount = 0
+    if (bufferTimeout) { clearTimeout(bufferTimeout); bufferTimeout = null }
+    if (historyCache.size > MAX_HISTORY_CACHE_SIZE) { logger.debug({ cacheSize: historyCache.size }, 'Clearing history cache'); historyCache.clear() }
+    const newData = makeBufferData()
+    for (const update of Object.values(data.chatUpdates)) {
+      if (update.conditional) { newData.chatUpdates[update.id] = update; delete data.chatUpdates[update.id] }
+    }
+    const consolidated = consolidateEvents(data)
+    if (Object.keys(consolidated).length) ev.emit('event', consolidated)
+    data = newData
+    logger.trace({ conditionalChatUpdatesLeft: Object.keys(newData.chatUpdates).length }, 'released buffered events')
+    return true
+  }
+
+  return {
+    process(handler) {
+      ev.on('event', handler)
+      return () => ev.off('event', handler)
+    },
+    emit(event, evData) {
+      if (isBuffering && BUFFERABLE_EVENT_SET.has(event)) { append(data, historyCache, event, evData, logger); return true }
+      return ev.emit('event', { [event]: evData })
+    },
+    isBuffering: () => isBuffering,
+    buffer,
+    flush,
+    createBufferedFunction(work) {
+      return async (...args) => {
+        buffer()
+        try {
+          const result = await work(...args)
+          if (bufferCount === 1) setTimeout(() => { if (isBuffering && bufferCount === 1) flush() }, 100)
+          return result
+        } finally {
+          bufferCount = Math.max(0, bufferCount - 1)
+          if (bufferCount === 0) setTimeout(flush, 100)
+        }
+      }
+    },
+    on: (...args) => ev.on(...args),
+    off: (...args) => ev.off(...args),
+    listener: eventName => ev.listenerCount(eventName),
+    removeAllListeners: (...args) => ev.removeAllListeners(...args)
+  }
+}
+
+function append(data, historyCache, event, eventData, logger) {
+  function absorbingChatUpdate(existing) {
+    const chatId = existing.id || ''
+    const update = data.chatUpdates[chatId]
+    if (!update) return
+    const conditionMatches = update.conditional ? update.conditional(data) : true
+    if (conditionMatches) { delete update.conditional; logger.debug({ chatId }, 'absorbed chat update in existing chat'); Object.assign(existing, concatChats(update, existing)); delete data.chatUpdates[chatId] }
+    else if (conditionMatches === false) { logger.debug({ chatId }, 'chat update condition fail, removing'); delete data.chatUpdates[chatId] }
+  }
+
+  function decrementChatReadCounterIfMsgDidUnread(message) {
+    const chatId = message.key.remoteJid
+    const chat = data.chatUpdates[chatId] || data.chatUpserts[chatId]
+    if (isRealMessage(message) && shouldIncrementChatUnread(message) && typeof chat?.unreadCount === 'number' && chat.unreadCount > 0) {
+      logger.debug({ chatId: chat.id }, 'decrementing chat counter')
+      chat.unreadCount -= 1
+      if (chat.unreadCount === 0) delete chat.unreadCount
+    }
+  }
+
+  switch (event) {
+    case 'messaging-history.set':
+      for (const chat of eventData.chats) {
+        const id = chat.id || ''
+        const existing = data.historySets.chats[id]
+        if (existing) existing.endOfHistoryTransferType = chat.endOfHistoryTransferType
+        else if (!historyCache.has(id)) { data.historySets.chats[id] = chat; historyCache.add(id); absorbingChatUpdate(chat) }
+      }
+      for (const contact of eventData.contacts) {
+        const existing = data.historySets.contacts[contact.id]
+        if (existing) Object.assign(existing, trimUndefined(contact))
+        else {
+          const hid = `c:${contact.id}`
+          if (!historyCache.has(hid) || contact.notify || contact.name || contact.verifiedName) { data.historySets.contacts[contact.id] = contact; historyCache.add(hid) }
+        }
+      }
+      for (const message of eventData.messages) {
+        const key = stringifyMessageKey(message.key)
+        if (!data.historySets.messages[key] && !historyCache.has(key)) { data.historySets.messages[key] = message; historyCache.add(key) }
+      }
+      data.historySets.empty = false
+      data.historySets.syncType = eventData.syncType
+      data.historySets.progress = eventData.progress
+      data.historySets.peerDataRequestSessionId = eventData.peerDataRequestSessionId
+      data.historySets.isLatest = eventData.isLatest || data.historySets.isLatest
+      break
+    case 'chats.upsert':
+      for (const chat of eventData) {
+        const id = chat.id || ''
+        let upsert = data.chatUpserts[id]
+        if (id && !upsert) { upsert = data.historySets.chats[id]; if (upsert) logger.debug({ chatId: id }, 'absorbed chat upsert in chat set') }
+        upsert = upsert ? concatChats(upsert, chat) : chat
+        data.chatUpserts[id] = upsert
+        absorbingChatUpdate(upsert)
+        data.chatDeletes.delete(id)
+      }
+      break
+    case 'chats.update':
+      for (const update of eventData) {
+        const chatId = update.id
+        const conditionMatches = update.conditional ? update.conditional(data) : true
+        if (conditionMatches) {
+          delete update.conditional
+          const upsert = data.historySets.chats[chatId] || data.chatUpserts[chatId]
+          if (upsert) concatChats(upsert, update)
+          else data.chatUpdates[chatId] = concatChats(data.chatUpdates[chatId] || {}, update)
+        } else if (conditionMatches === undefined) data.chatUpdates[chatId] = update
+        data.chatDeletes.delete(chatId)
+      }
+      break
+    case 'chats.delete':
+      for (const chatId of eventData) {
+        data.chatDeletes.add(chatId)
+        delete data.chatUpdates[chatId]
+        delete data.chatUpserts[chatId]
+        delete data.historySets.chats[chatId]
+      }
+      break
+    case 'contacts.upsert':
+      for (const contact of eventData) {
+        let upsert = data.contactUpserts[contact.id]
+        if (!upsert) { upsert = data.historySets.contacts[contact.id]; if (upsert) logger.debug({ contactId: contact.id }, 'absorbed contact upsert in contact set') }
+        upsert = upsert ? Object.assign(upsert, trimUndefined(contact)) : contact
+        data.contactUpserts[contact.id] = upsert
+        if (data.contactUpdates[contact.id]) { Object.assign(data.contactUpdates[contact.id], trimUndefined(contact)); delete data.contactUpdates[contact.id] }
+      }
+      break
+    case 'contacts.update':
+      for (const update of eventData) {
+        const upsert = data.historySets.contacts[update.id] || data.contactUpserts[update.id]
+        if (upsert) Object.assign(upsert, update)
+        else data.contactUpdates[update.id] = Object.assign(data.contactUpdates[update.id] || {}, update)
+      }
+      break
+    case 'messages.upsert': {
+      const { messages, type } = eventData
+      for (const message of messages) {
+        const key = stringifyMessageKey(message.key)
+        let existing = data.messageUpserts[key]?.message
+        if (!existing) { existing = data.historySets.messages[key]; if (existing) logger.debug({ messageId: key }, 'absorbed message upsert in message set') }
+        if (existing) message.messageTimestamp = existing.messageTimestamp
+        if (data.messageUpdates[key]) { logger.debug('absorbed prior message update in message upsert'); Object.assign(message, data.messageUpdates[key].update); delete data.messageUpdates[key] }
+        if (data.historySets.messages[key]) data.historySets.messages[key] = message
+        else data.messageUpserts[key] = { message, type: type === 'notify' || data.messageUpserts[key]?.type === 'notify' ? 'notify' : type }
+      }
+      break
+    }
+    case 'messages.update':
+      for (const { key, update } of eventData) {
+        const keyStr = stringifyMessageKey(key)
+        const existing = data.historySets.messages[keyStr] || data.messageUpserts[keyStr]?.message
+        if (existing) {
+          Object.assign(existing, update)
+          if (update.status === WAMessageStatus.READ && !key.fromMe) decrementChatReadCounterIfMsgDidUnread(existing)
+        } else {
+          const msgUpdate = data.messageUpdates[keyStr] || { key, update: {} }
+          Object.assign(msgUpdate.update, update)
+          data.messageUpdates[keyStr] = msgUpdate
+        }
+      }
+      break
+    case 'messages.delete':
+      if ('keys' in eventData) {
+        for (const key of eventData.keys) {
+          const keyStr = stringifyMessageKey(key)
+          if (!data.messageDeletes[keyStr]) data.messageDeletes[keyStr] = key
+          delete data.messageUpserts[keyStr]
+          delete data.messageUpdates[keyStr]
+        }
+      }
+      break
+    case 'messages.reaction':
+      for (const { key, reaction } of eventData) {
+        const keyStr = stringifyMessageKey(key)
+        const existing = data.messageUpserts[keyStr]
+        if (existing) updateMessageWithReaction(existing.message, reaction)
+        else { data.messageReactions[keyStr] = data.messageReactions[keyStr] || { key, reactions: [] }; updateMessageWithReaction(data.messageReactions[keyStr], reaction) }
+      }
+      break
+    case 'message-receipt.update':
+      for (const { key, receipt } of eventData) {
+        const keyStr = stringifyMessageKey(key)
+        const existing = data.messageUpserts[keyStr]
+        if (existing) updateMessageWithReceipt(existing.message, receipt)
+        else { data.messageReceipts[keyStr] = data.messageReceipts[keyStr] || { key, userReceipt: [] }; updateMessageWithReceipt(data.messageReceipts[keyStr], receipt) }
+      }
+      break
+    case 'groups.update':
+      for (const update of eventData) {
+        if (!data.groupUpdates[update.id]) data.groupUpdates[update.id] = Object.assign(data.groupUpdates[update.id] || {}, update)
+      }
+      break
+    default:
+      throw new Error(`"${event}" cannot be buffered`)
+  }
+}
+
+function consolidateEvents(data) {
+  const map = {}
+  const add = (key, list) => { if (list.length) map[key] = list }
+  if (!data.historySets.empty) map['messaging-history.set'] = { chats: Object.values(data.historySets.chats), messages: Object.values(data.historySets.messages), contacts: Object.values(data.historySets.contacts), syncType: data.historySets.syncType, progress: data.historySets.progress, isLatest: data.historySets.isLatest, peerDataRequestSessionId: data.historySets.peerDataRequestSessionId }
+  add('chats.upsert', Object.values(data.chatUpserts))
+  add('chats.update', Object.values(data.chatUpdates))
+  add('chats.delete', Array.from(data.chatDeletes))
+  const messageUpsertList = Object.values(data.messageUpserts)
+  if (messageUpsertList.length) map['messages.upsert'] = { messages: messageUpsertList.map(m => m.message), type: messageUpsertList[0].type }
+  add('messages.update', Object.values(data.messageUpdates))
+  const messageDeleteList = Object.values(data.messageDeletes)
+  if (messageDeleteList.length) map['messages.delete'] = { keys: messageDeleteList }
+  add('messages.reaction', Object.values(data.messageReactions).flatMap(({ key, reactions }) => reactions.map(reaction => ({ key, reaction }))))
+  add('message-receipt.update', Object.values(data.messageReceipts).flatMap(({ key, userReceipt }) => userReceipt.map(receipt => ({ key, receipt }))))
+  add('contacts.upsert', Object.values(data.contactUpserts))
+  add('contacts.update', Object.values(data.contactUpdates))
+  add('groups.update', Object.values(data.groupUpdates))
+  return map
+}
+
+function concatChats(a, b) {
+  if (b.unreadCount === null && a.unreadCount < 0) { a.unreadCount = undefined; b.unreadCount = undefined }
+  if (typeof a.unreadCount === 'number' && typeof b.unreadCount === 'number') { b = { ...b }; if (b.unreadCount >= 0) b.unreadCount = Math.max(b.unreadCount, 0) + Math.max(a.unreadCount, 0) }
+  return Object.assign(a, b)
+}