@oxidezap/baileyrs 0.0.26 → 0.0.28

package/lib/Socket/contacts.js

@@ -1,20 +1,22 @@
 export const makeContactMethods = (ctx) => ({
-    onWhatsApp: async (...jids) => {
+    onWhatsApp: async (...phoneNumber) => {
         const client = await ctx.getClient();
         // Single batched usync — the bridge splits PN/LID inputs internally and
         // returns lid/pnJid/isBusiness in the same payload, so no secondary IQ.
-        const results = await client.isOnWhatsApp(jids);
+        const results = await client.isOnWhatsApp(phoneNumber);
         return results.map(r => {
             const out = { exists: r.isRegistered, jid: r.jid, isBusiness: r.isBusiness };
             if (r.lid)
                 out.lid = r.lid;
             if (r.pnJid)
                 out.pnJid = r.pnJid;
+            if (r.verifiedName)
+                out.verifiedName = r.verifiedName;
             return out;
         });
     },
-    profilePictureUrl: async (jid, type = 'preview') => {
-        const result = await (await ctx.getClient()).profilePictureUrl(jid, type);
+    profilePictureUrl: async (jid, type = 'preview', timeoutMs) => {
+        const result = await (await ctx.getClient()).profilePictureUrl(jid, type, timeoutMs);
         return result?.url;
     },
     fetchUserInfo: async (...jids) => {

package/lib/Socket/contacts.js.map

@@ -1 +1 @@
-{"version":3,"file":"contacts.js","sourceRoot":"","sources":["../../src/Socket/contacts.ts"],"names":[],"mappings":"AAWA,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,GAAkB,EAAE,EAAE,CAAC,CAAC;IAC1D,UAAU,EAAE,KAAK,EAAE,GAAG,IAAc,EAA+B,EAAE;QACpE,MAAM,MAAM,GAAG,MAAM,GAAG,CAAC,SAAS,EAAE,CAAA;QACpC,wEAAwE;QACxE,wEAAwE;QACxE,MAAM,OAAO,GAAG,MAAM,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,CAAA;QAC/C,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE;YACtB,MAAM,GAAG,GAAqB,EAAE,MAAM,EAAE,CAAC,CAAC,YAAY,EAAE,GAAG,EAAE,CAAC,CAAC,GAAG,EAAE,UAAU,EAAE,CAAC,CAAC,UAAU,EAAE,CAAA;YAC9F,IAAI,CAAC,CAAC,GAAG;gBAAE,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,CAAA;YAC1B,IAAI,CAAC,CAAC,KAAK;gBAAE,GAAG,CAAC,KAAK,GAAG,CAAC,CAAC,KAAK,CAAA;YAChC,OAAO,GAAG,CAAA;QACX,CAAC,CAAC,CAAA;IACH,CAAC;IAED,iBAAiB,EAAE,KAAK,EAAE,GAAW,EAAE,OAA4B,SAAS,EAAE,EAAE;QAC/E,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,GAAG,CAAC,SAAS,EAAE,CAAC,CAAC,iBAAiB,CAAC,GAAG,EAAE,IAAI,CAAC,CAAA;QACzE,OAAO,MAAM,EAAE,GAAG,CAAA;IACnB,CAAC;IAED,aAAa,EAAE,KAAK,EAAE,GAAG,IAAc,EAAE,EAAE;QAC1C,OAAO,MAAM,CAAC,MAAM,GAAG,CAAC,SAAS,EAAE,CAAC,CAAC,aAAa,CAAC,IAAI,CAAC,CAAA;IACzD,CAAC;CACD,CAAC,CAAA"}
+{"version":3,"file":"contacts.js","sourceRoot":"","sources":["../../src/Socket/contacts.ts"],"names":[],"mappings":"AAaA,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,GAAkB,EAAE,EAAE,CAAC,CAAC;IAC1D,UAAU,EAAE,KAAK,EAAE,GAAG,WAAqB,EAA2C,EAAE;QACvF,MAAM,MAAM,GAAG,MAAM,GAAG,CAAC,SAAS,EAAE,CAAA;QACpC,wEAAwE;QACxE,wEAAwE;QACxE,MAAM,OAAO,GAAG,MAAM,MAAM,CAAC,YAAY,CAAC,WAAW,CAAC,CAAA;QACtD,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE;YACtB,MAAM,GAAG,GAAqB,EAAE,MAAM,EAAE,CAAC,CAAC,YAAY,EAAE,GAAG,EAAE,CAAC,CAAC,GAAG,EAAE,UAAU,EAAE,CAAC,CAAC,UAAU,EAAE,CAAA;YAC9F,IAAI,CAAC,CAAC,GAAG;gBAAE,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,CAAA;YAC1B,IAAI,CAAC,CAAC,KAAK;gBAAE,GAAG,CAAC,KAAK,GAAG,CAAC,CAAC,KAAK,CAAA;YAChC,IAAI,CAAC,CAAC,YAAY;gBAAE,GAAG,CAAC,YAAY,GAAG,CAAC,CAAC,YAAY,CAAA;YACrD,OAAO,GAAG,CAAA;QACX,CAAC,CAAC,CAAA;IACH,CAAC;IAED,iBAAiB,EAAE,KAAK,EAAE,GAAW,EAAE,IAAI,GAAwB,SAAS,EAAE,SAAkB,EAAE,EAAE;QACnG,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,GAAG,CAAC,SAAS,EAAE,CAAC,CAAC,iBAAiB,CAAC,GAAG,EAAE,IAAI,EAAE,SAAS,CAAC,CAAA;QACpF,OAAO,MAAM,EAAE,GAAG,CAAA;IACnB,CAAC;IAED,aAAa,EAAE,KAAK,EAAE,GAAG,IAAc,EAAE,EAAE;QAC1C,OAAO,MAAM,CAAC,MAAM,GAAG,CAAC,SAAS,EAAE,CAAC,CAAC,aAAa,CAAC,IAAI,CAAC,CAAA;IACzD,CAAC;CACD,CAAC,CAAA"}

package/lib/Socket/events.d.ts

@@ -6,20 +6,28 @@
  * mapped type so TS forces a handler per variant — a missing handler
  * is a compile error.
  */
-import type { WhatsAppEvent } from 'whatsapp-rust-bridge';
+import type { WhatsAppEvent, WhatsAppEventCallbacks } from 'whatsapp-rust-bridge';
+import type { CanonicalEvent } from '../Bridge/index.js';
 import type { SocketContext } from './types.js';
 interface EventCallbacks {
     onPairSuccess?: (data: {
         platform?: string;
         businessName?: string;
     }) => void | Promise<void>;
+    onIncomingCall?: (event: Extract<CanonicalEvent, {
+        type: 'incomingCall';
+    }>) => void;
+    onDirtyState?: (event: Extract<CanonicalEvent, {
+        type: 'dirtyState';
+    }>) => void;
 }
 /**
- * Create the event handler that translates canonical events into Baileys
- * events on `ctx.ev`. The handler does NO bridge-shape inspection — that's
- * the schema's job. Field-access here references canonical types
- * exclusively, so a downstream rename surfaces as a `tsc` failure.
+ * Create typed single and batch handlers for the bridge. The bridge only uses
+ * the batch capability when adjacent messages are already queued, while this
+ * layer owns all Baileys-specific translation and EventEmitter aggregation.
  */
+export declare const makeEventHandlers: (ctx: SocketContext, callbacks?: EventCallbacks) => WhatsAppEventCallbacks;
+/** Legacy single-event helper retained for direct consumers and tests. */
 export declare const makeEventHandler: (ctx: SocketContext, callbacks?: EventCallbacks) => (event: WhatsAppEvent) => void;
 export {};
 //# sourceMappingURL=events.d.ts.map

package/lib/Socket/events.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../src/Socket/events.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAqBzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AA+D/C,UAAU,cAAc;IACvB,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CAC5F;AAwiBD;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,GAAI,KAAK,aAAa,EAAE,YAAY,cAAc,MAGtE,OAAO,aAAa,SAe5B,CAAA"}
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../src/Socket/events.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAGX,aAAa,EACb,sBAAsB,EACtB,MAAM,sBAAsB,CAAA;AAC7B,OAAO,KAAK,EAAE,cAAc,EAAoB,MAAM,oBAAoB,CAAA;AA8B1E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAgF/C,UAAU,cAAc;IACvB,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAC5F,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,cAAc,EAAE;QAAE,IAAI,EAAE,cAAc,CAAA;KAAE,CAAC,KAAK,IAAI,CAAA;IACnF,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,cAAc,EAAE;QAAE,IAAI,EAAE,YAAY,CAAA;KAAE,CAAC,KAAK,IAAI,CAAA;CAC/E;AAuuBD;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,QAAS,aAAa,cAAc,cAAc,KAAG,sBA8DlF,CAAA;AAED,0EAA0E;AAC1E,eAAO,MAAM,gBAAgB,QAAS,aAAa,cAAc,cAAc,mCACrC,CAAA"}

package/lib/Socket/events.js

@@ -6,14 +6,25 @@
  * mapped type so TS forces a handler per variant — a missing handler
  * is a compile error.
  */
-import { adaptBridgeEvent } from "../Bridge/index.js";
-import { DisconnectReason, WAProto } from "../Types/index.js";
-import { Boom } from "../Utils/boom.js";
-import { isJidGroup } from "../WABinary/jid-utils.js";
-import { buildGroupJoinRequestEvents, buildGroupNotificationDomainEvent, buildGroupNotificationStubMessages } from "./group-notifications.js";
-import { mapReachoutTimelock } from "./reachout.js";
-const DEF_CALLBACK_PREFIX = 'CB:';
-const DEF_TAG_PREFIX = 'TAG:';
+import { BinaryReader } from 'whatsapp-rust-bridge';
+import { adaptBridgeEvent, adaptBridgeMessageWire } from '../Bridge/index.js';
+import { decodeHistorySyncWireBatch } from '../Bridge/history-sync-wire.js';
+import { bridgeGroupMetadataToBaileys } from '../Compatibility/group-metadata.js';
+import { DEF_CALLBACK_PREFIX, DEF_TAG_PREFIX, HISTORY_SYNC_PAUSED_TIMEOUT_MS } from '../Defaults/index.js';
+import { DisconnectReason, WAMessageStatus, WAProto } from '../Types/index.js';
+import { LabelAssociationType } from '../Types/LabelAssociation.js';
+import { Boom } from '../Utils/boom.js';
+import { toNumber } from '../Utils/generics.js';
+import { CONVERSATION_HISTORY_SYNC_TYPES } from '../Utils/process-history-message.js';
+import { isJidGroup } from '../WABinary/jid-utils.js';
+import { buildGroupCreateStubMessage, buildGroupJoinRequestEvents, buildGroupNotificationChatUpdates, buildGroupNotificationDomainEvent, buildGroupNotificationStubMessages } from '../Compatibility/group-notifications.js';
+import { emitMessageUpsert } from '../Compatibility/message-upsert.js';
+import { extractMessageCappingPayload } from './message-capping.js';
+import { mapReachoutTimelock } from './reachout.js';
+const CANONICAL_MESSAGE_EVENT = 'message';
+const MESSAGE_UPSERT_APPEND = 'append';
+const MESSAGE_UPSERT_NOTIFY = 'notify';
+const MESSAGE_WIRE_OFFSET_SENTINEL_COUNT = 1;
 /** Emit CB: pattern events on the ws EventEmitter for retrocompat. */
 const emitCBEvents = (ctx, node) => {
     const { ws } = ctx;
@@ -71,6 +82,17 @@ const canonicalMessageToWAMessage = (m) => {
         wm.key.editAttribute = m.editAttribute;
     return wm;
 };
+const messageUpsertMetadata = (message) => ({
+    type: message.isOffline ? MESSAGE_UPSERT_APPEND : MESSAGE_UPSERT_NOTIFY,
+    requestId: message.unavailableRequestId
+});
+const hasMessageSideEffects = (message) => message.messageProto.reactionMessage != null || message.messageProto.protocolMessage != null;
+const hasSameUpsertMetadata = (left, right) => left.type === right.type && left.requestId === right.requestId;
+const clearHistorySyncPausedTimeout = (state) => {
+    if (state.pausedTimeout)
+        clearTimeout(state.pausedTimeout);
+    state.pausedTimeout = undefined;
+};
 const emitClose = (ctx, reason, statusCode, data) => ctx.ev.emit('connection.update', {
     connection: 'close',
     lastDisconnect: { error: new Boom(reason, { statusCode, data }), date: new Date() }
@@ -132,7 +154,13 @@ const emitConnectionUpdate = (ctx, update) => ctx.ev.emit('connection.update', u
 const DISPATCHERS = {
     // ── Connection lifecycle ──
     connected: (_, { ctx }) => emitConnectionUpdate(ctx, { connection: 'open' }),
-    disconnected: (_, { ctx }) => emitClose(ctx, 'Connection closed', DisconnectReason.connectionClosed),
+    offlineSyncCompleted: (_, { ctx }) => emitConnectionUpdate(ctx, {
+        receivedPendingNotifications: true
+    }),
+    disconnected: (_, { ctx, historySync }) => {
+        clearHistorySyncPausedTimeout(historySync);
+        emitClose(ctx, 'Connection closed', DisconnectReason.connectionClosed);
+    },
     qr: (evt, { ctx }) => emitConnectionUpdate(ctx, { qr: evt.code }),
     pairSuccess: (evt, { ctx, callbacks }) => {
         const { id, lid, businessName, platform } = evt;
@@ -196,13 +224,7 @@ const DISPATCHERS = {
         // succeeds, not to drop inbound `fromMe` messages from other linked
         // devices.
         const waMsg = canonicalMessageToWAMessage(evt);
-        const upsertPayload = {
-            messages: [waMsg],
-            type: evt.isOffline ? 'append' : 'notify'
-        };
-        if (evt.unavailableRequestId)
-            upsertPayload.requestId = evt.unavailableRequestId;
-        ctx.ev.emit('messages.upsert', upsertPayload);
+        emitMessageUpsert(ctx, [waMsg], messageUpsertMetadata(evt));
         // Mirror upstream `process-message.ts:523-533`: when the inbound
         // proto carries a `reactionMessage`, surface it on the dedicated
         // `messages.reaction` channel as well. The `key` in the event
@@ -260,8 +282,11 @@ const DISPATCHERS = {
                 ]);
             }
             else if (protocolMsg.type === WAProto.Message.ProtocolMessage.Type.MESSAGE_EDIT && protocolMsg.editedMessage) {
+                // `timestampMs` is an int64 proto field → a protobufjs `Long`
+                // object from the bridge; `toNumber` is Long-safe (plain
+                // `Number()` would yield NaN and corrupt the edit timestamp).
                 const tsMs = protocolMsg.timestampMs;
-                const editedTs = tsMs != null ? Math.floor(Number(tsMs) / 1000) : (evt.timestamp ?? waMsg.messageTimestamp);
+                const editedTs = tsMs != null ? Math.floor(toNumber(tsMs) / 1000) : (evt.timestamp ?? waMsg.messageTimestamp);
                 ctx.ev.emit('messages.update', [
                     {
                         key: { ...waMsg.key, id: protocolKeyId },
@@ -383,6 +408,42 @@ const DISPATCHERS = {
     groupUpdate: (evt, { ctx }) => {
         const user = ctx.getUser();
         const fromMe = !!(evt.author && (evt.author === user?.id || evt.author === user?.lid));
+        if (evt.action.type === 'create') {
+            // The neutral bridge marker intentionally carries no Baileys-shaped
+            // metadata. Resolve it here, at the compatibility boundary, then emit
+            // the same complete lifecycle and ordering as upstream.
+            void (async () => {
+                try {
+                    const bridgeMetadata = await (await ctx.getClient()).getGroupMetadata(evt.groupJid);
+                    const metadata = bridgeGroupMetadataToBaileys(bridgeMetadata);
+                    ctx.ev.emit('chats.upsert', [
+                        { id: metadata.id, name: metadata.subject, conversationTimestamp: metadata.creation }
+                    ]);
+                    ctx.ev.emit('groups.upsert', [
+                        {
+                            ...metadata,
+                            author: evt.author,
+                            authorPn: evt.authorPn,
+                            authorUsername: evt.authorUsername
+                        }
+                    ]);
+                    ctx.ev.emit('messages.upsert', {
+                        messages: [buildGroupCreateStubMessage(evt, metadata, fromMe)],
+                        type: 'append'
+                    });
+                }
+                catch (err) {
+                    ctx.logger.warn({ err, groupJid: evt.groupJid }, 'group create notification: metadata resolution failed');
+                }
+            })();
+            return;
+        }
+        // Upstream upserts the synthesized notification message before
+        // process-message derives high-level group/chat events from it.
+        const stubMessages = buildGroupNotificationStubMessages(evt, fromMe);
+        if (stubMessages.length > 0) {
+            ctx.ev.emit('messages.upsert', { messages: stubMessages, type: 'append' });
+        }
         // Dispatch via discriminator instead of `as never` so TS validates
         // payload ↔ event-name pairing.
         const domainEvent = buildGroupNotificationDomainEvent(evt);
@@ -392,25 +453,15 @@ const DISPATCHERS = {
             else
                 ctx.ev.emit('group-participants.update', domainEvent.payload);
         }
-        // `groups.upsert` is intentionally NOT emitted from `<create>`. The
-        // bridge gives us only the creation marker — `participants` /
-        // `subject` / `creation` are unknown without an extra IQ. Upstream
-        // emits this only AFTER `groupMetadata` resolves (`messages-recv.ts:661`),
-        // so emitting `[{ id }]` here would feed consumers a broken
-        // `GroupMetadata` (participants undefined → `metadata.participants.map`
-        // throws). Bots that want the metadata should call
-        // `sock.groupMetadata(evt.groupJid)` from a `groups.update` listener
-        // or after the matching `messages.upsert` stub.
         // Fan out `group.join-request` for membership_approval_request /
         // created_membership_requests / revoked_membership_requests.
         // Upstream emits one event per affected participant.
         for (const joinReq of buildGroupJoinRequestEvents(evt)) {
             ctx.ev.emit('group.join-request', joinReq);
         }
-        const stubMessages = buildGroupNotificationStubMessages(evt, fromMe);
-        if (stubMessages.length > 0) {
-            ctx.ev.emit('messages.upsert', { messages: stubMessages, type: 'notify' });
-        }
+        const chatUpdates = buildGroupNotificationChatUpdates(evt);
+        if (chatUpdates.length > 0)
+            ctx.ev.emit('chats.update', chatUpdates);
     },
     // ── Chat state ──
     archiveUpdate: (evt, { ctx }) => ctx.ev.emit('chats.update', [{ id: evt.jid, archived: evt.archived }]),
@@ -435,16 +486,34 @@ const DISPATCHERS = {
     // Mirrors upstream `chat-utils.ts:852`: read=true → unreadCount=0,
     // read=false (mark as unread) → -1 sentinel.
     ctx.ev.emit('chats.update', [{ id: evt.jid, unreadCount: evt.read ? 0 : -1 }]),
+    labelEdit: (evt, { ctx }) => 
+    // Upstream `labels.edit` carries a `Label`. A delete arrives with
+    // `deleted: true` (consumers remove it from their store).
+    ctx.ev.emit('labels.edit', {
+        id: evt.labelId,
+        name: evt.name,
+        color: evt.color,
+        deleted: evt.deleted,
+        predefinedId: evt.predefinedId
+    }),
+    labelAssociation: (evt, { ctx }) => 
+    // Inbound sync only ever carries chat associations (the bridge event
+    // has a `chat_jid`); message-label associations are a separate path.
+    ctx.ev.emit('labels.association', {
+        association: { type: LabelAssociationType.Chat, chatId: evt.chatJid, labelId: evt.labelId },
+        type: evt.labeled ? 'add' : 'remove'
+    }),
     // ── Calls ──
-    incomingCall: (evt, { ctx }) => {
+    incomingCall: (evt, { ctx, callbacks }) => {
+        callbacks?.onIncomingCall?.(evt);
         const isGroup = isJidGroup(evt.from);
-        // Map the canonical action onto upstream Baileys' WACallUpdateType.
-        // `preAccept` is upstream's `ringing`. `timeout` has no bridge
-        // counterpart yet (upstream synthesizes it from a separate signal).
-        const status = evt.action.type === 'preAccept' ? 'ringing' : evt.action.type;
+        // Canonical call actions use the exact public Baileys status spelling;
+        // missed-call notifications are normalized to `timeout` by the adapter.
+        const status = evt.action.type;
         const callEvt = {
             chatId: evt.from,
-            from: evt.from,
+            from: evt.action.callCreator ?? evt.from,
+            ...(evt.action.callCreator ? { callCreator: evt.action.callCreator } : {}),
             id: evt.action.callId,
             date: new Date(evt.timestamp * 1000),
             status,
@@ -472,6 +541,7 @@ const DISPATCHERS = {
         ctx.ev.emit('call', [callEvt]);
     },
     // ── Raw passthrough ──
+    dirtyState: (evt, { callbacks }) => callbacks?.onDirtyState?.(evt),
     rawNode: (evt, { ctx }) => emitCBEvents(ctx, evt.node),
     notification: (evt, { ctx }) => ctx.logger.trace({ tag: evt.tag, attrs: evt.attrs }, 'bridge generic notification (no Baileys mapping)'),
     mexNotification: (evt, { ctx }) => {
@@ -485,8 +555,35 @@ const DISPATCHERS = {
                 ctx.logger.warn({ payload: evt.payload }, 'reachout-timelock push: payload missing expected fields');
             return;
         }
+        if (evt.opName === 'MessageCappingInfoNotification') {
+            const payload = extractMessageCappingPayload(evt.payload);
+            if (payload)
+                ctx.ev.emit('message-capping.update', payload);
+            else
+                ctx.logger.warn({ payload: evt.payload }, 'message-capping push: payload missing expected fields');
+            return;
+        }
         ctx.logger.trace({ opName: evt.opName, offline: evt.offline }, 'bridge mex notification with no Baileys mapping (drop)');
     },
+    serverAck: (evt, { ctx }) => {
+        // The public CB surface comes exclusively from Event::RawNode. Rebuilding
+        // an ACK from this semantic event would drop optional wire attributes and
+        // emit the same stanza twice whenever raw forwarding is enabled.
+        if (evt.class === 'message' && evt.error) {
+            ctx.logger.warn({ msgId: evt.id, from: evt.from, error: evt.error }, 'outgoing message was rejected by the server');
+            ctx.ev.emit('messages.update', [
+                {
+                    key: { remoteJid: evt.from, fromMe: true, id: evt.id },
+                    update: {
+                        status: WAMessageStatus.ERROR,
+                        messageStubParameters: [evt.error]
+                    }
+                }
+            ]);
+            return;
+        }
+        ctx.logger.debug({ msgId: evt.id, class: evt.class, from: evt.from, timestamp: evt.timestamp }, 'server acknowledged outgoing stanza');
+    },
     noop: (evt, { ctx }) => ctx.logger.trace({ bridgeType: evt.bridgeType, detail: evt.detail }, 'bridge event acknowledged (no Baileys equivalent)'),
     lidMappingUpdate: (evt, { ctx }) => {
         // Mirror upstream `messages-recv.ts:287`: one `lid-mapping.update`
@@ -496,6 +593,7 @@ const DISPATCHERS = {
         }
     },
     chatDelete: (evt, { ctx }) => ctx.ev.emit('chats.delete', [evt.jid]),
+    chatClear: (evt, { ctx }) => ctx.ev.emit('messages.delete', { jid: evt.jid, all: true }),
     messageDelete: (evt, { ctx }) => 
     // Upstream `chat-utils.ts:857` shape: `{ keys: WAMessageKey[] }` for
     // per-message delete (not the `{ jid, all: true }` chat-clear case
@@ -541,7 +639,7 @@ const DISPATCHERS = {
             ephemeralSettingTimestamp: evt.settingTimestamp
         }
     ]),
-    historySync: (evt, { ctx }) => {
+    historySync: (evt, { ctx, historySync }) => {
         // 1:1 with upstream `process-message.ts:371-376`. `isLatest` is true
         // when this is the first history sync the bot has seen since
         // pairing — upstream tracks it in `creds.processedHistoryMessages`,
@@ -550,13 +648,49 @@ const DISPATCHERS = {
         // gating "first hydrate" logic on `isLatest` see the same boolean.
         const HSType = WAProto.HistorySync.HistorySyncType;
         const isInitial = evt.syncType === HSType.INITIAL_BOOTSTRAP;
+        // The bridge may split one chunk into bounded batches (isFinalBatch=false
+        // on all but the last). `isLatest`/`progress` are chunk-level signals, so
+        // they only fire on the final batch — intermediate batches just append
+        // data. A non-batched bridge omits the flag → `!== false` keeps the old
+        // single-event behavior.
+        const isFinalBatch = evt.isFinalBatch !== false;
+        if (isFinalBatch && isInitial && !historySync.initialBootstrapComplete) {
+            historySync.initialBootstrapComplete = true;
+            ctx.ev.emit('messaging-history.status', {
+                syncType: HSType.INITIAL_BOOTSTRAP,
+                status: 'complete',
+                explicit: true
+            });
+        }
+        if (isFinalBatch && evt.syncType === HSType.RECENT && !historySync.recentSyncComplete) {
+            clearHistorySyncPausedTimeout(historySync);
+            if (evt.progress === 100) {
+                historySync.recentSyncComplete = true;
+                ctx.ev.emit('messaging-history.status', { syncType: HSType.RECENT, status: 'complete', explicit: true });
+            }
+            else {
+                historySync.pausedTimeout = setTimeout(() => {
+                    if (!historySync.recentSyncComplete) {
+                        historySync.recentSyncComplete = true;
+                        ctx.ev.emit('messaging-history.status', {
+                            syncType: HSType.RECENT,
+                            status: 'paused',
+                            explicit: false
+                        });
+                    }
+                    historySync.pausedTimeout = undefined;
+                }, HISTORY_SYNC_PAUSED_TIMEOUT_MS);
+                historySync.pausedTimeout.unref?.();
+            }
+        }
         const payload = {
             chats: evt.chats,
             contacts: evt.contacts,
             messages: evt.messages,
-            isLatest: evt.syncType === HSType.ON_DEMAND ? undefined : isInitial,
-            progress: evt.progress,
+            isLatest: evt.syncType === HSType.ON_DEMAND ? undefined : isInitial && isFinalBatch,
+            progress: isFinalBatch ? evt.progress : undefined,
             syncType: evt.syncType,
+            pastParticipants: evt.pastParticipants,
             chunkOrder: evt.chunkOrder,
             peerDataRequestSessionId: evt.peerDataRequestSessionId,
             lidPnMappings: evt.lidPnMappings.length > 0 ? evt.lidPnMappings : undefined
@@ -573,30 +707,121 @@ const DISPATCHERS = {
             ctx.ev.emit('contacts.upsert', evt.contacts);
     }
 };
+const dispatchCanonicalEvent = (canonical, dispatchCtx) => {
+    // Type-safe table lookup. The runtime cast through `DispatcherFn` is a
+    // no-op TS-wise (the table is exhaustively typed) — needed only because TS
+    // cannot follow the discriminator across an indexed mapped type.
+    const dispatcher = DISPATCHERS[canonical.type];
+    try {
+        dispatcher(canonical, dispatchCtx);
+    }
+    catch (err) {
+        // One bad event must not poison the rest of the pipeline.
+        dispatchCtx.ctx.logger.error({ err, type: canonical.type }, 'dispatcher threw — dropping event');
+    }
+};
+/** Aggregate adjacent ordinary messages while preserving every side-effecting
+ * event boundary. Both bridge object events and protobuf-wire batches enter
+ * through this single state machine. */
+const dispatchCanonicalBatch = (ctx, dispatchCtx, count, canonicalAt) => {
+    let pending;
+    for (let index = 0; index < count; index++) {
+        const canonical = canonicalAt(index);
+        if (!canonical)
+            continue;
+        // Only ordinary messages can share one messages.upsert emission.
+        // Flush before every other event or a message with secondary
+        // channels (reaction, revoke, edit, member-label) to preserve the
+        // exact observable order of those side effects.
+        if (canonical.type !== CANONICAL_MESSAGE_EVENT || hasMessageSideEffects(canonical)) {
+            if (pending) {
+                emitMessageUpsert(ctx, pending.messages, pending);
+                pending = undefined;
+            }
+            dispatchCanonicalEvent(canonical, dispatchCtx);
+            continue;
+        }
+        if (ctx.fullConfig.shouldIgnoreJid?.(canonical.chatJid))
+            continue;
+        try {
+            const metadata = messageUpsertMetadata(canonical);
+            const message = canonicalMessageToWAMessage(canonical);
+            if (pending && hasSameUpsertMetadata(pending, metadata)) {
+                pending.messages.push(message);
+            }
+            else {
+                if (pending)
+                    emitMessageUpsert(ctx, pending.messages, pending);
+                pending = { ...metadata, messages: [message] };
+            }
+        }
+        catch (err) {
+            ctx.logger.error({ err, type: CANONICAL_MESSAGE_EVENT }, 'dispatcher threw — dropping event');
+        }
+    }
+    if (pending)
+        emitMessageUpsert(ctx, pending.messages, pending);
+};
 /**
- * Create the event handler that translates canonical events into Baileys
- * events on `ctx.ev`. The handler does NO bridge-shape inspection — that's
- * the schema's job. Field-access here references canonical types
- * exclusively, so a downstream rename surfaces as a `tsc` failure.
+ * Create typed single and batch handlers for the bridge. The bridge only uses
+ * the batch capability when adjacent messages are already queued, while this
+ * layer owns all Baileys-specific translation and EventEmitter aggregation.
  */
-export const makeEventHandler = (ctx, callbacks) => {
-    const dispatchCtx = { ctx, callbacks };
-    return (event) => {
+export const makeEventHandlers = (ctx, callbacks) => {
+    const dispatchCtx = {
+        ctx,
+        callbacks,
+        historySync: { initialBootstrapComplete: false, recentSyncComplete: false }
+    };
+    const onEvent = (event) => {
         const canonical = adaptBridgeEvent(event, ctx.logger);
-        if (!canonical)
+        if (canonical)
+            dispatchCanonicalEvent(canonical, dispatchCtx);
+    };
+    const onMessageBatch = (batch) => {
+        if (batch.messageOffsets.length < MESSAGE_WIRE_OFFSET_SENTINEL_COUNT) {
+            ctx.logger.error('message wire batch is missing its leading offset');
             return;
-        // Type-safe table lookup. The runtime cast through `DispatcherFn`
-        // is a no-op TS-wise (the table is exhaustively typed) — needed
-        // only because TS can't follow the discriminator across the
-        // indexed-access into the mapped type.
-        const dispatcher = DISPATCHERS[canonical.type];
-        try {
-            dispatcher(canonical, dispatchCtx);
         }
-        catch (err) {
-            // One bad event must not poison the rest of the pipeline.
-            ctx.logger.error({ err, type: canonical.type }, 'dispatcher threw — dropping event');
+        const messageCount = batch.messageOffsets.length - MESSAGE_WIRE_OFFSET_SENTINEL_COUNT;
+        if (batch.infos.length !== messageCount) {
+            ctx.logger.error({ infoCount: batch.infos.length, messageCount }, 'message wire batch metadata count does not match its payload count');
+            return;
         }
+        // Decode through the runtime facade so each payload materializes as a
+        // hydrated runtime instance: `WebMessageInfo.fromObject` then keeps the
+        // message subtree via its instanceof short-circuit instead of walking
+        // and reallocating the whole tree — the dominant per-message allocation
+        // cost on the hot path. Lenient like the history-sync decoder: one
+        // malformed payload is skipped, not fatal to the batch.
+        const messages = new Array(messageCount);
+        const reader = new BinaryReader(batch.messageData);
+        for (let index = 0; index < messageCount; index++) {
+            try {
+                const start = batch.messageOffsets[index];
+                const end = batch.messageOffsets[index + 1];
+                reader.pos = start;
+                messages[index] = WAProto.Message.decode(reader, end - start);
+            }
+            catch (err) {
+                messages[index] = null;
+                ctx.logger.warn({ err, index }, 'skipping malformed wire message');
+            }
+        }
+        dispatchCanonicalBatch(ctx, dispatchCtx, messageCount, index => adaptBridgeMessageWire(messages[index], batch.infos[index], ctx.logger));
+    };
+    const onHistorySyncBatch = (batch) => {
+        const decoded = decodeHistorySyncWireBatch(batch, ctx.logger);
+        onEvent(decoded.event);
+        return decoded.skippedConversations;
+    };
+    return {
+        onEvent,
+        onMessageBatch,
+        onHistorySyncBatch,
+        historySyncConversationTypes: CONVERSATION_HISTORY_SYNC_TYPES
     };
 };
+/** Legacy single-event helper retained for direct consumers and tests. */
+export const makeEventHandler = (ctx, callbacks) => makeEventHandlers(ctx, callbacks).onEvent;
 //# sourceMappingURL=events.js.map