zapo-js 0.3.0 → 1.0.0

package/dist/message/kinds/newsletter.js

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processNewsletterLiveUpdates = processNewsletterLiveUpdates;
+exports.processIncomingNewsletterMessage = processIncomingNewsletterMessage;
+const context_info_1 = require("../context-info");
+const _proto_1 = require("../../proto.js");
+const constants_1 = require("../../protocol/constants");
+const message_1 = require("../../protocol/message");
+const helpers_1 = require("../../transport/node/helpers");
+const primitives_1 = require("../../util/primitives");
+function processNewsletterLiveUpdates(notification, options) {
+    const liveUpdates = (0, helpers_1.findNodeChild)(notification, 'live_updates');
+    if (!liveUpdates)
+        return;
+    const messagesNode = (0, helpers_1.findNodeChild)(liveUpdates, 'messages');
+    if (!messagesNode || !Array.isArray(messagesNode.content))
+        return;
+    const from = notification.attrs.from;
+    const outerId = notification.attrs.id;
+    const messagesT = messagesNode.attrs.t ?? notification.attrs.t;
+    for (const inner of messagesNode.content) {
+        if (inner.tag !== 'message')
+            continue;
+        if (!Array.isArray(inner.content) || inner.content.length === 0) {
+            continue;
+        }
+        const synth = {
+            tag: 'message',
+            attrs: {
+                ...(from ? { from } : {}),
+                ...(outerId ? { id: outerId } : {}),
+                ...(messagesT ? { t: messagesT } : {}),
+                ...inner.attrs
+            },
+            content: inner.content
+        };
+        processIncomingNewsletterMessage(synth, options);
+    }
+}
+function processIncomingNewsletterMessage(node, options) {
+    const messageType = node.attrs.type;
+    const editAttr = node.attrs.edit;
+    let emittedAggregate = false;
+    const reactionsEnvelope = (0, helpers_1.findNodeChild)(node, 'reactions');
+    if (reactionsEnvelope) {
+        const reactions = parseReactionAggregate(reactionsEnvelope);
+        if (reactions === null) {
+            emitUnhandled(node, options, 'newsletter.invalid_reactions');
+            return;
+        }
+        emitUpdate(node, options, {
+            kind: 'reaction',
+            isSender: node.attrs.is_sender === 'true',
+            revoked: false,
+            reactions
+        });
+        emittedAggregate = true;
+    }
+    else {
+        const reactionNode = (0, helpers_1.findNodeChild)(node, 'reaction');
+        if (reactionNode) {
+            const revoked = editAttr === message_1.WA_EDIT_ATTRS.SENDER_REVOKE || messageType === 'reaction_revoke';
+            emitUpdate(node, options, {
+                kind: 'reaction',
+                isSender: node.attrs.is_sender === 'true',
+                revoked,
+                reactions: [reactionNode.attrs.code ? { code: reactionNode.attrs.code } : {}]
+            });
+            emittedAggregate = true;
+        }
+    }
+    const votesNode = (0, helpers_1.findNodeChild)(node, 'votes');
+    if (votesNode) {
+        const votes = parsePollVotes(votesNode);
+        if (votes === null) {
+            emitUnhandled(node, options, 'newsletter.invalid_votes');
+            return;
+        }
+        emitUpdate(node, options, {
+            kind: 'poll_vote',
+            isSender: node.attrs.is_sender === 'true',
+            votes
+        });
+        emittedAggregate = true;
+    }
+    const counters = parseCounters(node);
+    if (counters) {
+        emitUpdate(node, options, counters);
+        emittedAggregate = true;
+    }
+    if (emittedAggregate)
+        return;
+    if (editAttr === message_1.WA_EDIT_ATTRS.ADMIN_REVOKE) {
+        emitUpdate(node, options, { kind: 'revoke' });
+        return;
+    }
+    if (editAttr === message_1.WA_EDIT_ATTRS.NEWSLETTER_EDIT) {
+        const decoded = decodePlaintext(node, options);
+        if (decoded === null) {
+            return;
+        }
+        emitUpdate(node, options, {
+            kind: 'edit',
+            plaintext: decoded.plaintext,
+            message: decoded.message
+        });
+        return;
+    }
+    const decoded = decodePlaintext(node, options);
+    if (decoded === null) {
+        return;
+    }
+    const chatJid = node.attrs.from;
+    const serverId = (0, primitives_1.parseOptionalInt)(node.attrs.server_id);
+    const expirationSeconds = (0, context_info_1.pickIncomingExpirationSeconds)(decoded.message);
+    options.emitIncomingMessage?.({
+        rawNode: node,
+        key: {
+            remoteJid: chatJid ?? '',
+            id: node.attrs.id ?? '',
+            fromMe: node.attrs.is_sender === 'true',
+            isGroup: false,
+            isBroadcast: false,
+            isNewsletter: true,
+            senderDevice: 0,
+            ...(serverId !== undefined ? { serverId } : {})
+        },
+        stanzaType: messageType,
+        offline: node.attrs.offline !== undefined,
+        timestampSeconds: (0, primitives_1.parseOptionalInt)(node.attrs.t),
+        ...(expirationSeconds !== undefined ? { expirationSeconds } : {}),
+        message: decoded.message
+    });
+}
+function emitUpdate(node, options, update) {
+    options.emitNewsletterMessageUpdate?.({
+        rawNode: node,
+        stanzaId: node.attrs.id,
+        chatJid: node.attrs.from,
+        stanzaType: node.attrs.type,
+        offline: node.attrs.offline !== undefined,
+        timestampSeconds: (0, primitives_1.parseOptionalInt)(node.attrs.t),
+        parentMessageServerId: (0, primitives_1.parseOptionalInt)(node.attrs.server_id),
+        update
+    });
+}
+function emitUnhandled(node, options, reason) {
+    options.emitUnhandledStanza?.({
+        rawNode: node,
+        stanzaId: node.attrs.id,
+        chatJid: node.attrs.from,
+        stanzaType: node.attrs.type,
+        offline: node.attrs.offline !== undefined,
+        reason
+    });
+}
+function decodePlaintext(node, options) {
+    const plaintextNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.PLAINTEXT);
+    if (!plaintextNode) {
+        emitUnhandled(node, options, 'newsletter.missing_plaintext');
+        return null;
+    }
+    try {
+        const plaintext = (0, helpers_1.decodeNodeContentBase64OrBytes)(plaintextNode.content, 'newsletter.plaintext');
+        const message = _proto_1.proto.Message.decode(plaintext);
+        return { plaintext, message };
+    }
+    catch (error) {
+        options.logger.warn('failed to decode newsletter plaintext message', {
+            id: node.attrs.id,
+            from: node.attrs.from,
+            type: node.attrs.type,
+            message: (0, primitives_1.toError)(error).message
+        });
+        emitUnhandled(node, options, 'newsletter.decode_failed');
+        return null;
+    }
+}
+function parsePollVotes(votesNode) {
+    if (!Array.isArray(votesNode.content)) {
+        return null;
+    }
+    const entries = [];
+    let withCount = 0;
+    let withoutCount = 0;
+    for (const child of votesNode.content) {
+        if (child.tag !== 'vote')
+            continue;
+        if (!(child.content instanceof Uint8Array) || child.content.byteLength !== 32) {
+            return null;
+        }
+        if (child.attrs.count === undefined) {
+            entries.push({ optionHash: child.content });
+            withoutCount += 1;
+            continue;
+        }
+        const count = (0, primitives_1.parseOptionalInt)(child.attrs.count);
+        if (count === undefined || count < 1) {
+            return null;
+        }
+        entries.push({ optionHash: child.content, count });
+        withCount += 1;
+    }
+    if (withCount > 0 && withoutCount > 0) {
+        return null;
+    }
+    if (entries.length === 0) {
+        return null;
+    }
+    return entries;
+}
+function parseCounters(node) {
+    const views = parseCounterAttr((0, helpers_1.findNodeChild)(node, 'views_count'));
+    const forwards = parseCounterAttr((0, helpers_1.findNodeChild)(node, 'forwards_count'));
+    const responses = parseCounterAttr((0, helpers_1.findNodeChild)(node, 'responses_count'));
+    if (views === undefined && forwards === undefined && responses === undefined)
+        return null;
+    return {
+        kind: 'counters',
+        ...(views !== undefined ? { views } : {}),
+        ...(forwards !== undefined ? { forwards } : {}),
+        ...(responses !== undefined ? { responses } : {})
+    };
+}
+function parseCounterAttr(node) {
+    if (!node)
+        return undefined;
+    return (0, primitives_1.parseOptionalInt)(node.attrs.count);
+}
+function parseReactionAggregate(envelope) {
+    if (!Array.isArray(envelope.content))
+        return null;
+    const out = [];
+    for (const child of envelope.content) {
+        if (child.tag !== 'reaction')
+            continue;
+        const code = child.attrs.code;
+        if (typeof code !== 'string' || code.length === 0)
+            return null;
+        const count = (0, primitives_1.parseOptionalInt)(child.attrs.count);
+        if (count === undefined || count < 1)
+            return null;
+        out.push({ code, count });
+    }
+    if (out.length === 0)
+        return null;
+    return out;
+}

