zapo-js 0.2.0 → 1.0.0

package/dist/esm/message/{content.js → encode/content.js}

@@ -1,13 +1,133 @@
-import { proto } from '../proto.js';
-import { WA_EDIT_ATTRS, WA_ENC_MEDIA_TYPES, WA_EVENT_META_TYPES, WA_POLL_META_TYPES, WA_STANZA_MSG_TYPES } from '../protocol/constants.js';
+import { proto } from '../../proto.js';
+import { WA_EDIT_ATTRS, WA_ENC_MEDIA_TYPES, WA_EVENT_META_TYPES, WA_POLL_META_TYPES, WA_STANZA_MSG_TYPES } from '../../protocol/constants.js';
+/**
+ * Returns the content-type key of a message - `'conversation'`,
+ * `'imageMessage'`, `'extendedTextMessage'`, etc. - or `undefined` for an empty
+ * message. `senderKeyDistributionMessage` is skipped so group messages report
+ * their real payload type rather than the piggy-backed sender-key.
+ */
+export function getContentType(content) {
+    if (!content)
+        return undefined;
+    const key = Object.keys(content).find((k) => (k === 'conversation' || k.includes('Message')) && k !== 'senderKeyDistributionMessage');
+    return key;
+}
+/**
+ * Normalizes a reply/edit/reaction/revoke/pin target into a {@link WaMessageKey}:
+ * an explicit key is returned as-is, while a received `message` event
+ * ({@link WaMessageRef}, identified by its `rawNode`) yields its pre-computed
+ * `key`.
+ */
+export function resolveMessageTarget(ref) {
+    if (!('rawNode' in ref)) {
+        return ref;
+    }
+    const key = ref.key;
+    if (key === undefined || typeof key.id !== 'string') {
+        throw new Error('message event used as a target is missing key.id');
+    }
+    return key;
+}
 export function isSendMediaMessage(content) {
+    if (!content || typeof content !== 'object' || !('type' in content)) {
+        return false;
+    }
+    if ('media' in content) {
+        return true;
+    }
+    return content.type === 'sticker-pack' && 'stickers' in content;
+}
+export function isSendTextMessage(content) {
+    return (!!content &&
+        typeof content === 'object' &&
+        'type' in content &&
+        content.type === 'text' &&
+        'text' in content);
+}
+export function isSendReactionMessage(content) {
+    return (!!content &&
+        typeof content === 'object' &&
+        'type' in content &&
+        content.type === 'reaction' &&
+        'target' in content);
+}
+export function isSendRevokeMessage(content) {
+    return (!!content &&
+        typeof content === 'object' &&
+        'type' in content &&
+        content.type === 'revoke' &&
+        'target' in content);
+}
+export function isSendPinMessage(content) {
+    if (!content || typeof content !== 'object' || !('type' in content) || !('target' in content)) {
+        return false;
+    }
+    const type = content.type;
+    return type === 'pin' || type === 'unpin';
+}
+export function isSendKeepMessage(content) {
+    if (!content || typeof content !== 'object' || !('type' in content) || !('target' in content)) {
+        return false;
+    }
+    const type = content.type;
+    return type === 'keep' || type === 'unkeep';
+}
+export function isSendPollMessage(content) {
+    return (!!content &&
+        typeof content === 'object' &&
+        'type' in content &&
+        content.type === 'poll' &&
+        'name' in content &&
+        'options' in content);
+}
+export function isSendPollVoteMessage(content) {
+    return (!!content &&
+        typeof content === 'object' &&
+        'type' in content &&
+        content.type === 'poll-vote' &&
+        'poll' in content &&
+        'selectedOptionNames' in content);
+}
+export function isSendEventMessage(content) {
     return (!!content &&
         typeof content === 'object' &&
         'type' in content &&
-        'media' in content &&
-        'mimetype' in content);
+        content.type === 'event' &&
+        'name' in content &&
+        'startTime' in content);
 }
