zapo-js 0.3.0 → 1.0.0

package/dist/esm/message/kinds/newsletter.js

@@ -0,0 +1,244 @@
+import { pickIncomingExpirationSeconds } from '../context-info.js';
+import { proto } from '../../proto.js';
+import { WA_NODE_TAGS } from '../../protocol/constants.js';
+import { WA_EDIT_ATTRS } from '../../protocol/message.js';
+import { decodeNodeContentBase64OrBytes, findNodeChild } from '../../transport/node/helpers.js';
+import { parseOptionalInt, toError } from '../../util/primitives.js';
+export function processNewsletterLiveUpdates(notification, options) {
+    const liveUpdates = findNodeChild(notification, 'live_updates');
+    if (!liveUpdates)
+        return;
+    const messagesNode = 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);
+    }
+}
+export function processIncomingNewsletterMessage(node, options) {
+    const messageType = node.attrs.type;
+    const editAttr = node.attrs.edit;
+    let emittedAggregate = false;
+    const reactionsEnvelope = 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 = findNodeChild(node, 'reaction');
+        if (reactionNode) {
+            const revoked = editAttr === 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 = 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 === WA_EDIT_ATTRS.ADMIN_REVOKE) {
+        emitUpdate(node, options, { kind: 'revoke' });
+        return;
+    }
+    if (editAttr === 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 = parseOptionalInt(node.attrs.server_id);
+    const expirationSeconds = 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: 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: parseOptionalInt(node.attrs.t),
+        parentMessageServerId: 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 = findNodeChild(node, WA_NODE_TAGS.PLAINTEXT);
+    if (!plaintextNode) {
+        emitUnhandled(node, options, 'newsletter.missing_plaintext');
+        return null;
+    }
+    try {
+        const plaintext = decodeNodeContentBase64OrBytes(plaintextNode.content, 'newsletter.plaintext');
+        const message = 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: 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 = 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(findNodeChild(node, 'views_count'));
+    const forwards = parseCounterAttr(findNodeChild(node, 'forwards_count'));
+    const responses = parseCounterAttr(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 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 = 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/esm/message/kinds/sticker-pack.js

@@ -0,0 +1,29 @@
+export 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`);
+    }
+}
+export function toStickerPackZipEntries(content) {
+    return [
+        ...content.stickers.map((sticker) => ({
+            fileName: sticker.fileName,
+            source: sticker.media
+        })),
+        { fileName: content.trayIcon.fileName, source: content.trayIcon.media }
+    ];
+}
+export 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/esm/message/{ack.js → primitives/ack.js}

@@ -1,4 +1,4 @@
-import { WA_MESSAGE_TAGS, WA_MESSAGE_TYPES, WA_RETRYABLE_ACK_CODES } from '../protocol/constants.js';
+import { WA_MESSAGE_TAGS, WA_MESSAGE_TYPES, WA_RETRYABLE_ACK_CODES } from '../../protocol/constants.js';
 export function isAckOrReceiptNode(node) {
     return node.tag === WA_MESSAGE_TAGS.ACK || node.tag === WA_MESSAGE_TAGS.RECEIPT;
 }
@@ -9,6 +9,9 @@ export function isNegativeAckNode(node) {
     if (node.tag !== WA_MESSAGE_TAGS.ACK) {
         return false;
     }
+    if (node.attrs.error) {
+        return true;
+    }
     const ackType = node.attrs.type;
     const ackClass = node.attrs.class;
     return (ackType === WA_MESSAGE_TYPES.ACK_TYPE_ERROR || ackClass === WA_MESSAGE_TYPES.ACK_CLASS_ERROR);
@@ -30,6 +33,7 @@ export 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}`;
     }
@@ -42,5 +46,8 @@ export function describeAckNode(node) {
     if (code) {
         description += ` code=${code}`;
     }
+    if (error) {
+        description += ` error=${error}`;
+    }
     return description;
 }

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

@@ -1,11 +1,32 @@
-import { unwrapDeviceSentMessage } from './device-sent.js';
-import { unpadPkcs7 } from './padding.js';
-import { proto } from '../proto.js';
-import { WA_MESSAGE_TAGS, WA_MESSAGE_TYPES } from '../protocol/constants.js';
-import { isBroadcastJid, isGroupJid, parseSignalAddressFromJid } from '../protocol/jid.js';
-import { buildAckNode, buildReceiptNode } from '../transport/node/builders/global.js';
-import { decodeNodeContentBase64OrBytes, findNodeChild } from '../transport/node/helpers.js';
-import { parseOptionalInt, toError } from '../util/primitives.js';
+import { pickIncomingExpirationSeconds } from '../context-info.js';
+import { unwrapDeviceSentMessage } from '../encode/device-sent.js';
+import { unpadPkcs7 } from '../encode/padding.js';
+import { processIncomingNewsletterMessage } from '../kinds/newsletter.js';
+import { proto } from '../../proto.js';
+import { WA_MESSAGE_TAGS, WA_MESSAGE_TYPES } from '../../protocol/constants.js';
+import { isBroadcastJid, isGroupJid, isNewsletterJid, parseJidFull, parseSignalAddressFromJid, toUserJid } from '../../protocol/jid.js';
+import { buildAckNode, buildReceiptNode } from '../../transport/node/builders/global.js';
+import { decodeNodeContentBase64OrBytes, findNodeChild } from '../../transport/node/helpers.js';
+import { longToNumber, parseOptionalInt, toError } from '../../util/primitives.js';
+// 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: toUserJid(rawRemoteJidAlt) } : {}),
+        ...(rawParticipantAlt ? { participantAlt: toUserJid(rawParticipantAlt) } : {}),
+        ...(senderUsername !== undefined ? { senderUsername } : {}),
+        ...(rawRecipient ? { recipientJid: toUserJid(rawRecipient) } : {}),
+        ...(rawRecipientAlt ? { recipientAlt: toUserJid(rawRecipientAlt) } : {}),
+        pushName: attrs.notify
+    };
+}
 function pickNextRetryCount(node) {
     const retryNode = findNodeChild(node, 'retry');
     const parsed = parseOptionalInt(retryNode?.attrs.count);
@@ -48,6 +69,47 @@ function buildIncomingEventRawNode(node) {
         content: children
     };
 }
+export 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 ? isGroupJid(chatJid) : false;
+    const isBroadcast = chatJid ? isBroadcastJid(chatJid) : false;
+    const rawSender = fromMe ? undefined : isGroup || isBroadcast ? participant : chatJid;
+    const sender = rawSender ? parseJidFull(rawSender) : null;
+    const senderDevice = sender?.address.device;
+    const timestampSeconds = webMessageInfo.messageTimestamp !== null && webMessageInfo.messageTimestamp !== undefined
+        ? longToNumber(webMessageInfo.messageTimestamp)
+        : undefined;
+    const stanzaId = key.id ?? undefined;
+    const message = webMessageInfo.message ?? undefined;
+    const expirationSeconds = pickIncomingExpirationSeconds(message);
+    const rawNode = {
+        tag: 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) {
@@ -123,7 +185,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,
@@ -142,7 +204,82 @@ async function sendRetryReceiptForDecryptFailure(node, options, error, encType)
         return false;
     }
 }
