zapo-js 1.0.1 → 1.1.1

package/README.md

@@ -1,5 +1,9 @@
 <p align="center">
-  <img src="https://raw.githubusercontent.com/vinikjkkj/zapo/master/.github/assets/logo.png" alt="zapo" width="400" />
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/vinikjkkj/zapo/master/.github/assets/logo.png" />
+    <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/vinikjkkj/zapo/master/.github/assets/logo-light.png" />
+    <img src="https://raw.githubusercontent.com/vinikjkkj/zapo/master/.github/assets/logo-light.png" alt="zapo" width="400" />
+  </picture>
 </p>
 
 <p align="center">

package/dist/auth/pairing/WaPairingFlow.js

@@ -11,6 +11,7 @@ const WaAdvSignature_1 = require("../../signal/attestation/WaAdvSignature");
 const global_1 = require("../../transport/node/builders/global");
 const pairing_1 = require("../../transport/node/builders/pairing");
 const helpers_1 = require("../../transport/node/helpers");
+const query_1 = require("../../transport/node/query");
 const bytes_1 = require("../../util/bytes");
 class WaPairingFlow {
     constructor(options) {
@@ -49,6 +50,7 @@ class WaPairingFlow {
             responseTag: response.tag,
             responseType: response.attrs.type
         });
+        (0, query_1.assertIqResult)(response, 'companion hello');
         const linkCodeNode = (0, helpers_1.findNodeChild)(response, constants_1.WA_NODE_TAGS.LINK_CODE_COMPANION_REG);
         if (!linkCodeNode) {
             throw new Error('companion hello response missing link_code_companion_reg');

package/dist/client/WaClient.js

@@ -258,10 +258,28 @@ class WaClient extends node_events_1.EventEmitter {
                 return;
             }
             if (protocolType === _proto_1.proto.Message.ProtocolMessage.Type.HISTORY_SYNC_NOTIFICATION) {
-                if (this.options.history?.enabled !== false &&
-                    protocolMessage.historySyncNotification) {
-                    const peerRemoteJid = event.key.remoteJid;
-                    const peerStanzaId = event.key.id;
+                if (!protocolMessage.historySyncNotification) {
+                    return;
+                }
+                const peerRemoteJid = event.key.remoteJid;
+                const peerStanzaId = event.key.id;
+                const sendHistSyncReceipt = peerRemoteJid && peerStanzaId
+                    ? async () => {
+                        try {
+                            await this.message.sendReceipt(peerRemoteJid, peerStanzaId, {
+                                type: constants_1.WA_MESSAGE_TYPES.RECEIPT_TYPE_HISTORY_SYNC
+                            });
+                        }
+                        catch (err) {
+                            this.logger.warn('failed to send hist_sync receipt', {
+                                id: peerStanzaId,
+                                to: peerRemoteJid,
+                                message: (0, primitives_1.toError)(err).message
+                            });
+                        }
+                    }
+                    : undefined;
+                if (this.options.history?.enabled !== false) {
                     await (0, history_sync_1.runHistorySyncNotification)({
                         logger: this.logger,
                         mediaTransfer: this.mediaTransfer,
@@ -269,24 +287,12 @@ class WaClient extends node_events_1.EventEmitter {
                         emitEvent: this.emit.bind(this),
                         onPrivacyTokens: (conversations) => this.deps.trustedContactToken.hydrateFromHistorySync(conversations),
                         onNctSalt: (salt) => this.deps.trustedContactToken.hydrateNctSaltFromHistorySync(salt),
-                        onProcessed: peerRemoteJid && peerStanzaId
-                            ? async () => {
-                                try {
-                                    await this.message.sendReceipt(peerRemoteJid, peerStanzaId, {
-                                        type: constants_1.WA_MESSAGE_TYPES.RECEIPT_TYPE_HISTORY_SYNC
-                                    });
-                                }
-                                catch (err) {
-                                    this.logger.warn('failed to send hist_sync receipt', {
-                                        id: peerStanzaId,
-                                        to: peerRemoteJid,
-                                        message: (0, primitives_1.toError)(err).message
-                                    });
-                                }
-                            }
-                            : undefined
+                        onProcessed: sendHistSyncReceipt
                     }, protocolMessage.historySyncNotification);
                 }
+                else if (sendHistSyncReceipt) {
+                    await sendHistSyncReceipt();
+                }
                 return;
             }
             if (SYNC_RELATED_PROTOCOL_TYPES.has(protocolType)) {

package/dist/client/coordinators/WaIncomingNodeCoordinator.js

@@ -391,7 +391,7 @@ class WaIncomingNodeCoordinator {
                 try {
                     const routingInfo = (0, helpers_1.decodeNodeContentBase64OrBytes)(routingInfoNode.content, `ib.${constants_1.WA_NODE_TAGS.EDGE_ROUTING}.${constants_1.WA_NODE_TAGS.ROUTING_INFO}`);
                     await this.runtime.persistRoutingInfo(routingInfo);
-                    this.logger.info('updated routing info from info bulletin', {
+                    this.logger.debug('updated routing info from info bulletin', {
                         byteLength: routingInfo.byteLength
                     });
                 }

package/dist/client/coordinators/WaMessageCoordinator.js

@@ -4,9 +4,9 @@ exports.WaMessageCoordinator = void 0;
 const node_fs_1 = require("node:fs");
 const promises_1 = require("node:stream/promises");
 const receipt_1 = require("../events/receipt");
+const media_1 = require("../media");
 const addon_crypto_1 = require("../../message/crypto/addon-crypto");
 const content_1 = require("../../message/encode/content");
-const media_payload_1 = require("../../message/encode/media-payload");
 const _proto_1 = require("../../proto");
 const jid_1 = require("../../protocol/jid");
 const client_1 = require("../../transport/node/mex/client");
@@ -235,23 +235,7 @@ class WaMessageCoordinator {
      * for one-shot verified downloads.
      */
     async download(source, options = {}) {
-        const message = 'rawNode' in source ? source.message : source;
-        const payload = (0, media_payload_1.resolveMediaPayload)(message);
-        if (!payload) {
-            throw new Error('message has no downloadable media');
-        }
-        const { plaintext, metadata } = await this.mediaTransfer.downloadAndDecryptStream({
-            directPath: payload.directPath,
-            mediaType: payload.mediaType,
-            mediaKey: payload.mediaKey,
-            fileSha256: payload.fileSha256,
-            fileEncSha256: payload.fileEncSha256,
-            timeoutMs: options.timeoutMs,
-            signal: options.signal,
-            maxBytes: options.maxBytes
-        });
-        metadata.catch(() => undefined);
-        return plaintext;
+        return (0, media_1.downloadMediaMessage)(source, { ...options, transfer: this.mediaTransfer });
     }
     /**
      * Convenience wrapper around {@link download} that streams the decrypted

package/dist/client/coordinators/WaMessageDispatchCoordinator.js

@@ -164,7 +164,8 @@ class WaMessageDispatchCoordinator {
             quote: options.quote,
             forward: options.forward,
             mentions: options.mentions,
-            meLid: this.deps.getCurrentCredentials()?.meLid
+            meLid: this.deps.getCurrentCredentials()?.meLid,
+            targetJid: recipientJid
         });
         const withCtx = ctx ? (0, context_info_1.applyContextInfo)(built.message, ctx) : built.message;
         const withViewOnce = options.viewOnce ? (0, content_1.wrapAsViewOnce)(withCtx) : withCtx;

package/dist/{types/client → client}/coordinators/WaRetryCoordinator.d.ts

@@ -50,7 +50,6 @@ export declare class WaRetryCoordinator {
     private isRetryReceiptNode;
     private prepareDecryptFailureRetry;
     private sendDecryptFailureRetryReceipt;
-    private resolvePeerRetryRecipient;
     private handleParsedRetryRequest;
     private processRetryRequest;
     private prepareRetryResend;

package/dist/client/coordinators/WaRetryCoordinator.js

@@ -169,7 +169,7 @@ class WaRetryCoordinator {
         };
     }
     async sendDecryptFailureRetryReceipt(context, prepared) {
-        const recipient = context.recipient ?? this.resolvePeerRetryRecipient(context);
+        const { recipient } = context;
         const retryReceiptNode = (0, retry_1.buildRetryReceiptNode)({
             stanzaId: context.stanzaId,
             to: context.from,
@@ -194,26 +194,6 @@ class WaRetryCoordinator {
             withKeys: prepared.retryKeys !== undefined
         });
     }
-    resolvePeerRetryRecipient(context) {
-        if (!context.participant) {
-            return undefined;
-        }
-        const meLid = this.deps.getCurrentCredentials()?.meLid;
-        if (!meLid) {
-            return undefined;
-        }
-        try {
-            const participantUser = (0, jid_1.toUserJid)(context.participant);
-            const meUserLid = (0, jid_1.toUserJid)(meLid);
-            if (participantUser !== meUserLid) {
-                return undefined;
-            }
-            return meUserLid;
-        }
-        catch {
-            return undefined;
-        }
-    }
     async handleParsedRetryRequest(receiptNode, request) {
         if (request.type === constants_1.WA_MESSAGE_TYPES.RECEIPT_TYPE_ENC_REKEY_RETRY) {
             this.deps.logger.debug('received enc_rekey_retry request (voip path deferred)', {

package/dist/client/events/incoming.js

@@ -18,6 +18,7 @@ const call_1 = require("../events/call");
 const group_1 = require("../events/group");
 const mex_notification_1 = require("../events/mex-notification");
 const picture_1 = require("../events/picture");
+const receipt_1 = require("../events/receipt");
 const registration_1 = require("../events/registration");
 const constants_1 = require("../../protocol/constants");
 const jid_1 = require("../../protocol/jid");
@@ -188,7 +189,8 @@ function createIncomingReceiptHandler(options) {
                 status: mapped.status,
                 fromSelfDevice: mapped.fromSelfDevice,
                 participantJid: node.attrs.participant,
-                recipientJid: node.attrs.recipient
+                recipientJid: node.attrs.recipient,
+                messageIds: (0, receipt_1.extractReceiptIds)(node)
             });
         }
         else if (node.attrs.type && !INTERNAL_ONLY_RECEIPT_TYPES.has(node.attrs.type)) {

package/dist/client/events/receipt.d.ts

@@ -0,0 +1,30 @@
+import type { BinaryNode } from '../../transport/types';
+interface ReceiptTarget {
+    readonly chatJid: string;
+    readonly id: string;
+    readonly senderJid?: string;
+    readonly isGroupChat?: boolean;
+    readonly isBroadcastChat?: boolean;
+}
+interface AggregatedReceiptGroup {
+    readonly jid: string;
+    readonly ids: readonly string[];
+    readonly participant?: string;
+}
+export declare function aggregateReceiptTargets(targets: readonly ReceiptTarget[]): readonly AggregatedReceiptGroup[];
+/**
+ * Resolves every message id a `<receipt>` acknowledges, mirroring WhatsApp
+ * Web's `externalIds`. A batch receipt carries the extra ids in a
+ * `<list><item id=.../>` block; the top-level `attrs.id` is just one of them.
+ *
+ * - `<list><item>` ids come first. For `type="view"` receipts the item key is
+ *   `server_id` (not `id`), and the top-level id is NOT appended.
+ * - Otherwise the top-level `attrs.id` is appended last.
+ * - Aggregated receipts (carrying a `<participants>` child) are out of scope:
+ *   their ids live in `<user>` children, so this falls back to the single
+ *   top-level id for them.
+ *
+ * No dedup: matches wa-web, which pushes the top id without checking the list.
+ */
+export declare function extractReceiptIds(node: BinaryNode): readonly string[];
+export {};

package/dist/client/events/receipt.js

@@ -1,7 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.aggregateReceiptTargets = aggregateReceiptTargets;
+exports.extractReceiptIds = extractReceiptIds;
+const constants_1 = require("../../protocol/constants");
 const jid_1 = require("../../protocol/jid");
+const helpers_1 = require("../../transport/node/helpers");
 function needsParticipant(target) {
     if (target.isGroupChat !== undefined || target.isBroadcastChat !== undefined) {
         return target.isGroupChat === true || target.isBroadcastChat === true;
@@ -24,3 +27,32 @@ function aggregateReceiptTargets(targets) {
     }
     return [...groups.values()];
 }
+/**
+ * Resolves every message id a `<receipt>` acknowledges, mirroring WhatsApp
+ * Web's `externalIds`. A batch receipt carries the extra ids in a
+ * `<list><item id=.../>` block; the top-level `attrs.id` is just one of them.
+ *
+ * - `<list><item>` ids come first. For `type="view"` receipts the item key is
+ *   `server_id` (not `id`), and the top-level id is NOT appended.
+ * - Otherwise the top-level `attrs.id` is appended last.
+ * - Aggregated receipts (carrying a `<participants>` child) are out of scope:
+ *   their ids live in `<user>` children, so this falls back to the single
+ *   top-level id for them.
+ *
+ * No dedup: matches wa-web, which pushes the top id without checking the list.
+ */
+function extractReceiptIds(node) {
+    const topId = node.attrs.id;
+    if ((0, helpers_1.hasNodeChild)(node, 'participants')) {
+        return topId ? [topId] : [];
+    }
+    const isView = node.attrs.type === constants_1.WA_MESSAGE_TYPES.RECEIPT_TYPE_VIEW;
+    const list = (0, helpers_1.findNodeChild)(node, 'list');
+    const ids = list
+        ? [...(0, helpers_1.getNodeChildrenNonEmptyAttrValuesByTag)(list, 'item', isView ? 'server_id' : 'id')]
+        : [];
+    if (!isView && topId) {
+        ids.push(topId);
+    }
+    return ids;
+}

package/dist/{types/client → client}/media.d.ts

@@ -1,9 +1,11 @@
 import { type Readable } from 'node:stream';
-import type { WaMediaOptions } from './types';
+import type { WaDownloadMediaOptions, WaIncomingMessageEvent, WaMediaOptions } from './types';
 import type { Logger } from '../infra/log/types';
-import type { WaMediaTransferClient } from '../media/transfer/WaMediaTransferClient';
+import { WaMediaTransferClient } from '../media/transfer/WaMediaTransferClient';
 import type { WaMediaConn } from '../media/types';
 import type { WaSendMediaMessage } from '../message/types';
+import type { Proto } from '../proto';
+import type { WaProxyTransport } from '../transport/types';
 export interface ProcessedMediaFields {
     readonly jpegThumbnail?: Uint8Array;
     readonly pngThumbnail?: Uint8Array;
@@ -62,4 +64,59 @@ export declare function shouldNormalizeVoiceNote(media: WaMediaOptions | undefin
 export declare function hasMediaProcessingTasks(media: WaMediaOptions | undefined, content: WaSendMediaMessage): boolean;
 export declare function getScopedMediaLogger(parent: Logger): Logger;
 export declare function runMediaProcessor(media: WaMediaOptions | undefined, input: Uint8Array | string | undefined, content: WaSendMediaMessage, logger: Logger): Promise<ProcessedMediaFields>;
+export interface WaDownloadMediaMessageOptions extends WaDownloadMediaOptions {
+    /**
+     * Reuse an existing transfer client instead of creating a fresh one. Lets
+     * the download inherit proxy agents, timeouts, and the MAC-verification
+     * toggle, and avoids spinning up a new HTTP client per call in a loop. A
+     * stateless {@link WaMediaTransferClient} is created when omitted - fine
+     * for one-off downloads.
+     */
+    readonly transfer?: WaMediaTransferClient;
+    /**
+     * Proxy for the CDN download leg, mirroring `proxy.mediaDownload` on the
+     * client. The fetch runs over `node:http`/`node:https`, so only the Node
+     * `http.Agent` form is used; an undici dispatcher is ignored (same as the
+     * client treats `mediaDownload`). Takes precedence over the default agent
+     * of a `transfer` you pass.
+     */
+    readonly proxy?: WaProxyTransport;
+}
+/**
+ * Streams and decrypts the media attached to a message without a connected
+ * `WaClient`. Resolves the encrypted payload (directPath, mediaKey, file
+ * hashes) from `source`, fetches the ciphertext from the WhatsApp media CDN,
+ * and decrypts it on the fly.
+ *
+ * The media keys come from the (already decrypted) message itself, so this is
+ * for re-downloading media you have persisted - not for fetching media you
+ * never received. The CDN download needs no session or auth token; only the
+ * upload path does.
+ *
+ * **The caller owns the returned stream** - pipe it somewhere or call
+ * `.destroy()` to release the socket; an unconsumed stream leaks the
+ * connection. MAC + SHA-256 verification runs as bytes are consumed, so
+ * aborting mid-read leaves you with unverified bytes. Pass `options.signal`
+ * to cancel cleanly.
+ *
+ * @throws when `source` carries no downloadable media.
+ * @example
+ * ```ts
+ * import { downloadMediaMessage } from '..'
+ * import { createWriteStream } from 'node:fs'
+ *
+ * const stream = await downloadMediaMessage(event)
+ * stream.pipe(createWriteStream('photo.jpg'))
+ * ```
+ * @example
+ * ```ts
+ * // Route the CDN download through an http.Agent-style proxy
+ * import { HttpsProxyAgent } from 'https-proxy-agent'
+ *
+ * const stream = await downloadMediaMessage(event, {
+ *     proxy: new HttpsProxyAgent('http://127.0.0.1:8080')
+ * })
+ * ```
+ */
+export declare function downloadMediaMessage(source: Proto.IMessage | WaIncomingMessageEvent, options?: WaDownloadMediaMessageOptions): Promise<Readable>;
 export {};

package/dist/client/media.js

@@ -14,6 +14,7 @@ exports.shouldNormalizeVoiceNote = shouldNormalizeVoiceNote;
 exports.hasMediaProcessingTasks = hasMediaProcessingTasks;
 exports.getScopedMediaLogger = getScopedMediaLogger;
 exports.runMediaProcessor = runMediaProcessor;
+exports.downloadMediaMessage = downloadMediaMessage;
 const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
 const promises_1 = require("node:fs/promises");
@@ -22,6 +23,9 @@ const node_path_1 = require("node:path");
 const node_stream_1 = require("node:stream");
 const promises_2 = require("node:stream/promises");
 const core_1 = require("../crypto/core");
+const WaMediaTransferClient_1 = require("../media/transfer/WaMediaTransferClient");
+const media_payload_1 = require("../message/encode/media-payload");
+const proxy_1 = require("../transport/proxy");
 const bytes_1 = require("../util/bytes");
 const primitives_1 = require("../util/primitives");
 async function readFileHead(filePath, bytes) {
@@ -398,3 +402,59 @@ async function runMediaProcessor(media, input, content, logger) {
     }
     return result;
 }
+/**
+ * Streams and decrypts the media attached to a message without a connected
+ * `WaClient`. Resolves the encrypted payload (directPath, mediaKey, file
+ * hashes) from `source`, fetches the ciphertext from the WhatsApp media CDN,
+ * and decrypts it on the fly.
+ *
+ * The media keys come from the (already decrypted) message itself, so this is
+ * for re-downloading media you have persisted - not for fetching media you
+ * never received. The CDN download needs no session or auth token; only the
+ * upload path does.
+ *
+ * **The caller owns the returned stream** - pipe it somewhere or call
+ * `.destroy()` to release the socket; an unconsumed stream leaks the
+ * connection. MAC + SHA-256 verification runs as bytes are consumed, so
+ * aborting mid-read leaves you with unverified bytes. Pass `options.signal`
+ * to cancel cleanly.
+ *
+ * @throws when `source` carries no downloadable media.
+ * @example
+ * ```ts
+ * import { downloadMediaMessage } from '..'
+ * import { createWriteStream } from 'node:fs'
+ *
+ * const stream = await downloadMediaMessage(event)
+ * stream.pipe(createWriteStream('photo.jpg'))
+ * ```
+ * @example
+ * ```ts
+ * // Route the CDN download through an http.Agent-style proxy
+ * import { HttpsProxyAgent } from 'https-proxy-agent'
+ *
+ * const stream = await downloadMediaMessage(event, {
+ *     proxy: new HttpsProxyAgent('http://127.0.0.1:8080')
+ * })
+ * ```
+ */
+async function downloadMediaMessage(source, options = {}) {
+    const message = 'rawNode' in source ? source.message : source;
+    const payload = (0, media_payload_1.resolveMediaPayload)(message);
+    if (!payload) {
+        throw new Error('message has no downloadable media');
+    }
+    const transfer = options.transfer ?? new WaMediaTransferClient_1.WaMediaTransferClient();
+    const { plaintext } = await transfer.downloadAndDecryptStream({
+        directPath: payload.directPath,
+        mediaType: payload.mediaType,
+        mediaKey: payload.mediaKey,
+        fileSha256: payload.fileSha256,
+        fileEncSha256: payload.fileEncSha256,
+        agent: (0, proxy_1.toProxyAgent)(options.proxy),
+        timeoutMs: options.timeoutMs,
+        signal: options.signal,
+        maxBytes: options.maxBytes
+    });
+    return plaintext;
+}

package/dist/client/messaging/ignore-key.js

@@ -88,12 +88,14 @@ function extractIgnoreKeyContext(node, meJid) {
     const me = tryParseJid(meJid);
     const fromCandidates = collectFromCandidates(kind, a);
     const fromMe = me !== null && fromCandidates.some((f) => tryParseJid(f)?.address.user === me.address.user);
+    // Device-stripped to match the JID form used by events/keys; a userless
+    // server `from` like `s.whatsapp.net` is unparseable, so fall back to raw.
     return {
         kind,
-        remoteJid: a.from ?? null,
+        remoteJid: tryParseJid(a.from)?.userJid ?? a.from ?? null,
         fromMe,
         id: a.id,
-        participant: a.participant ?? null
+        participant: tryParseJid(a.participant)?.userJid ?? a.participant ?? null
     };
 }
 /** Pure matcher. Exported for direct testing without a coordinator. */

package/dist/{types/client → client}/types.d.ts

@@ -423,27 +423,30 @@ export interface WaIgnoreKey {
  * Lib derives `kind` from the stanza tag and resolves `fromMe` by comparing
  * every from-candidate (`from`, `sender_pn`, `sender_lid`) against `meJid`.
  *
- * `remoteJid` and `participant` expose the **raw** `from` / `participant`
- * attrs verbatim and do NOT include the descriptor-style alt-attr lookups
- * (`sender_pn` / `sender_lid` / `participant_pn` / `participant_lid`) or
- * PN↔LID normalization. If the predicate needs to match by user identity
- * regardless of addressing mode, run the raw JID through `parseJidFull` and
- * compare on `userJid`, or use the descriptor form which handles it.
+ * `remoteJid` and `participant` are the `from` / `participant` attrs with the
+ * `:device` segment stripped (bare `user@server`), matching the JID form used
+ * by message events and keys. A value that does not parse as a JID (e.g. a
+ * userless server `from` like `s.whatsapp.net`) is passed through unchanged.
+ * They do NOT include the descriptor-style
+ * alt-attr lookups (`sender_pn` / `sender_lid` / `participant_pn` /
+ * `participant_lid`) or PN↔LID normalization, so they stay in whichever
+ * addressing mode the stanza arrived in. To match by user identity regardless
+ * of addressing mode, use the descriptor form, which handles it.
  */
 export interface WaIgnoreKeyContext {
     readonly kind: WaIgnoreStanzaKind;
-    /** Raw `from` attr (group JID for groups, PN or LID device JID for 1:1). */
+    /** `from` attr without `:device` (group JID for groups, PN or LID user JID for 1:1). */
     readonly remoteJid: string | null;
     readonly fromMe: boolean;
     readonly id: string | undefined;
-    /** Raw `participant` attr; `null` for non-group stanzas. */
+    /** `participant` attr without `:device`; `null` for non-group stanzas. */
     readonly participant: string | null;
 }
 /**
  * Predicate form of {@link WaClient.ignoreKey}. Return `true` to drop the
  * stanza, `false` to let it through. Receives a {@link WaIgnoreKeyContext}
- * with the raw `from`/`participant` attrs (see the context's JSDoc for the
- * PN↔LID caveat) plus lib-resolved `kind` and `fromMe`.
+ * with the device-stripped `from`/`participant` (see the context's JSDoc for
+ * the addressing-mode caveat) plus lib-resolved `kind` and `fromMe`.
  */
 export type WaIgnoreKeyPredicate = (ctx: WaIgnoreKeyContext) => boolean;
 export interface WaIncomingBaseEvent {
@@ -512,6 +515,13 @@ export interface WaIncomingReceiptEvent extends WaIncomingBaseEvent {
     readonly fromSelfDevice: boolean;
     readonly participantJid?: string;
     readonly recipientJid?: string;
+    /**
+     * All message ids this receipt acknowledges. For batch read/delivery
+     * receipts this is the `<list><item>` ids plus the top-level `stanzaId`;
+     * for single receipts it is just `[stanzaId]`. Mirrors WhatsApp Web's
+     * `externalIds`.
+     */
+    readonly messageIds: readonly string[];
 }
 export interface WaIncomingPresenceEvent extends WaIncomingBaseEvent {
     readonly type: IncomingPresenceType;

package/dist/esm/appstate-spec.js

@@ -1,6 +1,6 @@
 import { proto } from './proto.js';
-import { WA_APPSTATE_SCHEMAS as RAW_WA_APPSTATE_SCHEMAS } from '../spec/appstate';
-export { WA_APPSTATE_COLLECTIONS, WA_APPSTATE_SCHEMAS } from '../spec/appstate';
+import { WA_APPSTATE_SCHEMAS as RAW_WA_APPSTATE_SCHEMAS } from '../../spec/appstate/index.js';
+export { WA_APPSTATE_COLLECTIONS, WA_APPSTATE_SCHEMAS } from '../../spec/appstate/index.js';
 const SCHEMA_BY_ACTION_NAME_BUILDER = {};
 for (const key of Object.keys(RAW_WA_APPSTATE_SCHEMAS)) {
     SCHEMA_BY_ACTION_NAME_BUILDER[RAW_WA_APPSTATE_SCHEMAS[key].name] = key;

package/dist/esm/auth/pairing/WaPairingFlow.js

@@ -8,6 +8,7 @@ import { ADV_PREFIX_HOSTED_ACCOUNT_SIGNATURE, computeAdvIdentityHmac, generateDe
 import { buildAckNode, buildIqResultNode } from '../../transport/node/builders/global.js';
 import { buildCompanionFinishRequestNode, buildCompanionHelloRequestNode, buildGetCountryCodeRequestNode } from '../../transport/node/builders/pairing.js';
 import { decodeNodeContentUtf8OrBytes, findNodeChild, findNodeChildrenByTags, getFirstNodeChild, getNodeChildrenNonEmptyUtf8ByTag, hasNodeChild } from '../../transport/node/helpers.js';
+import { assertIqResult } from '../../transport/node/query.js';
 import { concatBytes, decodeProtoBytes, uint8Equal, uint8TimingSafeEqual } from '../../util/bytes.js';
 export class WaPairingFlow {
     constructor(options) {
@@ -46,6 +47,7 @@ export class WaPairingFlow {
             responseTag: response.tag,
             responseType: response.attrs.type
         });
+        assertIqResult(response, 'companion hello');
         const linkCodeNode = findNodeChild(response, WA_NODE_TAGS.LINK_CODE_COMPANION_REG);
         if (!linkCodeNode) {
             throw new Error('companion hello response missing link_code_companion_reg');

package/dist/esm/client/WaClient.js

@@ -255,10 +255,28 @@ export class WaClient extends EventEmitter {
                 return;
             }
             if (protocolType === proto.Message.ProtocolMessage.Type.HISTORY_SYNC_NOTIFICATION) {
-                if (this.options.history?.enabled !== false &&
-                    protocolMessage.historySyncNotification) {
-                    const peerRemoteJid = event.key.remoteJid;
-                    const peerStanzaId = event.key.id;
+                if (!protocolMessage.historySyncNotification) {
+                    return;
+                }
+                const peerRemoteJid = event.key.remoteJid;
+                const peerStanzaId = event.key.id;
+                const sendHistSyncReceipt = peerRemoteJid && peerStanzaId
+                    ? async () => {
+                        try {
+                            await this.message.sendReceipt(peerRemoteJid, peerStanzaId, {
+                                type: WA_MESSAGE_TYPES.RECEIPT_TYPE_HISTORY_SYNC
+                            });
+                        }
+                        catch (err) {
+                            this.logger.warn('failed to send hist_sync receipt', {
+                                id: peerStanzaId,
+                                to: peerRemoteJid,
+                                message: toError(err).message
+                            });
+                        }
+                    }
+                    : undefined;
+                if (this.options.history?.enabled !== false) {
                     await runHistorySyncNotification({
                         logger: this.logger,
                         mediaTransfer: this.mediaTransfer,
@@ -266,24 +284,12 @@ export class WaClient extends EventEmitter {
                         emitEvent: this.emit.bind(this),
                         onPrivacyTokens: (conversations) => this.deps.trustedContactToken.hydrateFromHistorySync(conversations),
                         onNctSalt: (salt) => this.deps.trustedContactToken.hydrateNctSaltFromHistorySync(salt),
-                        onProcessed: peerRemoteJid && peerStanzaId
-                            ? async () => {
-                                try {
-                                    await this.message.sendReceipt(peerRemoteJid, peerStanzaId, {
-                                        type: WA_MESSAGE_TYPES.RECEIPT_TYPE_HISTORY_SYNC
-                                    });
-                                }
-                                catch (err) {
-                                    this.logger.warn('failed to send hist_sync receipt', {
-                                        id: peerStanzaId,
-                                        to: peerRemoteJid,
-                                        message: toError(err).message
-                                    });
-                                }
-                            }
-                            : undefined
+                        onProcessed: sendHistSyncReceipt
                     }, protocolMessage.historySyncNotification);
                 }
+                else if (sendHistSyncReceipt) {
+                    await sendHistSyncReceipt();
+                }
                 return;
             }
             if (SYNC_RELATED_PROTOCOL_TYPES.has(protocolType)) {

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

@@ -388,7 +388,7 @@ export class WaIncomingNodeCoordinator {
                 try {
                     const routingInfo = decodeNodeContentBase64OrBytes(routingInfoNode.content, `ib.${WA_NODE_TAGS.EDGE_ROUTING}.${WA_NODE_TAGS.ROUTING_INFO}`);
                     await this.runtime.persistRoutingInfo(routingInfo);
-                    this.logger.info('updated routing info from info bulletin', {
+                    this.logger.debug('updated routing info from info bulletin', {
                         byteLength: routingInfo.byteLength
                     });
                 }