package/dist/message/kinds/sticker-pack.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateStickerPackInput = validateStickerPackInput;
+exports.toStickerPackZipEntries = toStickerPackZipEntries;
+exports.toStickerPackProtoStickers = toStickerPackProtoStickers;
+function validateStickerPackInput(content) {
+    if (content.stickers.length === 0) {
+        throw new Error('sticker pack requires at least one sticker');
+    }
+    if (!content.trayIcon.fileName) {
+        throw new Error('sticker pack trayIcon requires a non-empty fileName');
+    }
+    if (content.stickers.some((sticker) => sticker.fileName === content.trayIcon.fileName)) {
+        throw new Error(`sticker pack trayIcon.fileName ${content.trayIcon.fileName} collides with a sticker fileName; the tray icon must be a separate ZIP entry`);
+    }
+}
+function toStickerPackZipEntries(content) {
+    return [
+        ...content.stickers.map((sticker) => ({
+            fileName: sticker.fileName,
+            source: sticker.media
+        })),
+        { fileName: content.trayIcon.fileName, source: content.trayIcon.media }
+    ];
+}
+function toStickerPackProtoStickers(content) {
+    return content.stickers.map((sticker) => ({
+        fileName: sticker.fileName,
+        emojis: [...sticker.emojis],
+        isAnimated: sticker.isAnimated,
+        isLottie: sticker.isLottie,
+        mimetype: sticker.mimetype ?? 'image/webp'
+    }));
+}