+function processMsmsgEncNode(node, encNode, senderJid, options) {
+    try {
+        const payload = decodeNodeContentBase64OrBytes(encNode.content, 'message.enc');
+        const decoded = 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 ? parseJidFull(senderJid) : null;
+        const isGroup = chatJid ? isGroupJid(chatJid) : false;
+        const isBroadcast = chatJid ? 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: 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: 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 = parseSignalAddressFromJid(senderJid);
         const decryptedPayload = await decrypt(decodeNodeContentBase64OrBytes(encNode.content, 'message.enc'), senderAddress);
@@ -153,18 +290,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: toError(error).message
                 });
@@ -172,27 +303,36 @@ async function decryptAndProcessEncNode(node, encNode, encType, senderJid, optio
         }
         if (shouldEmitIncomingMessage(message)) {
             const chatJid = node.attrs.from;
+            const isGroup = chatJid ? isGroupJid(chatJid) : false;
+            const isBroadcast = chatJid ? isBroadcastJid(chatJid) : false;
+            const senderUserJid = `${senderAddress.user}@${senderAddress.server}`;
+            const { pushName, ...keyIdentity } = extractMessageIdentityAttrs(node.attrs);
+            const expirationSeconds = 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: parseOptionalInt(node.attrs.t),
-                senderJid,
-                encryptionType: encType,
-                isGroupChat: chatJid ? isGroupJid(chatJid) : false,
-                isBroadcastChat: chatJid ? 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: toError(error).message
         });
@@ -201,6 +341,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 };
@@ -210,6 +351,10 @@ export async function handleIncomingMessageAck(node, options) {
     if (node.tag !== WA_MESSAGE_TAGS.MESSAGE) {
         return false;
     }
+    const from = node.attrs.from;
+    if (from && isNewsletterJid(from)) {
+        return handleIncomingNewsletterMessage(node, options);
+    }
     let shouldSendStandardReceipt = true;
     const nodeContent = node.content;
     if (Array.isArray(nodeContent) && nodeContent.length > 0) {
@@ -235,6 +380,7 @@ export 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;
@@ -259,6 +405,14 @@ export 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;
             }
@@ -281,7 +435,6 @@ export 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),
@@ -298,7 +451,7 @@ export 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,
@@ -316,7 +469,7 @@ export 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,
@@ -325,3 +478,34 @@ export async function handleIncomingMessageAck(node, options) {
     await options.sendNode(receiptNode);
     return true;
 }
+async function handleIncomingNewsletterMessage(node, options) {
+    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 = 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;
+}