zapo-js 1.1.2 → 1.2.0

package/dist/esm/client/coordinators/WaMessageDispatchCoordinator.js

@@ -12,7 +12,7 @@ import { writeRandomPadMax16 } from '../../message/encode/padding.js';
 import { buildBotInvokeProtoCopy, extractInvokedBotJid, genBotMsgSecret } from '../../message/kinds/bot.js';
 import { proto } from '../../proto.js';
 import { WA_DEFAULTS, WA_NACK_REASONS } from '../../protocol/constants.js';
-import { isBotJid, isGroupJid, isHostedDeviceJid, isLidJid, isNewsletterJid, normalizeDeviceJid, normalizeRecipientJid, parseJidFull, parseSignalAddressFromJid, signalAddressKey, toUserJid } from '../../protocol/jid.js';
+import { canonicalizeOwnAccountJid, isBotJid, isGroupJid, isHostedDeviceJid, isLidJid, isNewsletterJid, isUserJid, normalizeDeviceJid, normalizeRecipientJid, parseJidFull, parseSignalAddressFromJid, signalAddressKey, toUserJid } from '../../protocol/jid.js';
 import { encodeBinaryNode } from '../../transport/binary/index.js';
 import { buildButtonAddonNode, buildDirectMessageFanoutNode, buildGroupSenderKeyMessageNode, buildMetaNode } from '../../transport/node/builders/message.js';
 import { bytesToHex, TEXT_ENCODER } from '../../util/bytes.js';