package/dist/message/{ack.js → primitives/ack.js}

@@ -4,7 +4,7 @@ exports.isAckOrReceiptNode = isAckOrReceiptNode;
 exports.isNegativeAckNode = isNegativeAckNode;
 exports.isRetryableNegativeAck = isRetryableNegativeAck;
 exports.describeAckNode = describeAckNode;
-const constants_1 = require("../protocol/constants");
+const constants_1 = require("../../protocol/constants");
 function isAckOrReceiptNode(node) {
     return node.tag === constants_1.WA_MESSAGE_TAGS.ACK || node.tag === constants_1.WA_MESSAGE_TAGS.RECEIPT;
 }
@@ -15,6 +15,9 @@ function isNegativeAckNode(node) {
     if (node.tag !== constants_1.WA_MESSAGE_TAGS.ACK) {
         return false;
     }
+    if (node.attrs.error) {
+        return true;
+    }
     const ackType = node.attrs.type;
     const ackClass = node.attrs.class;
     return (ackType === constants_1.WA_MESSAGE_TYPES.ACK_TYPE_ERROR || ackClass === constants_1.WA_MESSAGE_TYPES.ACK_CLASS_ERROR);
@@ -36,6 +39,7 @@ function describeAckNode(node) {
     const type = node.attrs.type;
     const ackClass = node.attrs.class;
     const code = node.attrs.code;
+    const error = node.attrs.error;
     if (id) {
         description += ` id=${id}`;
     }
@@ -48,5 +52,8 @@ function describeAckNode(node) {
     if (code) {
         description += ` code=${code}`;
     }
+    if (error) {
+        description += ` error=${error}`;
+    }
     return description;
 }

package/dist/message/{incoming.js → primitives/incoming.js}

@@ -1,14 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRecoveredIncomingEvent = buildRecoveredIncomingEvent;
 exports.handleIncomingMessageAck = handleIncomingMessageAck;
-const device_sent_1 = require("./device-sent");
-const padding_1 = require("./padding");
-const _proto_1 = require("../proto.js");
-const constants_1 = require("../protocol/constants");
-const jid_1 = require("../protocol/jid");
-const global_1 = require("../transport/node/builders/global");
-const helpers_1 = require("../transport/node/helpers");
-const primitives_1 = require("../util/primitives");
+const context_info_1 = require("../context-info");
+const device_sent_1 = require("../encode/device-sent");
+const padding_1 = require("../encode/padding");
+const newsletter_1 = require("../kinds/newsletter");
+const _proto_1 = require("../../proto.js");
+const constants_1 = require("../../protocol/constants");
+const jid_1 = require("../../protocol/jid");
+const global_1 = require("../../transport/node/builders/global");
+const helpers_1 = require("../../transport/node/helpers");
+const primitives_1 = require("../../util/primitives");
+// Addressing fields use conditional includes so they're absent (not own-undefined) when
+// the source attr isn't present — the `...keyIdentity` spread then only injects defined
+// keys into the event's `key`. `pushName` is destructured straight to the event top-level
+// and stays present-as-undefined there.
+function extractMessageIdentityAttrs(attrs) {
+    const rawRemoteJidAlt = attrs.sender_pn ?? attrs.sender_lid;
+    const rawParticipantAlt = attrs.participant_pn ?? attrs.participant_lid;
+    const rawRecipientAlt = attrs.peer_recipient_pn ?? attrs.peer_recipient_lid;
+    const rawRecipient = attrs.recipient;
+    const senderUsername = attrs.participant_username ?? attrs.username;
+    return {
+        ...(rawRemoteJidAlt ? { remoteJidAlt: (0, jid_1.toUserJid)(rawRemoteJidAlt) } : {}),
+        ...(rawParticipantAlt ? { participantAlt: (0, jid_1.toUserJid)(rawParticipantAlt) } : {}),
+        ...(senderUsername !== undefined ? { senderUsername } : {}),
+        ...(rawRecipient ? { recipientJid: (0, jid_1.toUserJid)(rawRecipient) } : {}),
+        ...(rawRecipientAlt ? { recipientAlt: (0, jid_1.toUserJid)(rawRecipientAlt) } : {}),
+        pushName: attrs.notify
+    };
+}
 function pickNextRetryCount(node) {
     const retryNode = (0, helpers_1.findNodeChild)(node, 'retry');
     const parsed = (0, primitives_1.parseOptionalInt)(retryNode?.attrs.count);
@@ -51,6 +73,47 @@ function buildIncomingEventRawNode(node) {
         content: children
     };
 }
+function buildRecoveredIncomingEvent(webMessageInfo) {
+    const key = webMessageInfo.key ?? {};
+    const chatJid = key.remoteJid ?? undefined;
+    const fromMe = key.fromMe === true;
+    const participant = key.participant ?? undefined;
+    const isGroup = chatJid ? (0, jid_1.isGroupJid)(chatJid) : false;
+    const isBroadcast = chatJid ? (0, jid_1.isBroadcastJid)(chatJid) : false;
+    const rawSender = fromMe ? undefined : isGroup || isBroadcast ? participant : chatJid;
+    const sender = rawSender ? (0, jid_1.parseJidFull)(rawSender) : null;
+    const senderDevice = sender?.address.device;
+    const timestampSeconds = webMessageInfo.messageTimestamp !== null && webMessageInfo.messageTimestamp !== undefined
+        ? (0, primitives_1.longToNumber)(webMessageInfo.messageTimestamp)
+        : undefined;
+    const stanzaId = key.id ?? undefined;
+    const message = webMessageInfo.message ?? undefined;
+    const expirationSeconds = (0, context_info_1.pickIncomingExpirationSeconds)(message);
+    const rawNode = {
+        tag: constants_1.WA_MESSAGE_TAGS.MESSAGE,
+        attrs: {
+            ...(stanzaId !== undefined ? { id: stanzaId } : {}),
+            ...(chatJid !== undefined ? { from: chatJid } : {}),
+            ...(participant !== undefined ? { participant } : {})
+        }
+    };
+    return {
+        rawNode,
+        key: {
+            remoteJid: chatJid ?? '',
+            id: stanzaId ?? '',
+            fromMe,
+            isGroup,
+            isBroadcast,
+            isNewsletter: false,
+            ...(participant !== undefined ? { participant } : {}),
+            senderDevice: senderDevice ?? 0
+        },
+        timestampSeconds,
+        ...(expirationSeconds !== undefined ? { expirationSeconds } : {}),
+        message
+    };
+}
 function pickSenderKeyDistributionPayload(message) {
     const direct = pickDirectSenderKeyDistributionPayload(message);
     if (direct) {
@@ -126,7 +189,7 @@ async function sendRetryReceiptForDecryptFailure(node, options, error, encType)
     });
     try {
         await options.sendNode(retryReceiptNode);
-        options.logger.debug('sent retry receipt for undecryptable incoming message', {
+        options.logger.trace('sent retry receipt for undecryptable incoming message', {
             id: stanzaId,
             to: from,
             participant: retryReceiptNode.attrs.participant,
@@ -145,7 +208,82 @@ async function sendRetryReceiptForDecryptFailure(node, options, error, encType)
         return false;
     }
 }
+function processMsmsgEncNode(node, encNode, senderJid, options) {
+    try {
+        const payload = (0, helpers_1.decodeNodeContentBase64OrBytes)(encNode.content, 'message.enc');
+        const decoded = _proto_1.proto.MessageSecretMessage.decode(payload);
+        if (!decoded.encIv || !decoded.encPayload) {
+            options.logger.warn('msmsg payload missing encIv/encPayload', {
+                id: node.attrs.id,
+                from: node.attrs.from
+            });
+            options.emitUnhandledStanza?.({
+                rawNode: buildIncomingEventRawNode(node),
+                stanzaId: node.attrs.id,
+                chatJid: node.attrs.from,
+                stanzaType: node.attrs.type,
+                offline: node.attrs.offline !== undefined,
+                reason: 'message.msmsg.missing_payload'
+            });
+            return { success: false, encType: 'msmsg' };
+        }
+        const message = {
+            secretEncryptedMessage: {
+                encIv: decoded.encIv,
+                encPayload: decoded.encPayload
+            }
+        };
+        const chatJid = node.attrs.from;
+        const sender = senderJid ? (0, jid_1.parseJidFull)(senderJid) : null;
+        const isGroup = chatJid ? (0, jid_1.isGroupJid)(chatJid) : false;
+        const isBroadcast = chatJid ? (0, jid_1.isBroadcastJid)(chatJid) : false;
+        const { pushName, ...keyIdentity } = extractMessageIdentityAttrs(node.attrs);
+        options.emitIncomingMessage?.({
+            rawNode: buildIncomingEventRawNode(node),
+            key: {
+                remoteJid: chatJid ?? '',
+                id: node.attrs.id ?? '',
+                fromMe: false,
+                isGroup,
+                isBroadcast,
+                isNewsletter: false,
+                ...keyIdentity,
+                ...((isGroup || isBroadcast) && sender?.userJid
+                    ? { participant: sender.userJid }
+                    : {}),
+                senderDevice: sender?.address.device ?? 0
+            },
+            stanzaType: node.attrs.type,
+            offline: node.attrs.offline !== undefined,
+            timestampSeconds: (0, primitives_1.parseOptionalInt)(node.attrs.t),
+            pushName,
+            message
+        });
+        return { success: true, encType: 'msmsg' };
+    }
+    catch (error) {
+        options.logger.warn('failed to decode msmsg payload', {
+            id: node.attrs.id,
+            from: node.attrs.from,
+            message: (0, primitives_1.toError)(error).message
+        });
+        options.emitUnhandledStanza?.({
+            rawNode: buildIncomingEventRawNode(node),
+            stanzaId: node.attrs.id,
+            chatJid: node.attrs.from,
+            stanzaType: node.attrs.type,
+            offline: node.attrs.offline !== undefined,
+            reason: 'message.msmsg.decode_failed'
+        });
+        return { success: false, encType: 'msmsg', error };
+    }
+}
 async function decryptAndProcessEncNode(node, encNode, encType, senderJid, options, decrypt) {
+    const log = options.logger.child({
+        id: node.attrs.id,
+        from: node.attrs.from,
+        participant: node.attrs.participant
+    });
     try {
         const senderAddress = (0, jid_1.parseSignalAddressFromJid)(senderJid);
         const decryptedPayload = await decrypt((0, helpers_1.decodeNodeContentBase64OrBytes)(encNode.content, 'message.enc'), senderAddress);
@@ -156,18 +294,12 @@ async function decryptAndProcessEncNode(node, encNode, encType, senderJid, optio
         if (senderKeyDistribution && options.senderKeyManager) {
             try {
                 await options.senderKeyManager.processSenderKeyDistributionPayload(senderKeyDistribution.groupId, senderAddress, senderKeyDistribution.payload);
-                options.logger.debug('processed incoming sender key distribution', {
-                    id: node.attrs.id,
-                    from: node.attrs.from,
-                    participant: node.attrs.participant,
+                log.trace('processed incoming sender key distribution', {
                     groupId: senderKeyDistribution.groupId
                 });
             }
             catch (error) {
-                options.logger.warn('failed to process incoming sender key distribution', {
-                    id: node.attrs.id,
-                    from: node.attrs.from,
-                    participant: node.attrs.participant,
+                log.warn('failed to process incoming sender key distribution', {
                     groupId: senderKeyDistribution.groupId,
                     message: (0, primitives_1.toError)(error).message
                 });
@@ -175,27 +307,36 @@ async function decryptAndProcessEncNode(node, encNode, encType, senderJid, optio
         }
         if (shouldEmitIncomingMessage(message)) {
             const chatJid = node.attrs.from;
+            const isGroup = chatJid ? (0, jid_1.isGroupJid)(chatJid) : false;
+            const isBroadcast = chatJid ? (0, jid_1.isBroadcastJid)(chatJid) : false;
+            const senderUserJid = `${senderAddress.user}@${senderAddress.server}`;
+            const { pushName, ...keyIdentity } = extractMessageIdentityAttrs(node.attrs);
+            const expirationSeconds = (0, context_info_1.pickIncomingExpirationSeconds)(message);
             options.emitIncomingMessage?.({
                 rawNode: buildIncomingEventRawNode(node),
-                stanzaId: node.attrs.id,
-                chatJid,
+                key: {
+                    remoteJid: chatJid ?? '',
+                    id: node.attrs.id ?? '',
+                    fromMe: false,
+                    isGroup,
+                    isBroadcast,
+                    isNewsletter: false,
+                    ...keyIdentity,
+                    senderDevice: senderAddress.device,
+                    ...(isGroup || isBroadcast ? { participant: senderUserJid } : {})
+                },
                 stanzaType: node.attrs.type,
+                offline: node.attrs.offline !== undefined,
                 timestampSeconds: (0, primitives_1.parseOptionalInt)(node.attrs.t),
-                senderJid,
-                encryptionType: encType,
-                isGroupChat: chatJid ? (0, jid_1.isGroupJid)(chatJid) : false,
-                isBroadcastChat: chatJid ? (0, jid_1.isBroadcastJid)(chatJid) : false,
-                plaintext: unpaddedPlaintext,
+                ...(expirationSeconds !== undefined ? { expirationSeconds } : {}),
+                pushName,
                 message
             });
         }
         return { success: true, encType };
     }
     catch (error) {
-        options.logger.warn('failed to decrypt incoming message', {
-            id: node.attrs.id,
-            from: node.attrs.from,
-            participant: node.attrs.participant,
+        log.warn('failed to decrypt incoming message', {
             encType,
             message: (0, primitives_1.toError)(error).message
         });
@@ -204,6 +345,7 @@ async function decryptAndProcessEncNode(node, encNode, encType, senderJid, optio
             stanzaId: node.attrs.id,
             chatJid: node.attrs.from,
             stanzaType: node.attrs.type,
+            offline: node.attrs.offline !== undefined,
             reason: `message.decrypt_failed.${encType}`
         });
         return { success: false, encType, error };
@@ -213,6 +355,10 @@ async function handleIncomingMessageAck(node, options) {
     if (node.tag !== constants_1.WA_MESSAGE_TAGS.MESSAGE) {
         return false;
     }
+    const from = node.attrs.from;
+    if (from && (0, jid_1.isNewsletterJid)(from)) {
+        return handleIncomingNewsletterMessage(node, options);
+    }
     let shouldSendStandardReceipt = true;
     const nodeContent = node.content;
     if (Array.isArray(nodeContent) && nodeContent.length > 0) {
@@ -238,6 +384,7 @@ async function handleIncomingMessageAck(node, options) {
                             stanzaId: node.attrs.id,
                             chatJid: node.attrs.from,
                             stanzaType: node.attrs.type,
+                            offline: node.attrs.offline !== undefined,
                             reason: 'message.skmsg.missing_group_context'
                         });
                         continue;
@@ -262,6 +409,14 @@ async function handleIncomingMessageAck(node, options) {
                     }));
                     break;
                 }
+                case 'msmsg': {
+                    // Bot streaming chunk: payload is a MessageSecretMessage proto
+                    // (encIv + encPayload), not a Signal envelope. The actual
+                    // decryption uses the parent prompt's messageSecret and is
+                    // performed downstream by `tryDecryptBotChunk`.
+                    result = processMsmsgEncNode(node, child, senderJid, options);
+                    break;
+                }
                 default:
                     continue;
             }
@@ -284,7 +439,6 @@ async function handleIncomingMessageAck(node, options) {
         }
     }
     const id = node.attrs.id;
-    const from = node.attrs.from;
     if (!id || !from) {
         options.logger.warn('incoming message missing required attrs for ack/receipt', {
             hasId: Boolean(id),
@@ -301,7 +455,7 @@ async function handleIncomingMessageAck(node, options) {
             to: from,
             from: options.getMeJid?.()
         });
-        options.logger.debug('sending inbound message ack', {
+        options.logger.trace('sending inbound message ack', {
             id,
             to: from,
             type: ackNode.attrs.type,
@@ -319,7 +473,7 @@ async function handleIncomingMessageAck(node, options) {
         id,
         to: from
     });
-    options.logger.debug('sending inbound message receipt', {
+    options.logger.trace('sending inbound message receipt', {
         id,
         to: from,
         type: receiptNode.attrs.type,
@@ -328,3 +482,34 @@ async function handleIncomingMessageAck(node, options) {
     await options.sendNode(receiptNode);
     return true;
 }
+async function handleIncomingNewsletterMessage(node, options) {
+    (0, newsletter_1.processIncomingNewsletterMessage)(node, {
+        logger: options.logger,
+        emitIncomingMessage: options.emitIncomingMessage,
+        emitNewsletterMessageUpdate: options.emitNewsletterMessageUpdate,
+        emitUnhandledStanza: options.emitUnhandledStanza
+    });
+    const id = node.attrs.id;
+    const from = node.attrs.from;
+    if (!id || !from) {
+        options.logger.warn('incoming newsletter message missing required attrs for ack', {
+            hasId: Boolean(id),
+            hasFrom: Boolean(from),
+            type: node.attrs.type
+        });
+        return true;
+    }
+    const ackNode = (0, global_1.buildAckNode)({
+        kind: 'message',
+        node,
+        id,
+        to: from
+    });
+    options.logger.trace('sending inbound newsletter message ack', {
+        id,
+        to: from,
+        type: ackNode.attrs.type
+    });
+    await options.sendNode(ackNode);
+    return true;
+}