-function unwrapMessage(message) {
+export function isSendEventResponseMessage(content) {
+    return (!!content &&
+        typeof content === 'object' &&
+        'type' in content &&
+        content.type === 'event-response' &&
+        'event' in content &&
+        'response' in content);
+}
+export function isSendAddonCryptoMessage(content) {
+    return isSendPollVoteMessage(content) || isSendEventResponseMessage(content);
+}
+const VIEW_ONCE_MEDIA_FIELDS = [
+    'imageMessage',
+    'videoMessage',
+    'ptvMessage',
+    'audioMessage'
+];
+export function supportsViewOnce(message) {
+    return VIEW_ONCE_MEDIA_FIELDS.some((field) => message[field]);
+}
+export function wrapAsViewOnce(message) {
+    if (message.viewOnceMessage || message.viewOnceMessageV2) {
+        return message;
+    }
+    for (const field of VIEW_ONCE_MEDIA_FIELDS) {
+        const media = message[field];
+        if (media)
+            return { ...message, [field]: { ...media, viewOnce: true } };
+    }
+    return message;
+}
+export function unwrapMessage(message) {
     let msg = message;
     for (;;) {
         const inner = msg.ephemeralMessage?.message ??
@@ -70,12 +190,55 @@ export function resolveMessageTypeAttr(message) {
     return WA_STANZA_MSG_TYPES.MEDIA;
 }
 const REVOKED_REACTION_TEXT = '';
-export function resolveEditAttr(message, subtype) {
+export function resolveDecryptFailAttr(message) {
+    const msg = unwrapMessage(message);
+    const secretEncType = msg.secretEncryptedMessage?.secretEncType;
+    if (msg.reactionMessage ||
+        msg.encReactionMessage ||
+        (msg.pollUpdateMessage &&
+            msg.pollUpdateMessage.vote !== null &&
+            msg.pollUpdateMessage.vote !== undefined) ||
+        msg.keepInChatMessage ||
+        msg.editedMessage ||
+        msg.pinInChatMessage ||
+        msg.encCommentMessage ||
+        msg.encEventResponseMessage ||
+        secretEncType === proto.Message.SecretEncryptedMessage.SecretEncType.EVENT_EDIT ||
+        secretEncType === proto.Message.SecretEncryptedMessage.SecretEncType.POLL_EDIT ||
+        secretEncType === proto.Message.SecretEncryptedMessage.SecretEncType.POLL_ADD_OPTION ||
+        msg.messageHistoryNotice) {
+        return 'hide';
+    }
+    if (msg.protocolMessage) {
+        const protocolType = msg.protocolMessage.type;
+        if (protocolType === proto.Message.ProtocolMessage.Type.EPHEMERAL_SYNC_RESPONSE ||
+            protocolType === proto.Message.ProtocolMessage.Type.REQUEST_WELCOME_MESSAGE ||
+            msg.protocolMessage.editedMessage) {
+            return 'hide';
+        }
+    }
+    return undefined;
+}
+export function needsSecretPersistence(message) {
+    const msg = unwrapMessage(message);
+    return !!(msg.pollCreationMessage ||
+        msg.pollCreationMessageV2 ||
+        msg.pollCreationMessageV3 ||
+        msg.pollCreationMessageV4 ||
+        msg.pollCreationMessageV5 ||
+        msg.pollCreationMessageV6 ||
+        msg.eventMessage ||
+        // botMetadata sits on the top-level MessageContextInfo even when the
+        // prompt body is wrapped (e.g. in `botInvokeMessage`); check both.
+        message.messageContextInfo?.botMetadata ||
+        msg.messageContextInfo?.botMetadata);
+}
+export function resolveEditAttr(message) {
     const msg = unwrapMessage(message);
     if (msg.protocolMessage) {
         const protocolType = msg.protocolMessage.type;
         if (protocolType === proto.Message.ProtocolMessage.Type.REVOKE) {
-            return subtype === 'admin_revoke'
+            return msg.protocolMessage.key?.fromMe === false
                 ? WA_EDIT_ATTRS.ADMIN_REVOKE
                 : WA_EDIT_ATTRS.SENDER_REVOKE;
         }
@@ -118,6 +281,8 @@ export function resolveEncMediaType(message) {
         return WA_ENC_MEDIA_TYPES.IMAGE;
     if (msg.stickerMessage)
         return WA_ENC_MEDIA_TYPES.STICKER;
+    if (msg.stickerPackMessage)
+        return WA_ENC_MEDIA_TYPES.STICKER_PACK;
     if (msg.locationMessage) {
         return msg.locationMessage.isLive
             ? WA_ENC_MEDIA_TYPES.LIVE_LOCATION
@@ -160,6 +325,14 @@ export function resolveEncMediaType(message) {
     }
     return null;
 }
+export function resolveButtonAddonKind(message) {
+    const msg = unwrapMessage(message);
+    if (msg.listMessage)
+        return 'list';
+    if (msg.buttonsMessage || msg.interactiveMessage?.nativeFlowMessage)
+        return 'interactive';
+    return null;
+}
 export function resolveMetaAttrs(message) {
     const msg = unwrapMessage(message);
     let polltype;
@@ -189,7 +362,9 @@ export function resolveMetaAttrs(message) {
         proto.Message.SecretEncryptedMessage.SecretEncType.EVENT_EDIT) {
         eventType = WA_EVENT_META_TYPES.EDIT;
     }
-    if (message.viewOnceMessage || message.viewOnceMessageV2) {
+    if (message.viewOnceMessage ||
+        message.viewOnceMessageV2 ||
+        VIEW_ONCE_MEDIA_FIELDS.some((field) => msg[field]?.viewOnce)) {
         viewOnce = 'true';
     }
     if (!polltype && !eventType && !viewOnce) {

package/dist/esm/message/encode/media-payload.js

@@ -0,0 +1,42 @@
+import { unwrapMessage } from '../encode/content.js';
+import { longToNumber } from '../../util/primitives.js';
+function buildPayload(mediaType, fields) {
+    if (!fields.directPath || !fields.mediaKey) {
+        return null;
+    }
+    const mediaKey = fields.mediaKey instanceof Uint8Array ? fields.mediaKey : null;
+    if (!mediaKey) {
+        return null;
+    }
+    const fileSha256 = fields.fileSha256 instanceof Uint8Array ? fields.fileSha256 : undefined;
+    const fileEncSha256 = fields.fileEncSha256 instanceof Uint8Array ? fields.fileEncSha256 : undefined;
+    return {
+        mediaType,
+        directPath: fields.directPath,
+        mediaKey,
+        fileSha256,
+        fileEncSha256,
+        mimetype: fields.mimetype ?? undefined,
+        fileLength: fields.fileLength ? longToNumber(fields.fileLength) : undefined
+    };
+}
+export function resolveMediaPayload(message) {
+    if (!message)
+        return null;
+    const msg = unwrapMessage(message);
+    if (msg.imageMessage)
+        return buildPayload('image', msg.imageMessage);
+    if (msg.videoMessage) {
+        return buildPayload(msg.videoMessage.gifPlayback ? 'gif' : 'video', msg.videoMessage);
+    }
+    if (msg.audioMessage) {
+        return buildPayload(msg.audioMessage.ptt ? 'ptt' : 'audio', msg.audioMessage);
+    }
+    if (msg.documentMessage)
+        return buildPayload('document', msg.documentMessage);
+    if (msg.stickerMessage)
+        return buildPayload('sticker', msg.stickerMessage);
+    if (msg.ptvMessage)
+        return buildPayload('ptv', msg.ptvMessage);
+    return null;
+}

package/dist/esm/message/{padding.js → encode/padding.js}

@@ -1,8 +1,14 @@
-import { randomBytesAsync } from '../crypto/index.js';
+import { randomBytesAsync } from '../../crypto/index.js';
 const RANDOM_PAD_MAX_16_MASK = 0x0f;
+const PAD_SEED_BATCH_SIZE = 1024;
+let padSeedBuffer = null;
+let padSeedCursor = 0;
 export async function writeRandomPadMax16(message) {
-    const padSeed = await randomBytesAsync(1);
-    const padLength = (padSeed[0] & RANDOM_PAD_MAX_16_MASK) + 1;
+    if (!padSeedBuffer || padSeedCursor >= padSeedBuffer.length) {
+        padSeedBuffer = await randomBytesAsync(PAD_SEED_BATCH_SIZE);
+        padSeedCursor = 0;
+    }
+    const padLength = (padSeedBuffer[padSeedCursor++] & RANDOM_PAD_MAX_16_MASK) + 1;
     const out = new Uint8Array(message.length + padLength);
     out.set(message, 0);
     out.fill(padLength, message.length);

package/dist/esm/message/index.js

@@ -1,4 +1,4 @@
 export { WaMessageClient } from './WaMessageClient.js';
-export * from './addon-crypto.js';
+export * from './crypto/addon-crypto.js';
 export * from './types.js';
-export * from './use-case-secret.js';
+export * from './crypto/use-case-secret.js';

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

@@ -0,0 +1,111 @@
+import { aesGcmDecrypt, hkdf } from '../../crypto/index.js';
+import { buildAddonAdditionalData } from '../crypto/addon-crypto.js';
+import { assertMessageSecret } from '../crypto/use-case-secret.js';
+import { proto } from '../../proto.js';
+import { WA_BOT_HKDF_INFO, WA_BOT_MSG_SECRET_BYTES } from '../../protocol/bot.js';
+import { isBotJid } from '../../protocol/jid.js';
+import { TEXT_ENCODER, toBytesView } from '../../util/bytes.js';
+export function genBotMsgSecret(messageSecret) {
+    const ikm = assertMessageSecret(messageSecret, 'bot parent message secret');
+    return hkdf(ikm, null, WA_BOT_HKDF_INFO, WA_BOT_MSG_SECRET_BYTES);
+}
+export function deriveBotChunkKey(input) {
+    if (!input.saltId)
+        throw new Error('bot chunk salt id must be a non-empty string');
+    if (!input.targetSenderJid)
+        throw new Error('bot chunk target sender jid must be a non-empty string');
+    if (!input.authorJid)
+        throw new Error('bot chunk author jid must be a non-empty string');
+    const info = TEXT_ENCODER.encode(input.saltId + input.targetSenderJid + input.authorJid);
+    return hkdf(toBytesView(input.botMsgSecret), null, info, WA_BOT_MSG_SECRET_BYTES);
+}
+export function decryptBotChunk(input) {
+    const botMsgSecret = genBotMsgSecret(input.parentMessageSecret);
+    const key = deriveBotChunkKey({
+        botMsgSecret,
+        saltId: input.saltId,
+        targetSenderJid: input.targetSenderJid,
+        authorJid: input.authorJid
+    });
+    return aesGcmDecrypt(key, toBytesView(input.encIv), toBytesView(input.encPayload), buildAddonAdditionalData(input.saltId, input.authorJid));
+}
+export function attachBotMetadata(message, input) {
+    if (!input.personaId && !input.invokerJid && !input.capabilities) {
+        return message;
+    }
+    const botMetadata = {};
+    if (input.personaId)
+        botMetadata.personaId = input.personaId;
+    if (input.invokerJid)
+        botMetadata.invokerJid = input.invokerJid;
+    if (input.capabilities && input.capabilities.length > 0) {
+        botMetadata.capabilityMetadata = {
+            capabilities: input.capabilities
+        };
+    }
+    return {
+        ...message,
+        messageContextInfo: {
+            ...(message.messageContextInfo ?? {}),
+            botMetadata
+        }
+    };
+}
+export function attachBotThread(message, input) {
+    const ctx = message.messageContextInfo ?? {};
+    const existingBotMetadata = ctx.botMetadata ?? {};
+    const threadType = input.threadType ?? proto.AIThreadInfo.AIThreadClientInfo.AIThreadType.DEFAULT;
+    return {
+        ...message,
+        messageContextInfo: {
+            ...ctx,
+            threadId: [
+                {
+                    threadType: proto.ThreadID.ThreadType.AI_THREAD,
+                    threadKey: {
+                        remoteJid: input.remoteJid,
+                        fromMe: true,
+                        id: input.aiThreadId
+                    }
+                }
+            ],
+            botMetadata: {
+                ...existingBotMetadata,
+                botThreadInfo: { clientInfo: { type: threadType } }
+            }
+        }
+    };
+}
+export function extractInvokedBotJid(message) {
+    const inner = message.botInvokeMessage?.message;
+    if (!inner)
+        return null;
+    // Mention metadata lives on whichever submessage carries the body – text
+    // prompts on extendedTextMessage, media prompts on the caption-bearing body.
+    const mentioned = inner.extendedTextMessage?.contextInfo?.mentionedJid ??
+        inner.imageMessage?.contextInfo?.mentionedJid ??
+        inner.videoMessage?.contextInfo?.mentionedJid ??
+        inner.documentMessage?.contextInfo?.mentionedJid;
+    if (!mentioned)
+        return null;
+    for (const jid of mentioned) {
+        if (isBotJid(jid))
+            return jid;
+    }
+    return null;
+}
+// Mirrors `WAWebE2EProtoGenerator.updateBotInvokeMsgProtoCopyForCapi`, minus
+// the pushname rewrite (raw mentions are accepted by Meta AI).
+export function buildBotInvokeProtoCopy(message, botMessageSecret) {
+    const { messageContextInfo, ...rest } = message;
+    if (!messageContextInfo && !botMessageSecret)
+        return rest;
+    const nextContextInfo = {
+        ...(messageContextInfo ?? {}),
+        messageSecret: undefined
+    };
+    if (botMessageSecret) {
+        nextContextInfo.botMessageSecret = botMessageSecret;
+    }
+    return { ...rest, messageContextInfo: nextContextInfo };
+}

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'
+    }));
+}