zapo-js 0.2.0 → 1.0.0

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/primitives/incoming.js

@@ -0,0 +1,511 @@
+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);
+    if (!parsed || parsed < 1) {
+        return 1;
+    }
+    return parsed + 1;
+}
+function buildIncomingEventRawNode(node) {
+    const nodeContent = node.content;
+    if (!Array.isArray(nodeContent) || nodeContent.length === 0) {
+        return node;
+    }
+    let children = null;
+    for (let index = 0; index < nodeContent.length; index += 1) {
+        const child = nodeContent[index];
+        const shouldRedact = child.tag === WA_MESSAGE_TAGS.ENC &&
+            (typeof child.content === 'string' || child.content instanceof Uint8Array);
+        if (!shouldRedact) {
+            if (children) {
+                children.push(child);
+            }
+            continue;
+        }
+        if (!children) {
+            children = nodeContent.slice(0, index);
+        }
+        children.push({
+            tag: child.tag,
+            attrs: child.attrs
+        });
+    }
+    if (!children) {
+        return node;
+    }
+    // Strip heavy encrypted payload from event snapshots to reduce retention.
+    return {
+        tag: node.tag,
+        attrs: node.attrs,
+        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) {
+        return direct;
+    }
+    const nestedMessage = message.deviceSentMessage?.message ?? undefined;
+    if (nestedMessage) {
+        return pickSenderKeyDistributionPayload(nestedMessage);
+    }
+    return null;
+}
+function pickDirectSenderKeyDistributionPayload(message) {
+    const senderKeyDistribution = message.senderKeyDistributionMessage;
+    if (senderKeyDistribution?.groupId &&
+        senderKeyDistribution.axolotlSenderKeyDistributionMessage) {
+        return {
+            groupId: senderKeyDistribution.groupId,
+            payload: senderKeyDistribution.axolotlSenderKeyDistributionMessage
+        };
+    }
+    const fastRatchetSenderKeyDistribution = message.fastRatchetKeySenderKeyDistributionMessage;
+    if (fastRatchetSenderKeyDistribution?.groupId &&
+        fastRatchetSenderKeyDistribution.axolotlSenderKeyDistributionMessage) {
+        return {
+            groupId: fastRatchetSenderKeyDistribution.groupId,
+            payload: fastRatchetSenderKeyDistribution.axolotlSenderKeyDistributionMessage
+        };
+    }
+    return null;
+}
+function shouldEmitIncomingMessage(message) {
+    if (!pickDirectSenderKeyDistributionPayload(message)) {
+        return true;
+    }
+    const messageRecord = message;
+    for (const field in messageRecord) {
+        if (field === 'senderKeyDistributionMessage' ||
+            field === 'fastRatchetKeySenderKeyDistributionMessage' ||
+            field === '$$unknownFieldCount') {
+            continue;
+        }
+        const value = messageRecord[field];
+        if (value === null || value === undefined) {
+            continue;
+        }
+        return true;
+    }
+    return false;
+}
+async function sendRetryReceiptForDecryptFailure(node, options, error, encType) {
+    const stanzaId = node.attrs.id;
+    const from = node.attrs.from;
+    if (!stanzaId || !from) {
+        return false;
+    }
+    const retryContext = {
+        messageNode: node,
+        stanzaId,
+        from,
+        participant: node.attrs.participant,
+        recipient: node.attrs.recipient,
+        t: node.attrs.t
+    };
+    if (options.onDecryptFailure) {
+        return options.onDecryptFailure(retryContext, error);
+    }
+    const retryReceiptNode = buildReceiptNode({
+        kind: 'retry',
+        node,
+        id: stanzaId,
+        to: from,
+        retryCount: pickNextRetryCount(node)
+    });
+    try {
+        await options.sendNode(retryReceiptNode);
+        options.logger.trace('sent retry receipt for undecryptable incoming message', {
+            id: stanzaId,
+            to: from,
+            participant: retryReceiptNode.attrs.participant,
+            encType
+        });
+        return true;
+    }
+    catch (retryError) {
+        options.logger.warn('failed to send retry receipt for incoming message', {
+            id: stanzaId,
+            from,
+            participant: node.attrs.participant,
+            encType,
+            message: toError(retryError).message
+        });
+        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);
+        const unpaddedPlaintext = unpadPkcs7(decryptedPayload);
+        const decodedMessage = proto.Message.decode(unpaddedPlaintext);
+        const message = unwrapDeviceSentMessage(decodedMessage) ?? decodedMessage;
+        const senderKeyDistribution = pickSenderKeyDistributionPayload(message);
+        if (senderKeyDistribution && options.senderKeyManager) {
+            try {
+                await options.senderKeyManager.processSenderKeyDistributionPayload(senderKeyDistribution.groupId, senderAddress, senderKeyDistribution.payload);
+                log.trace('processed incoming sender key distribution', {
+                    groupId: senderKeyDistribution.groupId
+                });
+            }
+            catch (error) {
+                log.warn('failed to process incoming sender key distribution', {
+                    groupId: senderKeyDistribution.groupId,
+                    message: toError(error).message
+                });
+            }
+        }
+        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),
+                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),
+                ...(expirationSeconds !== undefined ? { expirationSeconds } : {}),
+                pushName,
+                message
+            });
+        }
+        return { success: true, encType };
+    }
+    catch (error) {
+        log.warn('failed to decrypt incoming message', {
+            encType,
+            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.decrypt_failed.${encType}`
+        });
+        return { success: false, encType, error };
+    }
+}
+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) {
+        const senderJid = node.attrs.participant ?? node.attrs.from;
+        let hasSuccessfulDecrypt = false;
+        let firstDecryptFailure = null;
+        let encCount = 0;
+        let firstEncType;
+        for (const child of nodeContent) {
+            if (child.tag !== WA_MESSAGE_TAGS.ENC) {
+                continue;
+            }
+            encCount += 1;
+            if (firstEncType === undefined) {
+                firstEncType = child.attrs.type;
+            }
+            let result = null;
+            switch (child.attrs.type) {
+                case 'skmsg': {
+                    if (!senderJid || !node.attrs.from || !options.senderKeyManager) {
+                        options.emitUnhandledStanza?.({
+                            rawNode: buildIncomingEventRawNode(node),
+                            stanzaId: node.attrs.id,
+                            chatJid: node.attrs.from,
+                            stanzaType: node.attrs.type,
+                            offline: node.attrs.offline !== undefined,
+                            reason: 'message.skmsg.missing_group_context'
+                        });
+                        continue;
+                    }
+                    const groupId = node.attrs.from;
+                    result = await decryptAndProcessEncNode(node, child, 'skmsg', senderJid, options, (ciphertext, senderAddress) => options.senderKeyManager.decryptGroupMessage({
+                        groupId,
+                        sender: senderAddress,
+                        ciphertext
+                    }));
+                    break;
+                }
+                case 'msg':
+                case 'pkmsg': {
+                    if (!senderJid || !options.signalProtocol) {
+                        continue;
+                    }
+                    const encType = child.attrs.type === 'msg' ? 'msg' : 'pkmsg';
+                    result = await decryptAndProcessEncNode(node, child, encType, senderJid, options, (ciphertext, senderAddress) => options.signalProtocol.decryptMessage(senderAddress, {
+                        type: encType,
+                        ciphertext
+                    }));
+                    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;
+            }
+            if (result.success)
+                hasSuccessfulDecrypt = true;
+            else if (!firstDecryptFailure)
+                firstDecryptFailure = result;
+        }
+        if (encCount > 1 && firstEncType === 'skmsg') {
+            options.logger.warn('incoming message enc order is unexpected: skmsg first', {
+                id: node.attrs.id,
+                from: node.attrs.from,
+                participant: node.attrs.participant,
+                encCount
+            });
+        }
+        if (encCount > 0 && !hasSuccessfulDecrypt && firstDecryptFailure) {
+            await sendRetryReceiptForDecryptFailure(node, options, firstDecryptFailure.error, firstDecryptFailure.encType);
+            shouldSendStandardReceipt = false;
+        }
+    }
+    const id = node.attrs.id;
+    if (!id || !from) {
+        options.logger.warn('incoming message missing required attrs for ack/receipt', {
+            hasId: Boolean(id),
+            hasFrom: Boolean(from),
+            type: node.attrs.type
+        });
+        return true;
+    }
+    if (node.attrs.type === WA_MESSAGE_TYPES.MEDIA_NOTIFY) {
+        const ackNode = buildAckNode({
+            kind: 'message',
+            node,
+            id,
+            to: from,
+            from: options.getMeJid?.()
+        });
+        options.logger.trace('sending inbound message ack', {
+            id,
+            to: from,
+            type: ackNode.attrs.type,
+            participant: ackNode.attrs.participant
+        });
+        await options.sendNode(ackNode);
+        return true;
+    }
+    if (!shouldSendStandardReceipt) {
+        return true;
+    }
+    const receiptNode = buildReceiptNode({
+        kind: 'delivery',
+        node,
+        id,
+        to: from
+    });
+    options.logger.trace('sending inbound message receipt', {
+        id,
+        to: from,
+        type: receiptNode.attrs.type,
+        participant: receiptNode.attrs.participant
+    });
+    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;
+}

package/dist/esm/message/primitives/peer-data-operation.js

@@ -0,0 +1,93 @@
+import { proto } from '../../proto.js';
+import { toUserJid } from '../../protocol/jid.js';
+import { setBoundedMapEntry } from '../../util/collections.js';
+const DEFAULT_TIMEOUT_MS = 30000;
+const DEFAULT_MAX_PENDING = 256;
+function buildRequestProtocolMessage(type, body) {
+    return {
+        type: proto.Message.ProtocolMessage.Type.PEER_DATA_OPERATION_REQUEST_MESSAGE,
+        peerDataOperationRequestMessage: {
+            ...body,
+            peerDataOperationRequestType: type
+        }
+    };
+}
+export function createPeerDataOperationRequester(options) {
+    const { logger, publishProtocolMessageToDevice, getCurrentCredentials, generateOutgoingMessageId, subscribeToProtocolMessage } = options;
+    const defaultTimeoutMs = options.defaultTimeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const maxPending = options.maxPending ?? DEFAULT_MAX_PENDING;
+    const pending = new Map();
+    subscribeToProtocolMessage((event) => {
+        const protocolMessage = event.protocolMessage;
+        if (protocolMessage.type !==
+            proto.Message.ProtocolMessage.Type.PEER_DATA_OPERATION_REQUEST_RESPONSE_MESSAGE) {
+            return;
+        }
+        const response = protocolMessage.peerDataOperationRequestResponseMessage;
+        if (!response) {
+            return;
+        }
+        const stanzaId = response.stanzaId;
+        const results = response.peerDataOperationResult ?? [];
+        if (!stanzaId) {
+            logger.debug('pdo response without stanzaId', {
+                from: event.key.remoteJid,
+                resultCount: results.length
+            });
+            return;
+        }
+        const entry = pending.get(stanzaId);
+        if (!entry) {
+            logger.debug('pdo response for unknown stanzaId', {
+                stanzaId,
+                resultCount: results.length
+            });
+            return;
+        }
+        clearTimeout(entry.timeout);
+        pending.delete(stanzaId);
+        entry.resolve(results);
+    });
+    const publish = async (type, body, id) => {
+        const meJid = getCurrentCredentials()?.meJid;
+        if (!meJid) {
+            throw new Error('peer data operation requires current me jid');
+        }
+        const result = await publishProtocolMessageToDevice(toUserJid(meJid), buildRequestProtocolMessage(type, body), { id, pushPriority: 'high_force' });
+        return result.id;
+    };
+    return {
+        request: async (type, body, requestOptions) => {
+            const messageId = await generateOutgoingMessageId();
+            const timeoutMs = requestOptions?.timeoutMs ?? defaultTimeoutMs;
+            return new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => {
+                    if (!pending.delete(messageId)) {
+                        return;
+                    }
+                    logger.debug('pdo request timed out', { messageId, timeoutMs, type });
+                    reject(new Error(`peer data operation timed out after ${timeoutMs}ms (id=${messageId})`));
+                }, timeoutMs);
+                const entry = { resolve, reject, timeout };
+                setBoundedMapEntry(pending, messageId, entry, maxPending, (evictedKey, evicted) => {
+                    clearTimeout(evicted.timeout);
+                    logger.warn('pdo pending entry evicted: capacity reached', {
+                        evictedId: evictedKey,
+                        maxPending
+                    });
+                    evicted.reject(new Error(`peer data operation evicted from pending map (id=${String(evictedKey)})`));
+                });
+                publish(type, body, messageId).catch((error) => {
+                    clearTimeout(timeout);
+                    if (pending.delete(messageId)) {
+                        reject(error instanceof Error ? error : new Error(String(error)));
+                    }
+                });
+            });
+        },
+        send: async (type, body) => {
+            const messageId = await generateOutgoingMessageId();
+            return { messageId: await publish(type, body, messageId) };
+        }
+    };
+}

package/dist/esm/mex.js

@@ -0,0 +1 @@
+export { WA_MEX_PERSIST_IDS, WA_MEX_OPERATION_SCHEMAS } from '../spec/mex';