@@ -65,17 +65,20 @@ export class WaMessageDispatchCoordinator {
     }
     async publishSignalMessage(input, options = {}) {
         this.requireCurrentMeJid('publishSignalMessage');
-        const address = parseSignalAddressFromJid(input.to);
+        const credentials = this.deps.getCurrentCredentials();
+        const sessionJid = canonicalizeOwnAccountJid(input.to, credentials?.meJid, credentials?.meLid);
+        const address = parseSignalAddressFromJid(sessionJid);
         if (address.server === WA_DEFAULTS.GROUP_SERVER) {
             throw new Error('publishSignalMessage currently supports only direct chats; use sender-key flow for groups');
         }
         this.deps.logger.trace('wa client publish signal message', {
             to: input.to,
+            sessionJid,
             type: input.type
         });
         const [paddedPlaintext] = await Promise.all([
             writeRandomPadMax16(input.plaintext),
-            this.deps.sessionResolver.ensureSession(address, input.to, input.expectedIdentity)
+            this.deps.sessionResolver.ensureSession(address, sessionJid, input.expectedIdentity)
         ]);
         const encrypted = await this.deps.signalProtocol.encryptMessage(address, paddedPlaintext, input.expectedIdentity);
         const messageType = input.type ?? 'text';
@@ -211,7 +214,7 @@ export class WaMessageDispatchCoordinator {
         if (rawSecret &&
             rawSecret.length > 0 &&
             sendOptions.id &&
-            needsSecretPersistence(messageWithSecret)) {
+            (this.deps.persistAllMessageSecrets || needsSecretPersistence(messageWithSecret))) {
             const meJid = this.deps.getCurrentCredentials()?.meJid ?? '';
             void this.deps.messageSecretStore
                 .set(sendOptions.id, { secret: rawSecret, senderJid: meJid })
@@ -272,11 +275,14 @@ export class WaMessageDispatchCoordinator {
         const directRecipientJid = isGroup
             ? recipientJid
             : await this.resolveDirectRecipientLid(toUserJid(recipientJid));
+        const peerRecipientPn = isGroup
+            ? undefined
+            : await this.resolvePeerRecipientPn(toUserJid(recipientJid), directRecipientJid);
         const publishResult = isGroup
             ? this.shouldUseGroupDirectPath(messageWithIcdc)
                 ? await this.publishGroupDirectMessage(recipientJid, envelope)
                 : await this.publishGroupSenderKeyMessage(recipientJid, envelope)
-            : await this.publishDirectSignalMessageWithFanout(directRecipientJid, envelope);
+            : await this.publishDirectSignalMessageWithFanout(directRecipientJid, envelope, peerRecipientPn);
         return upload ? { ...publishResult, upload } : publishResult;
     }
     /**
@@ -311,6 +317,35 @@ export class WaMessageDispatchCoordinator {
         }
         return pnUserJid;
     }
+    /**
+     * Resolves the `peer_recipient_pn` cross-reference for a 1:1 send, or
+     * `undefined` to drop the attribute. Only set when the envelope is
+     * LID-addressed (`directRecipientJid` is a LID): the PN is the caller's own
+     * JID when they passed a PN (zapo switched it to LID for sending), else the
+     * device-list snapshot counterpart for a recipient passed in LID form.
+     * Mirrors wa-web, which sets `peer_recipient_pn = getPhoneNumber($)` for a
+     * LID destination.
+     */
+    async resolvePeerRecipientPn(recipientUserJid, directRecipientJid) {
+        if (!isLidJid(directRecipientJid))
+            return undefined;
+        if (isUserJid(recipientUserJid))
+            return recipientUserJid;
+        try {
+            const snapshot = await this.deps.deviceListStore.findByAnyUserJid(directRecipientJid);
+            if (snapshot?.userJid && isUserJid(snapshot.userJid))
+                return snapshot.userJid;
+            if (snapshot?.altUserJid && isUserJid(snapshot.altUserJid))
+                return snapshot.altUserJid;
+        }
+        catch (error) {
+            this.deps.logger.trace('peer_recipient_pn store lookup failed', {
+                lid: directRecipientJid,
+                message: toError(error).message
+            });
+        }
+        return undefined;
+    }
     async syncSignalSession(jid, reasonIdentity = false) {
         const address = parseSignalAddressFromJid(jid);
         if (address.server === WA_DEFAULTS.GROUP_SERVER) {
@@ -322,7 +357,8 @@ export class WaMessageDispatchCoordinator {
         await this.deps.messageClient.sendReceipt(input);
     }
     async publishProtocolMessageToDevice(deviceJid, protocolMessage, options) {
-        const meJid = this.deps.getCurrentCredentials()?.meJid;
+        const credentials = this.deps.getCurrentCredentials();
+        const meJid = credentials?.meJid;
         const meParsed = meJid ? parseJidFull(meJid) : undefined;
         const meUserJid = meParsed?.userJid;
         let senderIcdc = null;
@@ -990,7 +1026,7 @@ export class WaMessageDispatchCoordinator {
             distributionParticipants
         };
     }
-    async publishDirectSignalMessageWithFanout(recipientJid, envelope) {
+    async publishDirectSignalMessageWithFanout(recipientJid, envelope, peerRecipientPn) {
         const { message, plaintext, type, edit, mediatype, sendOptions } = envelope;
         const meJid = this.requireCurrentMeJid('sendMessage');
         const meLid = this.deps.getCurrentCredentials()?.meLid;
@@ -1153,6 +1189,7 @@ export class WaMessageDispatchCoordinator {
             customNodes: customNodes.length > 0 ? customNodes : undefined,
             mediatype,
             decryptFail: envelope.decryptFail,
+            peerRecipientPn,
             additionalAttributes: sendOptions.additionalAttributes
         });
         const replayPayload = {

package/dist/esm/client/coordinators/WaPresenceCoordinator.js

@@ -1,8 +1,9 @@
+import { isGroupJid } from '../../protocol/jid.js';
 import { buildChatstateNode } from '../../transport/node/builders/chatstate.js';
 import { buildPresenceNode, buildPresenceSubscribeNode } from '../../transport/node/builders/presence.js';
 /** Builds a {@link WaPresenceCoordinator} from its node-send dependency. */
 export function createPresenceCoordinator(options) {
-    const { sendNode, getCurrentCredentials } = options;
+    const { sendNode, getCurrentCredentials, resolvePrivacyTokenNode } = options;
     return {
         send: async (type) => {
             const credentials = getCurrentCredentials();
@@ -12,7 +13,12 @@ export function createPresenceCoordinator(options) {
             await sendNode(buildChatstateNode({ jid, ...opts }));
         },
         subscribe: async (jid, opts) => {
-            await sendNode(buildPresenceSubscribeNode({ jid, ...opts }));
+            const privacyTokenNode = isGroupJid(jid) ? null : await resolvePrivacyTokenNode(jid);
+            await sendNode(buildPresenceSubscribeNode({
+                jid,
+                ...opts,
+                ...(privacyTokenNode ? { privacyTokenNode } : {})
+            }));
         }
     };
 }

package/dist/esm/client/coordinators/WaProfileCoordinator.js

@@ -192,10 +192,11 @@ function buildTextStatusMutationInput(input) {
 }
 /** Builds a {@link WaProfileCoordinator} from its IQ/MEX/SID dependencies. */
 export function createProfileCoordinator(options) {
-    const { queryWithContext, generateSid, mexSocket, queryLidsByPhoneJids, mutations, applyOwnPushName, logger } = options;
+    const { queryWithContext, generateSid, mexSocket, queryLidsByPhoneJids, mutations, applyOwnPushName, resolvePrivacyTokenNode, logger } = options;
     return {
         getProfilePicture: async (jid, type, existingId) => {
-            const node = buildGetProfilePictureIq(jid, type, existingId);
+            const privacyTokenNode = (await resolvePrivacyTokenNode(jid)) ?? undefined;
+            const node = buildGetProfilePictureIq(jid, type, existingId, privacyTokenNode);
             const result = await queryWithContext('profile.getPicture', node, undefined, {
                 jid,
                 type: type ?? 'preview'
@@ -222,10 +223,11 @@ export function createProfileCoordinator(options) {
         getStatus: async (jid) => {
             const sid = await generateSid();
             const queryNodes = buildGetStatusUsyncQueryNodes();
+            const privacyTokenNode = await resolvePrivacyTokenNode(jid);
             const usyncNode = buildUsyncIq({
                 sid,
                 queryProtocolNodes: [queryNodes[1]],
-                users: [{ jid }]
+                users: [{ jid, ...(privacyTokenNode ? { content: [privacyTokenNode] } : {}) }]
             });
             const result = await queryWithContext('profile.getStatus', usyncNode, undefined, {
                 jid
@@ -253,10 +255,14 @@ export function createProfileCoordinator(options) {
             }
             const sid = await generateSid();
             const queryProtocolNodes = buildGetStatusUsyncQueryNodes();
+            const users = await Promise.all(jids.map(async (jid) => {
+                const privacyTokenNode = await resolvePrivacyTokenNode(jid);
+                return { jid, ...(privacyTokenNode ? { content: [privacyTokenNode] } : {}) };
+            }));
             const usyncNode = buildUsyncIq({
                 sid,
                 queryProtocolNodes,
-                users: jids.map((jid) => ({ jid }))
+                users
             });
             const result = await queryWithContext('profile.getProfiles', usyncNode, undefined, {
                 count: jids.length

package/dist/esm/client/coordinators/WaRetryCoordinator.js

@@ -499,7 +499,7 @@ export class WaRetryCoordinator {
                     id: request.keyBundle.key.id,
                     publicKey: request.keyBundle.key.publicKey
                 }
-            });
+            }, { reuseExisting: true });
             return this.applySessionBaseKeyPolicy(request, requesterJid, requesterAddress, requesterNormalizedDeviceJid);
         }
         const sessionStillExists = currentSession !== null && !regIdMismatch;

package/dist/esm/client/coordinators/WaTrustedContactTokenCoordinator.js

@@ -39,14 +39,30 @@ export class WaTrustedContactTokenCoordinator {
             maxDurationS
         };
     }
-    async resolveTokenForMessage(recipientJid) {
-        const record = await this.store.getByJid(recipientJid);
-        const nowS = this.serverClock.nowSeconds();
+    /**
+     * Resolves the receiver-mode `<tctoken>` node to echo back on outbound
+     * queries against a contact's privacy-gated data (presence subscribe,
+     * profile-picture get, about/status usync). Returns the token only when a
+     * non-expired receiver token exists for `jid`; unlike
+     * {@link resolveTokenForMessage} it does **not** fall back to a `<cstoken>`
+     * (the gated query flows attach the trusted-contact token only).
+     */
+    async resolveReceiverTokenNode(jid) {
+        const record = await this.store.getByJid(jid);
+        if (!record?.tcToken || record.tcTokenTimestamp === undefined) {
+            return null;
+        }
         const config = this.resolveConfig();
-        if (record?.tcToken &&
-            record.tcTokenTimestamp !== undefined &&
-            !isTokenExpired(record.tcTokenTimestamp, nowS, config.durationS, config.numBuckets)) {
-            return buildTcTokenMessageNode(record.tcToken);
+        const nowS = this.serverClock.nowSeconds();
+        if (isTokenExpired(record.tcTokenTimestamp, nowS, config.durationS, config.numBuckets)) {
+            return null;
+        }
+        return buildTcTokenMessageNode(record.tcToken);
+    }
+    async resolveTokenForMessage(recipientJid) {
+        const tcTokenNode = await this.resolveReceiverTokenNode(recipientJid);
+        if (tcTokenNode) {
+            return tcTokenNode;
         }
         const nctSalt = await this.getNctSalt();
         if (!nctSalt) {

package/dist/esm/client/persistence/mailbox.js

@@ -53,7 +53,7 @@ function persistContacts(writeBehind, event, nowMs) {
     }
 }
 export function persistIncomingMailboxEntities(options) {
-    const { logger, writeBehind, messageSecretStore, event } = options;
+    const { logger, writeBehind, messageSecretStore, persistAllSecrets, event } = options;
     const stanzaId = event.key.id;
     const chatJid = event.key.remoteJid;
     if (!stanzaId || !chatJid) {
@@ -78,7 +78,7 @@ export function persistIncomingMailboxEntities(options) {
         if (rawSecret &&
             rawSecret.length > 0 &&
             event.message &&
-            needsSecretPersistence(event.message)) {
+            (persistAllSecrets || needsSecretPersistence(event.message))) {
             const rawSender = event.key.participant ?? event.rawNode.attrs.participant ?? event.key.remoteJid;
             const senderJid = rawSender ? toUserJid(rawSender) : '';
             void messageSecretStore

package/dist/esm/message/primitives/incoming.js

@@ -4,7 +4,7 @@ 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 { canonicalizeOwnAccountJid, isBroadcastJid, isGroupJid, isNewsletterJid, isOwnAccountJid, 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';
@@ -27,6 +27,52 @@ function extractMessageIdentityAttrs(attrs) {
         pushName: attrs.notify
     };
 }
+/**
+ * Self-authored 1:1 chat is the recipient, so its alternate addressing is the
+ * `recipient*` attrs (the `sender*` attrs describe me). Promotes `recipientAlt`
+ * to `remoteJidAlt` and drops the stale sender/recipient fields.
+ */
+function promoteRecipientAddressing(identity) {
+    return {
+        ...(identity.recipientAlt ? { remoteJidAlt: identity.recipientAlt } : {}),
+        ...(identity.senderUsername !== undefined
+            ? { senderUsername: identity.senderUsername }
+            : {})
+    };
+}
+/**
+ * Resolves the {@link WaIncomingMessageKey} for a decrypted stanza. `remoteJid`
+ * is the chat: the `from`, or the recipient (`recipient` attr, then the
+ * deviceSentMessage `destinationJid`) when the message is `fromMe`.
+ */
+function buildIncomingMessageKey(node, sender, options, destinationJid) {
+    const fromUserJid = node.attrs.from ? toUserJid(node.attrs.from) : node.attrs.from;
+    const isGroup = fromUserJid ? isGroupJid(fromUserJid) : false;
+    const isBroadcast = fromUserJid ? isBroadcastJid(fromUserJid) : false;
+    const fromMe = sender
+        ? isOwnAccountJid(sender.userJid, options.getMeJid?.(), options.getMeLid?.())
+        : false;
+    const selfSentChat = fromMe && !isGroup && !isBroadcast
+        ? (node.attrs.recipient ?? destinationJid ?? undefined)
+        : undefined;
+    const chatJid = selfSentChat ? toUserJid(selfSentChat) : fromUserJid;
+    const { pushName, ...identity } = extractMessageIdentityAttrs(node.attrs);
+    const keyIdentity = selfSentChat ? promoteRecipientAddressing(identity) : identity;
+    return {
+        pushName,
+        key: {
+            remoteJid: chatJid ?? '',
+            id: node.attrs.id ?? '',
+            fromMe,
+            isGroup,
+            isBroadcast,
+            isNewsletter: false,
+            ...keyIdentity,
+            senderDevice: sender?.device ?? 0,
+            ...((isGroup || isBroadcast) && sender ? { participant: sender.userJid } : {})
+        }
+    };
+}
 function pickNextRetryCount(node) {
     const retryNode = findNodeChild(node, 'retry');
     const parsed = parseOptionalInt(retryNode?.attrs.count);
@@ -240,26 +286,11 @@ function processMsmsgEncNode(node, encNode, senderJid, options) {
                 encPayload: decoded.encPayload
             }
         };
-        const chatJid = node.attrs.from ? toUserJid(node.attrs.from) : 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);
+        const { key, pushName } = buildIncomingMessageKey(node, sender ? { userJid: sender.userJid, device: sender.address.device } : null, options);
         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
-            },
+            key,
             stanzaType: node.attrs.type,
             offline: node.attrs.offline !== undefined,
             timestampSeconds: parseOptionalInt(node.attrs.t),
@@ -313,29 +344,14 @@ async function decryptAndProcessEncNode(node, encNode, encType, senderJid, optio
             }
         }
         if (shouldEmitIncomingMessage(message)) {
-            // remoteJid is the chat identity, which is deviceless: the device
-            // lives in senderDevice (from senderAddress), so strip any `:device`
-            // segment the `from` attr carries for 1:1 chats.
-            const fromAttr = node.attrs.from;
-            const chatJid = fromAttr ? toUserJid(fromAttr) : fromAttr;
-            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 { key, pushName } = buildIncomingMessageKey(node, {
+                userJid: `${senderAddress.user}@${senderAddress.server}`,
+                device: senderAddress.device
+            }, options, decodedMessage.deviceSentMessage?.destinationJid ?? undefined);
             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 } : {})
-                },
+                key,
                 stanzaType: node.attrs.type,
                 offline: node.attrs.offline !== undefined,
                 timestampSeconds: parseOptionalInt(node.attrs.t),
@@ -414,10 +430,15 @@ export async function handleIncomingMessageAck(node, options) {
                         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
-                    }));
+                    result = await decryptAndProcessEncNode(node, child, encType, senderJid, options, (ciphertext, senderAddress) => {
+                        const sessionJid = canonicalizeOwnAccountJid(senderJid, options.getMeJid?.(), options.getMeLid?.());
+                        return options.signalProtocol.decryptMessage(sessionJid === senderJid
+                            ? senderAddress
+                            : parseSignalAddressFromJid(sessionJid), {
+                            type: encType,
+                            ciphertext
+                        });
+                    });
                     break;
                 }
                 case 'msmsg': {
@@ -475,6 +496,42 @@ export async function handleIncomingMessageAck(node, options) {
         await options.sendNode(ackNode);
         return true;
     }
+    const unavailableNode = findNodeChild(node, 'unavailable');
+    if (unavailableNode) {
+        const kind = unavailableNode.attrs.hosted === 'true'
+            ? 'hosted'
+            : unavailableNode.attrs.type === 'view_once'
+                ? 'view_once'
+                : 'other';
+        const senderJid = node.attrs.participant ?? node.attrs.from;
+        const sender = senderJid ? parseJidFull(senderJid) : null;
+        const { key, pushName } = buildIncomingMessageKey(node, sender ? { userJid: sender.userJid, device: sender.address.device } : null, options);
+        options.emitUnavailableMessage?.({
+            rawNode: buildIncomingEventRawNode(node),
+            key,
+            kind,
+            stanzaType: node.attrs.type,
+            offline: node.attrs.offline !== undefined,
+            timestampSeconds: parseOptionalInt(node.attrs.t),
+            pushName
+        });
+        const ackNode = buildAckNode({
+            kind: 'message',
+            node,
+            id,
+            to: from,
+            from: options.getMeJid?.()
+        });
+        options.logger.trace('acking unavailable incoming message', {
+            id,
+            to: from,
+            type: ackNode.attrs.type,
+            participant: ackNode.attrs.participant,
+            unavailableKind: kind
+        });
+        await options.sendNode(ackNode);
+        return true;
+    }
     if (!shouldSendStandardReceipt) {
         return true;
     }

package/dist/esm/protocol/jid.js

@@ -191,6 +191,48 @@ export function toUserJid(jid, options = {}) {
         : address.server;
     return `${address.user}@${server}`;
 }
+/**
+ * True when `jid` is the account's own user, matching the `meJid` (pn) or
+ * `meLid` (lid) identity device-insensitively. Mirrors WhatsApp Web's
+ * `isMeAccount`.
+ */
+export function isOwnAccountJid(jid, meJid, meLid) {
+    const candidateUser = toUserJid(jid);
+    return ((!!meJid && toUserJid(meJid) === candidateUser) ||
+        (!!meLid && toUserJid(meLid) === candidateUser));
+}
+/**
+ * Rewrites the account's own PN device JID to its LID equivalent so self traffic
+ * keys one LID session instead of forking into separate PN and LID ratchets.
+ * No-op for other users, already-LID/unparseable JIDs, or unknown identity.
+ */
+export function canonicalizeOwnAccountJid(jid, meJid, meLid) {
+    if (!meJid || !meLid)
+        return jid;
+    let address;
+    try {
+        address = parseSignalAddressFromJid(jid);
+    }
+    catch {
+        return jid;
+    }
+    if ((address.server ?? WA_DEFAULTS.HOST_DOMAIN) !== WA_DEFAULTS.HOST_DOMAIN)
+        return jid;
+    let mePnUser;
+    let meLidUser;
+    try {
+        mePnUser = parseSignalAddressFromJid(meJid).user;
+        meLidUser = parseSignalAddressFromJid(meLid).user;
+    }
+    catch {
+        return jid;
+    }
+    if (address.user !== mePnUser)
+        return jid;
+    return address.device === 0
+        ? `${meLidUser}@${WA_DEFAULTS.LID_SERVER}`
+        : `${meLidUser}:${address.device}@${WA_DEFAULTS.LID_SERVER}`;
+}
 /**
  * Returns the JID in its full device form. JIDs with `device === 0` lose the
  * device segment (`user@server`); all others keep `user:device@server`.

package/dist/esm/retry/reason.js

@@ -17,10 +17,10 @@ const RETRY_REASON_MATCHERS = [
     },
     { matches: ['invalid signature'], code: RETRY_REASON.SignalErrorInvalidSignature },
     {
-        matches: ['too many messages in future', 'future message'],
+        matches: ['too far in future', 'too many messages in future', 'future message'],
         code: RETRY_REASON.SignalErrorFutureMessage
     },
-    { matches: ['invalid mac'], code: RETRY_REASON.SignalErrorBadMac },
+    { matches: ['invalid message mac', 'invalid mac'], code: RETRY_REASON.SignalErrorBadMac },
     { matches: ['invalid session'], code: RETRY_REASON.SignalErrorInvalidSession },
     { matches: ['invalid message key'], code: RETRY_REASON.SignalErrorInvalidMsgKey },
     {

package/dist/esm/transport/node/WaNodeOrchestrator.js

@@ -21,8 +21,12 @@ export class WaNodeOrchestrator {
         return this.pendingQueries.size > 0;
     }
     clearPending(reason) {
-        this.logger.warn('clearing pending node queries', {
-            count: this.pendingQueries.size,
+        const count = this.pendingQueries.size;
+        if (count === 0) {
+            return;
+        }
+        this.logger.debug('clearing pending node queries', {
+            count,
             reason: reason.message
         });
         for (const pending of this.pendingQueries.values()) {

package/dist/esm/transport/node/builders/message.js

@@ -32,6 +32,9 @@ function buildMessageAttrs(input) {
     if (input.addressingMode) {
         attrs.addressing_mode = input.addressingMode;
     }
+    if (input.peerRecipientPn) {
+        attrs.peer_recipient_pn = input.peerRecipientPn;
+    }
     if (input.additionalAttributes) {
         Object.assign(attrs, input.additionalAttributes);
     }

package/dist/esm/transport/node/builders/presence.js

@@ -34,6 +34,7 @@ export function buildPresenceSubscribeNode(input) {
     }
     return {
         tag: WA_NODE_TAGS.PRESENCE,
-        attrs
+        attrs,
+        ...(input.privacyTokenNode ? { content: [input.privacyTokenNode] } : {})
     };
 }

package/dist/esm/transport/node/builders/profile.js

@@ -1,6 +1,6 @@
 import { WA_DEFAULTS, WA_IQ_TYPES, WA_NODE_TAGS, WA_XMLNS } from '../../../protocol/constants.js';
 import { buildIqNode } from '../../node/query.js';
-export function buildGetProfilePictureIq(targetJid, type = 'preview', existingId) {
+export function buildGetProfilePictureIq(targetJid, type = 'preview', existingId, privacyTokenNode) {
     const pictureAttrs = {
         type,
         query: 'url'
@@ -11,7 +11,8 @@ export function buildGetProfilePictureIq(targetJid, type = 'preview', existingId
     return buildIqNode(WA_IQ_TYPES.GET, WA_DEFAULTS.HOST_DOMAIN, WA_XMLNS.PROFILE_PICTURE, [
         {
             tag: WA_NODE_TAGS.PICTURE,
-            attrs: pictureAttrs
+            attrs: pictureAttrs,
+            ...(privacyTokenNode ? { content: [privacyTokenNode] } : {})
         }
     ], {
         target: targetJid

package/dist/esm/transport/node/builders/retry.js

@@ -73,11 +73,9 @@ export function buildRetryReceiptNode(input) {
         v: RETRY_RECEIPT_VERSION,
         count: String(input.retryCount),
         id: input.originalMsgId,
-        t: input.t
+        t: input.t,
+        error: String(input.error ?? 0)
     };
-    if (input.error !== undefined && input.error !== 0) {
-        retryAttrs.error = String(input.error);
-    }
     const content = [
         {
             tag: 'retry',

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export { WaClient } from './client';
 export type { WaClientEventMap, WaClientOptions, WaClientProxyOptions, WaDownloadMediaOptions, WaHistorySyncChunkEvent, WaHistorySyncOptions, WaWriteBehindOptions } from './client/types';
 export type { WaMessageCoordinator } from './client/coordinators/WaMessageCoordinator';
-export type { WaAccountTakeoverNoticeEvent, WaAppStateMutationEvent, WaAppStateMutationSource, WaBusinessEvent, WaBusinessEventAction, WaBusinessProfileResult, WaConnectionEvent, WaGroupEvent, WaGroupEventAction, WaGroupEventLinkedGroup, WaGroupEventMembershipRequest, WaGroupEventParticipant, WaGroupEventSubgroupSuggestion, WaIgnoreKey, WaIgnoreKeyContext, WaIgnoreKeyPredicate, WaIgnoreStanzaKind, WaIncomingAddonEvent, WaIncomingBaseEvent, WaIncomingBotChunkEvent, WaIncomingCallEvent, WaIncomingChatstateEvent, WaIncomingErrorStanzaEvent, WaIncomingFailureEvent, WaIncomingMessageEvent, WaIncomingMessageKey, WaIncomingNewsletterEvent, WaIncomingNewsletterMessageUpdateEvent, WaIncomingNodeHandler, WaIncomingNodeHandlerRegistration, WaIncomingNotificationEvent, WaIncomingPresenceEvent, WaIncomingProtocolMessageEvent, WaIncomingReceiptEvent, WaIncomingStanzaFilter, WaIncomingUnhandledStanzaEvent, WaMexLidChangeEvent, WaMexMessageCappingEvent, WaMexMessageCappingStatus, WaMexNotificationEvent, WaMexNotificationGraphQlError, WaMexNotificationOperationName, WaMexNotificationUnknownEvent, WaMexOwnUsernameSyncEvent, WaMexTextStatusUpdateEvent, WaMexTextStatusUpdateHintEvent, WaMexUsernameDeleteEvent, WaMexUsernameSetEvent, WaMexUsernameUpdateHintEvent, WaOfflineResumeEvent, WaPictureEvent, WaPictureEventAction, WaPrivacyTokenUpdateEvent, WaReceiptStatus, WaRegistrationCodeEvent, WaSendMessageOptions, WaVerifiedNameResult, WaAddonKind, WaNewsletterEventAction, WaNewsletterMessageUpdate, WaNewsletterPollVoteEntry, WaNewsletterReactionEntry } from './client/types';
+export type { WaAccountTakeoverNoticeEvent, WaAppStateMutationEvent, WaAppStateMutationSource, WaBusinessEvent, WaBusinessEventAction, WaBusinessProfileResult, WaConnectionEvent, WaGroupEvent, WaGroupEventAction, WaGroupEventLinkedGroup, WaGroupEventMembershipRequest, WaGroupEventParticipant, WaGroupEventSubgroupSuggestion, WaIgnoreKey, WaIgnoreKeyContext, WaIgnoreKeyPredicate, WaIgnoreStanzaKind, WaIncomingAddonEvent, WaIncomingBaseEvent, WaIncomingBotChunkEvent, WaIncomingCallEvent, WaIncomingChatstateEvent, WaIncomingErrorStanzaEvent, WaIncomingFailureEvent, WaIncomingMessageEvent, WaIncomingMessageKey, WaIncomingNewsletterEvent, WaIncomingNewsletterMessageUpdateEvent, WaIncomingNodeHandler, WaIncomingNodeHandlerRegistration, WaIncomingNotificationEvent, WaIncomingPresenceEvent, WaIncomingProtocolMessageEvent, WaIncomingReceiptEvent, WaIncomingStanzaFilter, WaIncomingUnavailableMessageEvent, WaIncomingUnhandledStanzaEvent, WaMexLidChangeEvent, WaMexMessageCappingEvent, WaMexMessageCappingStatus, WaMexNotificationEvent, WaMexNotificationGraphQlError, WaMexNotificationOperationName, WaMexNotificationUnknownEvent, WaMexOwnUsernameSyncEvent, WaMexTextStatusUpdateEvent, WaMexTextStatusUpdateHintEvent, WaMexUsernameDeleteEvent, WaMexUsernameSetEvent, WaMexUsernameUpdateHintEvent, WaOfflineResumeEvent, WaPictureEvent, WaPictureEventAction, WaPrivacyTokenUpdateEvent, WaReceiptStatus, WaRegistrationCodeEvent, WaSendMessageOptions, WaUnavailableMessageKind, WaVerifiedNameResult, WaAddonKind, WaNewsletterEventAction, WaNewsletterMessageUpdate, WaNewsletterPollVoteEntry, WaNewsletterReactionEntry } from './client/types';
 export type { WaAppStateMutationCoordinator, WaBroadcastListParticipant, WaSetBroadcastListInput, WaSetStatusPrivacyInput } from './client/coordinators/WaAppStateMutationCoordinator';
 export type { WaBotCoordinator, WaBotInfo, WaBotPosingAsProfessional, WaBotProfileCommand, WaBotProfilePrompt, WaBotProfileResult, WaBotPromptOptions, WaGetBotProfileOptions } from './client/coordinators/WaBotCoordinator';
 export type { WaBroadcastListCoordinator, WaSendBroadcastListMessageInput } from './client/coordinators/WaBroadcastListCoordinator';

package/dist/message/primitives/incoming.d.ts

@@ -1,4 +1,4 @@
-import type { WaIncomingMessageEvent, WaIncomingNewsletterMessageUpdateEvent, WaIncomingUnhandledStanzaEvent } from '../../client/types';
+import type { WaIncomingMessageEvent, WaIncomingNewsletterMessageUpdateEvent, WaIncomingUnavailableMessageEvent, WaIncomingUnhandledStanzaEvent } from '../../client/types';
 import type { Logger } from '../../infra/log/types';
 import { proto } from '../../proto';
 import type { WaRetryDecryptFailureContext } from '../../retry/types';
@@ -9,11 +9,13 @@ interface WaIncomingMessageAckHandlerOptions {
     readonly logger: Logger;
     readonly sendNode: (node: BinaryNode) => Promise<void>;
     readonly getMeJid?: () => string | null | undefined;
+    readonly getMeLid?: () => string | null | undefined;
     readonly signalProtocol?: SignalProtocol;
     readonly senderKeyManager?: SenderKeyManager;
     readonly onDecryptFailure?: (context: WaRetryDecryptFailureContext, error: unknown) => Promise<boolean>;
     readonly emitIncomingMessage?: (event: WaIncomingMessageEvent) => void;
     readonly emitNewsletterMessageUpdate?: (event: WaIncomingNewsletterMessageUpdateEvent) => void;
+    readonly emitUnavailableMessage?: (event: WaIncomingUnavailableMessageEvent) => void;
     readonly emitUnhandledStanza?: (event: WaIncomingUnhandledStanzaEvent) => void;
 }
 /**