zapo-js 1.7.0 → 1.7.1

package/dist/client/messaging/messages.js

@@ -105,19 +105,23 @@ function buildPollCreationMessage(content) {
     const options = content.options.map((opt) => ({
         optionName: typeof opt === 'string' ? opt : opt.name
     }));
-    return {
-        pollCreationMessageV3: {
-            name: content.name,
-            options,
-            selectableOptionsCount: content.selectableCount ?? 1,
-            ...(content.allowAddOption !== undefined
-                ? { allowAddOption: content.allowAddOption }
-                : {}),
-            ...(content.hideParticipantName !== undefined
-                ? { hideParticipantName: content.hideParticipantName }
-                : {})
-        }
+    const selectableOptionsCount = content.selectableCount ?? 1;
+    const allowAddOption = content.allowAddOption === true;
+    const hideParticipantName = content.hideParticipantName === true;
+    const pollBody = {
+        name: content.name,
+        options,
+        selectableOptionsCount,
+        ...(allowAddOption ? { allowAddOption: true } : {}),
+        ...(hideParticipantName ? { hideParticipantName: true } : {})
     };
+    if (allowAddOption || hideParticipantName) {
+        return { pollCreationMessageV6: pollBody };
+    }
+    if (selectableOptionsCount === 1) {
+        return { pollCreationMessageV3: pollBody };
+    }
+    return { pollCreationMessage: pollBody };
 }
 function buildEventMessage(content) {
     const eventMessage = {

package/dist/client/newsletter/discovery.js

@@ -17,7 +17,8 @@ function createDiscoveryOps(deps) {
             fetch_full_image: opts?.fetchFullImage ?? keyType !== 'INVITE',
             fetch_creation_time: opts?.fetchCreationTime ?? true,
             fetch_wamo_sub: opts?.fetchWamoSub ?? false,
-            fetch_status_metadata: false
+            fetch_status_metadata: false,
+            fetch_pinned_messages: true
         });
         if (!data?.xwa2_newsletter) {
             throw new Error('newsletter fetch returned no envelope');
@@ -107,7 +108,8 @@ function createDiscoveryOps(deps) {
                     type: isJid ? 'JID' : 'INVITE',
                     view_role: opts?.viewRole ?? newsletter_1.WA_NEWSLETTER_VIEW_ROLES.SUBSCRIBER
                 },
-                fetch_wamo_sub: opts?.fetchWamoSub ?? false
+                fetch_wamo_sub: opts?.fetchWamoSub ?? false,
+                fetch_pinned_messages: true
             });
             return (0, parse_1.parseDehydratedMetadata)(data);
         }

package/dist/client/persistence/history-sync.d.ts

@@ -4,6 +4,24 @@ import type { Logger } from '../../infra/log/types';
 import type { WaMediaTransferClient } from '../../media/transfer/WaMediaTransferClient';
 import { type Proto } from '../../proto';
 import type { WaChatMetadataStore } from '../../store/contracts/chat-metadata.store';
+interface ByteRange {
+    readonly start: number;
+    readonly end: number;
+}
+interface HistorySyncScan {
+    readonly conversationRanges: readonly ByteRange[];
+    readonly pushnames: readonly Proto.IPushname[];
+    readonly inlineContacts: readonly Proto.IInlineContact[];
+    readonly phoneNumberToLidMappings: readonly Proto.IPhoneNumberToLIDMapping[];
+    readonly nctSalt: Uint8Array | null;
+    readonly chunkOrder: number | null;
+    readonly progress: number | null;
+}
+export declare function scanHistorySyncBlob(bytes: Uint8Array): HistorySyncScan;
+export declare function scanConversationJidPair(bytes: Uint8Array, range: ByteRange): {
+    readonly pnJid: string | null;
+    readonly lidJid: string | null;
+};
 interface WaHistorySyncDeps {
     readonly logger: Logger;
     readonly mediaTransfer: WaMediaTransferClient;

package/dist/client/persistence/history-sync.js

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanHistorySyncBlob = scanHistorySyncBlob;
+exports.scanConversationJidPair = scanConversationJidPair;
 exports.runHistorySyncNotification = runHistorySyncNotification;
 exports.processHistorySyncNotification = processHistorySyncNotification;
 const node_util_1 = require("node:util");
@@ -10,6 +12,7 @@ const jid_1 = require("../../protocol/jid");
 const message_1 = require("../../protocol/message");
 const bytes_1 = require("../../util/bytes");
 const primitives_1 = require("../../util/primitives");
+const protoscan_1 = require("../../util/protoscan");
 const unzipAsync = (0, node_util_1.promisify)(node_zlib_1.unzip);
 const HANDLED_SYNC_TYPES = new Set([
     _proto_1.proto.Message.HistorySyncType.INITIAL_BOOTSTRAP,
@@ -20,6 +23,90 @@ const HANDLED_SYNC_TYPES = new Set([
     _proto_1.proto.Message.HistorySyncType.NON_BLOCKING_DATA
 ]);
 const HISTORY_SYNC_MAX_PENDING_WRITES = 1024;
+const HISTORY_SYNC_FIELDS = Object.freeze({
+    CONVERSATIONS: 2,
+    CHUNK_ORDER: 5,
+    PROGRESS: 6,
+    PUSHNAMES: 7,
+    PHONE_NUMBER_TO_LID_MAPPINGS: 15,
+    NCT_SALT: 19,
+    INLINE_CONTACTS: 20
+});
+const CONVERSATION_JID_FIELDS = Object.freeze({
+    PN_JID: 39,
+    LID_JID: 42,
+    ACCOUNT_LID: 49
+});
+function scanHistorySyncBlob(bytes) {
+    const conversationRanges = [];
+    const pushnames = [];
+    const inlineContacts = [];
+    const phoneNumberToLidMappings = [];
+    let nctSalt = null;
+    let chunkOrder = null;
+    let progress = null;
+    (0, protoscan_1.scanProtoFields)(bytes, 0, bytes.length, (field) => {
+        if (field.wireType === protoscan_1.PROTO_WIRE_TYPES.LEN) {
+            if (field.fieldNumber === HISTORY_SYNC_FIELDS.CONVERSATIONS) {
+                conversationRanges[conversationRanges.length] = {
+                    start: field.valueStart,
+                    end: field.valueEnd
+                };
+            }
+            else if (field.fieldNumber === HISTORY_SYNC_FIELDS.PUSHNAMES) {
+                pushnames[pushnames.length] = _proto_1.proto.Pushname.decode(bytes.subarray(field.valueStart, field.valueEnd));
+            }
+            else if (field.fieldNumber === HISTORY_SYNC_FIELDS.PHONE_NUMBER_TO_LID_MAPPINGS) {
+                phoneNumberToLidMappings[phoneNumberToLidMappings.length] =
+                    _proto_1.proto.PhoneNumberToLIDMapping.decode(bytes.subarray(field.valueStart, field.valueEnd));
+            }
+            else if (field.fieldNumber === HISTORY_SYNC_FIELDS.INLINE_CONTACTS) {
+                inlineContacts[inlineContacts.length] = _proto_1.proto.InlineContact.decode(bytes.subarray(field.valueStart, field.valueEnd));
+            }
+            else if (field.fieldNumber === HISTORY_SYNC_FIELDS.NCT_SALT) {
+                nctSalt = bytes.slice(field.valueStart, field.valueEnd);
+            }
+            return;
+        }
+        if (field.wireType === protoscan_1.PROTO_WIRE_TYPES.VARINT) {
+            if (field.fieldNumber === HISTORY_SYNC_FIELDS.CHUNK_ORDER) {
+                chunkOrder = field.varintValue;
+            }
+            else if (field.fieldNumber === HISTORY_SYNC_FIELDS.PROGRESS) {
+                progress = field.varintValue;
+            }
+        }
+    });
+    return {
+        conversationRanges,
+        pushnames,
+        inlineContacts,
+        phoneNumberToLidMappings,
+        nctSalt,
+        chunkOrder,
+        progress
+    };
+}
+function scanConversationJidPair(bytes, range) {
+    let pnJid = null;
+    let lidJid = null;
+    let accountLid = null;
+    (0, protoscan_1.scanProtoFields)(bytes, range.start, range.end, (field) => {
+        if (field.wireType !== protoscan_1.PROTO_WIRE_TYPES.LEN) {
+            return;
+        }
+        if (field.fieldNumber === CONVERSATION_JID_FIELDS.PN_JID) {
+            pnJid = bytes_1.TEXT_DECODER.decode(bytes.subarray(field.valueStart, field.valueEnd));
+        }
+        else if (field.fieldNumber === CONVERSATION_JID_FIELDS.LID_JID) {
+            lidJid = bytes_1.TEXT_DECODER.decode(bytes.subarray(field.valueStart, field.valueEnd));
+        }
+        else if (field.fieldNumber === CONVERSATION_JID_FIELDS.ACCOUNT_LID) {
+            accountLid = bytes_1.TEXT_DECODER.decode(bytes.subarray(field.valueStart, field.valueEnd));
+        }
+    });
+    return { pnJid, lidJid: lidJid ?? accountLid };
+}
 async function runHistorySyncNotification(deps, notification) {
     try {
         await processHistorySyncNotification(deps, notification);
@@ -49,14 +136,17 @@ async function processHistorySyncNotification(deps, notification) {
     }
     const blob = await downloadHistorySyncBlob(deps, notification);
     const decompressed = (0, bytes_1.toBytesView)(await unzipAsync(blob));
-    const historySync = _proto_1.proto.HistorySync.decode(decompressed);
+    // Conversations are decoded one record at a time in the loop below so the
+    // full message graph never coexists in memory; the scan only records their
+    // byte ranges and decodes the small metadata fields.
+    const scan = scanHistorySyncBlob(decompressed);
     deps.logger.info('decoded history sync chunk', {
         syncType,
-        chunkOrder: historySync.chunkOrder,
-        progress: historySync.progress,
-        conversations: historySync.conversations.length,
-        pushnames: historySync.pushnames.length,
-        inlineContacts: historySync.inlineContacts?.length ?? 0
+        chunkOrder: scan.chunkOrder,
+        progress: scan.progress,
+        conversations: scan.conversationRanges.length,
+        pushnames: scan.pushnames.length,
+        inlineContacts: scan.inlineContacts.length
     });
     const nowMs = Date.now();
     const pendingWrites = [];
@@ -65,24 +155,23 @@ async function processHistorySyncNotification(deps, notification) {
     // pushnames and mappings land on a single canonical (LID-form) contact
     // row instead of two mirror rows (one keyed by PN, one keyed by LID).
     const pnToLid = new Map();
-    for (const map of historySync.phoneNumberToLidMappings ?? []) {
+    for (const map of scan.phoneNumberToLidMappings) {
         if (map.pnJid && map.lidJid) {
             pnToLid.set(map.pnJid, map.lidJid);
         }
     }
-    for (const c of historySync.inlineContacts ?? []) {
+    for (const c of scan.inlineContacts) {
         if (c.pnJid && c.lidJid) {
             pnToLid.set(c.pnJid, c.lidJid);
         }
     }
-    for (const conversation of historySync.conversations) {
-        const pnJid = conversation.pnJid;
-        const lidJid = conversation.lidJid ?? conversation.accountLid;
-        if (pnJid && lidJid) {
-            pnToLid.set(pnJid, lidJid);
+    for (const range of scan.conversationRanges) {
+        const pair = scanConversationJidPair(decompressed, range);
+        if (pair.pnJid && pair.lidJid) {
+            pnToLid.set(pair.pnJid, pair.lidJid);
         }
     }
-    for (const pn of historySync.pushnames) {
+    for (const pn of scan.pushnames) {
         if (!pn.id) {
             continue;
         }
@@ -103,7 +192,7 @@ async function processHistorySyncNotification(deps, notification) {
             await (0, history_blob_1.flushPendingWrites)(pendingWrites);
         }
     }
-    for (const c of historySync.inlineContacts ?? []) {
+    for (const c of scan.inlineContacts) {
         const jid = c.lidJid ?? c.pnJid;
         if (!jid) {
             continue;
@@ -123,12 +212,32 @@ async function processHistorySyncNotification(deps, notification) {
         }
     }
     let messagesCount = 0;
-    for (const conversation of historySync.conversations) {
+    const tokenConversations = [];
+    for (const range of scan.conversationRanges) {
+        let conversation;
+        try {
+            conversation = _proto_1.proto.Conversation.decode(decompressed.subarray(range.start, range.end));
+        }
+        catch (error) {
+            await Promise.allSettled(pendingWrites);
+            throw (0, primitives_1.toError)(error);
+        }
         const threadJid = conversation.id;
         if (!threadJid) {
             deps.logger.debug('skipping history sync conversation without thread jid');
             continue;
         }
+        if (deps.onPrivacyTokens &&
+            (conversation.tcToken ||
+                conversation.tcTokenTimestamp ||
+                conversation.tcTokenSenderTimestamp)) {
+            tokenConversations[tokenConversations.length] = {
+                jid: threadJid,
+                tcToken: conversation.tcToken ? new Uint8Array(conversation.tcToken) : undefined,
+                tcTokenTimestamp: (0, primitives_1.longToNumber)(conversation.tcTokenTimestamp) || undefined,
+                tcTokenSenderTimestamp: (0, primitives_1.longToNumber)(conversation.tcTokenSenderTimestamp) || undefined
+            };
+        }
         const ephemeralExpiration = conversation.ephemeralExpiration ?? undefined;
         const ephemeralSettingTimestamp = (0, message_1.normalizeEphemeralSettingSeconds)((0, primitives_1.longToNumber)(conversation.ephemeralSettingTimestamp)) || undefined;
         if (deps.chatMetadataStore && ephemeralExpiration !== undefined) {
@@ -216,37 +325,20 @@ async function processHistorySyncNotification(deps, notification) {
             await (0, history_blob_1.flushPendingWrites)(pendingWrites);
         }
     }
-    if (deps.onPrivacyTokens) {
-        const tokenConversations = [];
-        for (const conversation of historySync.conversations) {
-            if (!conversation.id)
-                continue;
-            if (conversation.tcToken ||
-                conversation.tcTokenTimestamp ||
-                conversation.tcTokenSenderTimestamp) {
-                tokenConversations[tokenConversations.length] = {
-                    jid: conversation.id,
-                    tcToken: conversation.tcToken,
-                    tcTokenTimestamp: (0, primitives_1.longToNumber)(conversation.tcTokenTimestamp) || undefined,
-                    tcTokenSenderTimestamp: (0, primitives_1.longToNumber)(conversation.tcTokenSenderTimestamp) || undefined
-                };
-            }
-        }
-        if (tokenConversations.length > 0) {
-            pendingWrites[pendingWrites.length] = deps.onPrivacyTokens(tokenConversations);
-        }
+    if (deps.onPrivacyTokens && tokenConversations.length > 0) {
+        pendingWrites[pendingWrites.length] = deps.onPrivacyTokens(tokenConversations);
     }
-    if (deps.onNctSalt && historySync.nctSalt) {
-        pendingWrites[pendingWrites.length] = deps.onNctSalt(historySync.nctSalt);
+    if (deps.onNctSalt && scan.nctSalt) {
+        pendingWrites[pendingWrites.length] = deps.onNctSalt(scan.nctSalt);
     }
     const event = {
         syncType,
         messagesCount,
-        conversationsCount: historySync.conversations.length,
-        pushnamesCount: historySync.pushnames.length,
-        inlineContactsCount: historySync.inlineContacts?.length ?? 0,
-        chunkOrder: historySync.chunkOrder ?? undefined,
-        progress: historySync.progress ?? undefined
+        conversationsCount: scan.conversationRanges.length,
+        pushnamesCount: scan.pushnames.length,
+        inlineContactsCount: scan.inlineContacts.length,
+        chunkOrder: scan.chunkOrder ?? undefined,
+        progress: scan.progress ?? undefined
     };
     await (0, history_blob_1.flushPendingWrites)(pendingWrites);
     deps.emitEvent('history_sync_chunk', event);

package/dist/client/plugins/types.d.ts

@@ -63,10 +63,18 @@ type ExposedOf<P> = P extends {
  * `{ readonly voip: WaVoipCoordinator }`.
  */
 export type WaClientExposedFromPlugins<P extends readonly unknown[]> = UnionToIntersection<ExposedOf<P[number]>>;
-/** Event map a plugin contributes, carried as a phantom marker on its definition. */
+/**
+ * Event map a plugin contributes, carried as a phantom marker on its definition.
+ *
+ * The marker is optional (it never exists at runtime), so under
+ * `exactOptionalPropertyTypes` the inferred `E` keeps the `| undefined` the
+ * declaration emits. `Exclude` drops it before the union reaches
+ * {@link UnionToIntersection}, which would otherwise collapse
+ * `Events | undefined` to `never` and type every client listener as `never`.
+ */
 type EventsOf<P> = P extends {
     readonly __pluginEvents?: infer E;
-} ? unknown extends E ? {} : E : {};
+} ? unknown extends E ? {} : Exclude<E, undefined> : {};
 /**
  * Client events contributed by a tuple of plugin definitions, derived from the
  * plugin values (no global augmentation). Threaded into the client's

package/dist/crypto/core/index.d.ts

@@ -7,5 +7,5 @@ export { hkdf, hkdfSplit } from '../core/hkdf';
 export { toSerializedPubKey, toRawPubKey, prependVersion, readVersionedContent } from '../core/keys';
 export { writeNonceCounter } from '../core/nonce';
 export { randomBytesAsync, randomFillAsync, randomIntAsync } from '../core/random';
-export { sha1, sha256, sha512, md5Bytes, aesGcmEncrypt, aesGcmDecrypt, aesCbcEncrypt, aesCbcDecrypt, aesCtrEncrypt, aesCtrDecrypt, hmacSha256Sign, hmacSha512Sign, pbkdf2Sha256 } from '../core/primitives';
+export { sha1, sha256, sha512, md5Bytes, aesGcmEncrypt, aesGcmDecrypt, aesCbcEncrypt, aesCbcEncryptWithTrailer, aesCbcDecrypt, aesCtrEncrypt, aesCtrDecrypt, hmacSha256Sign, hmacSha512Sign, pbkdf2Sha256 } from '../core/primitives';
 export { xeddsaSign, xeddsaVerify } from '../core/xeddsa';

package/dist/crypto/core/index.js

@@ -3,7 +3,7 @@
  * Cryptographic utilities
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.xeddsaVerify = exports.xeddsaSign = exports.pbkdf2Sha256 = exports.hmacSha512Sign = exports.hmacSha256Sign = exports.aesCtrDecrypt = exports.aesCtrEncrypt = exports.aesCbcDecrypt = exports.aesCbcEncrypt = exports.aesGcmDecrypt = exports.aesGcmEncrypt = exports.md5Bytes = exports.sha512 = exports.sha256 = exports.sha1 = exports.randomIntAsync = exports.randomFillAsync = exports.randomBytesAsync = exports.writeNonceCounter = exports.readVersionedContent = exports.prependVersion = exports.toRawPubKey = exports.toSerializedPubKey = exports.hkdfSplit = exports.hkdf = exports.X25519 = exports.Ed25519 = void 0;
+exports.xeddsaVerify = exports.xeddsaSign = exports.pbkdf2Sha256 = exports.hmacSha512Sign = exports.hmacSha256Sign = exports.aesCtrDecrypt = exports.aesCtrEncrypt = exports.aesCbcDecrypt = exports.aesCbcEncryptWithTrailer = exports.aesCbcEncrypt = exports.aesGcmDecrypt = exports.aesGcmEncrypt = exports.md5Bytes = exports.sha512 = exports.sha256 = exports.sha1 = exports.randomIntAsync = exports.randomFillAsync = exports.randomBytesAsync = exports.writeNonceCounter = exports.readVersionedContent = exports.prependVersion = exports.toRawPubKey = exports.toSerializedPubKey = exports.hkdfSplit = exports.hkdf = exports.X25519 = exports.Ed25519 = void 0;
 var Ed25519_1 = require("../curves/Ed25519");
 Object.defineProperty(exports, "Ed25519", { enumerable: true, get: function () { return Ed25519_1.Ed25519; } });
 var X25519_1 = require("../curves/X25519");
@@ -30,6 +30,7 @@ Object.defineProperty(exports, "md5Bytes", { enumerable: true, get: function ()
 Object.defineProperty(exports, "aesGcmEncrypt", { enumerable: true, get: function () { return primitives_1.aesGcmEncrypt; } });
 Object.defineProperty(exports, "aesGcmDecrypt", { enumerable: true, get: function () { return primitives_1.aesGcmDecrypt; } });
 Object.defineProperty(exports, "aesCbcEncrypt", { enumerable: true, get: function () { return primitives_1.aesCbcEncrypt; } });
+Object.defineProperty(exports, "aesCbcEncryptWithTrailer", { enumerable: true, get: function () { return primitives_1.aesCbcEncryptWithTrailer; } });
 Object.defineProperty(exports, "aesCbcDecrypt", { enumerable: true, get: function () { return primitives_1.aesCbcDecrypt; } });
 Object.defineProperty(exports, "aesCtrEncrypt", { enumerable: true, get: function () { return primitives_1.aesCtrEncrypt; } });
 Object.defineProperty(exports, "aesCtrDecrypt", { enumerable: true, get: function () { return primitives_1.aesCtrDecrypt; } });

package/dist/crypto/core/primitives.d.ts

@@ -21,6 +21,25 @@ export declare function aesGcmEncrypt(key: AesKey, nonce: Uint8Array, plaintext:
 export declare function aesGcmDecrypt(key: AesKey, nonce: Uint8Array, ciphertext: Uint8Array, aad?: Uint8Array): Uint8Array;
 /** AES-256-CBC encrypt with PKCS#7 padding (default Node behavior). */
 export declare function aesCbcEncrypt(key: Uint8Array, iv: Uint8Array, plaintext: Uint8Array): Uint8Array;
+/**
+ * AES-256-CBC encrypt into a buffer that reserves `trailerBytes` of spare room
+ * after the ciphertext, for a caller that has to append a MAC to it.
+ *
+ * Appending to the result of {@link aesCbcEncrypt} means copying the whole
+ * ciphertext a second time, which on a media payload is a copy of the entire
+ * file to make room for ten bytes. Sizing the destination from the PKCS#7
+ * output length up front removes that copy, and feeding the cipher in bounded
+ * chunks keeps the transient buffer Node hands back to a chunk rather than a
+ * second full-size ciphertext, so peak memory stays near one copy of the
+ * payload instead of two.
+ *
+ * The ciphertext occupies `result.length - trailerBytes`; the reserved tail is
+ * left zeroed for the caller to fill.
+ *
+ * @throws when `trailerBytes` is not a non-negative safe integer, or when the
+ * cipher yields a length other than the PKCS#7 size the destination was cut to.
+ */
+export declare function aesCbcEncryptWithTrailer(key: Uint8Array, iv: Uint8Array, plaintext: Uint8Array, trailerBytes: number): Uint8Array;
 /** AES-256-CBC decrypt with PKCS#7 padding. */
 export declare function aesCbcDecrypt(key: Uint8Array, iv: Uint8Array, ciphertext: Uint8Array): Uint8Array;
 /** AES-256-CTR encrypt with the given 16-byte counter. */

package/dist/crypto/core/primitives.js

@@ -7,6 +7,7 @@ exports.md5Bytes = md5Bytes;
 exports.aesGcmEncrypt = aesGcmEncrypt;
 exports.aesGcmDecrypt = aesGcmDecrypt;
 exports.aesCbcEncrypt = aesCbcEncrypt;
+exports.aesCbcEncryptWithTrailer = aesCbcEncryptWithTrailer;
 exports.aesCbcDecrypt = aesCbcDecrypt;
 exports.aesCtrEncrypt = aesCtrEncrypt;
 exports.aesCtrDecrypt = aesCtrDecrypt;
@@ -17,6 +18,9 @@ const node_crypto_1 = require("node:crypto");
 const node_util_1 = require("node:util");
 const bytes_1 = require("../../util/bytes");
 const AES_GCM_TAG_LENGTH = 16;
+const AES_CBC_BLOCK_SIZE = 16;
+/** Bounds the transient buffer `cipher.update` returns per call. */
+const AES_CBC_CHUNK_SIZE = 262144;
 const pbkdf2Async = (0, node_util_1.promisify)(node_crypto_1.pbkdf2);
 function feed(target, input) {
     if (Array.isArray(input)) {
@@ -96,6 +100,50 @@ function aesCbcEncrypt(key, iv, plaintext) {
     }
     return (0, bytes_1.concatBytes)([head, tail]);
 }
+/**
+ * AES-256-CBC encrypt into a buffer that reserves `trailerBytes` of spare room
+ * after the ciphertext, for a caller that has to append a MAC to it.
+ *
+ * Appending to the result of {@link aesCbcEncrypt} means copying the whole
+ * ciphertext a second time, which on a media payload is a copy of the entire
+ * file to make room for ten bytes. Sizing the destination from the PKCS#7
+ * output length up front removes that copy, and feeding the cipher in bounded
+ * chunks keeps the transient buffer Node hands back to a chunk rather than a
+ * second full-size ciphertext, so peak memory stays near one copy of the
+ * payload instead of two.
+ *
+ * The ciphertext occupies `result.length - trailerBytes`; the reserved tail is
+ * left zeroed for the caller to fill.
+ *
+ * @throws when `trailerBytes` is not a non-negative safe integer, or when the
+ * cipher yields a length other than the PKCS#7 size the destination was cut to.
+ */
+function aesCbcEncryptWithTrailer(key, iv, plaintext, trailerBytes) {
+    if (!Number.isSafeInteger(trailerBytes) || trailerBytes < 0) {
+        throw new Error(`invalid trailer length ${trailerBytes}`);
+    }
+    const cipherLength = (Math.floor(plaintext.length / AES_CBC_BLOCK_SIZE) + 1) * AES_CBC_BLOCK_SIZE;
+    const out = new Uint8Array(cipherLength + trailerBytes);
+    const cipher = (0, node_crypto_1.createCipheriv)('aes-256-cbc', key, iv);
+    let offset = 0;
+    for (let start = 0; start < plaintext.length; start += AES_CBC_CHUNK_SIZE) {
+        const end = Math.min(start + AES_CBC_CHUNK_SIZE, plaintext.length);
+        const block = cipher.update(plaintext.subarray(start, end));
+        if (block.length > 0) {
+            out.set(block, offset);
+            offset += block.length;
+        }
+    }
+    const tail = cipher.final();
+    if (tail.length > 0) {
+        out.set(tail, offset);
+        offset += tail.length;
+    }
+    if (offset !== cipherLength) {
+        throw new Error(`aes-cbc produced ${offset} bytes, expected ${cipherLength}`);
+    }
+    return out;
+}
 /** AES-256-CBC decrypt with PKCS#7 padding. */
 function aesCbcDecrypt(key, iv, ciphertext) {
     const decipher = (0, node_crypto_1.createDecipheriv)('aes-256-cbc', key, iv);

package/dist/crypto/core/xeddsa.js

@@ -51,6 +51,23 @@ async function xeddsaVerify(curvePublicKey, message, signature) {
         signature[lastByteIndex] = originalLastByte;
     }
 }
+const publicDerivationCache = new WeakMap();
+function derivePublicForSigning(privateKey) {
+    const cached = publicDerivationCache.get(privateKey);
+    if (cached) {
+        return cached;
+    }
+    const clampedPrivateKey = (0, X25519_1.clampCurvePrivateKeyInPlace)(privateKey);
+    const privateScalar = (0, le_1.bytesToBigIntLE)(clampedPrivateKey);
+    const encodedPublic = (0, edwards_1.encodeExtendedPoint)((0, edwards_1.scalarMultBase)(privateScalar));
+    const derivation = {
+        privateScalar,
+        encodedPublic,
+        pubKeySignBit: encodedPublic[31] & 0x80
+    };
+    publicDerivationCache.set(privateKey, derivation);
+    return derivation;
+}
 /**
  * Signs `message` with an X25519 (Montgomery) private key using the XEdDSA
  * construction. Returns a 64-byte signature.
@@ -60,10 +77,8 @@ async function xeddsaSign(privateKey, message) {
     if (nativeBinding) {
         return (0, bytes_1.toBytesView)(nativeBinding.xeddsaSign(privateKey, message));
     }
-    const clampedPrivateKey = (0, X25519_1.clampCurvePrivateKeyInPlace)(privateKey);
-    const privateScalar = (0, le_1.bytesToBigIntLE)(clampedPrivateKey);
-    const encodedPublic = (0, edwards_1.encodeExtendedPoint)((0, edwards_1.scalarMultBase)(privateScalar));
-    const pubKeySignBit = encodedPublic[31] & 0x80;
+    const { privateScalar, encodedPublic, pubKeySignBit } = derivePublicForSigning(privateKey);
+    const clampedPrivateKey = privateKey;
     const randomSuffix = await (0, random_1.randomBytesAsync)(64);
     const r = (0, mod_1.modGroup)((0, le_1.bytesToBigIntLE)((0, primitives_1.sha512)([PREFIX_SIGNATURE_RANDOM, clampedPrivateKey, message, randomSuffix])));
     const encodedR = (0, edwards_1.encodeExtendedPoint)((0, edwards_1.scalarMultBase)(r));

package/dist/crypto/curves/X25519.js

@@ -86,19 +86,33 @@ function montgomeryToEdwardsPublic(curvePublicKey, signBit) {
     encoded[31] = (encoded[31] & 0x7f) | (signBit & 0x80);
     return encoded;
 }
+const privateKeyObjectCache = new WeakMap();
+const publicKeyObjectCache = new WeakMap();
 function x25519PrivateKeyObject(privKey) {
-    return (0, node_crypto_1.createPrivateKey)({
+    const cached = privateKeyObjectCache.get(privKey);
+    if (cached) {
+        return cached;
+    }
+    const keyObject = (0, node_crypto_1.createPrivateKey)({
         key: (0, types_1.pkcs8FromRawPrivate)(constants_1.X25519_PKCS8_PREFIX, privKey),
         format: 'der',
         type: 'pkcs8'
     });
+    privateKeyObjectCache.set(privKey, keyObject);
+    return keyObject;
 }
 function x25519PublicKeyObject(pubKey) {
-    return (0, node_crypto_1.createPublicKey)({
+    const cached = publicKeyObjectCache.get(pubKey);
+    if (cached) {
+        return cached;
+    }
+    const keyObject = (0, node_crypto_1.createPublicKey)({
         key: (0, bytes_1.concatBytes)([constants_1.X25519_SPKI_PREFIX, pubKey]),
         format: 'der',
         type: 'spki'
     });
+    publicKeyObjectCache.set(pubKey, keyObject);
+    return keyObject;
 }
 /**
  * X25519 key-pair generation and Diffie-Hellman scalar multiplication

package/dist/esm/appstate/crypto/WaAppStateCrypto.js

@@ -174,12 +174,10 @@ export class WaAppStateCrypto {
         if (out.byteLength !== left.byteLength) {
             throw new Error('lt hash output length mismatch');
         }
-        const leftView = new DataView(left.buffer, left.byteOffset, left.byteLength);
-        const rightView = new DataView(right.buffer, right.byteOffset, right.byteLength);
-        const outView = new DataView(out.buffer, out.byteOffset, out.byteLength);
         for (let offset = 0; offset < left.byteLength; offset += APP_STATE_POINT_SIZE) {
-            const value = combine(leftView.getUint16(offset, true), rightView.getUint16(offset, true));
-            outView.setUint16(offset, value & 0xffff, true);
+            const value = combine(left[offset] | (left[offset + 1] << 8), right[offset] | (right[offset + 1] << 8));
+            out[offset] = value & 0xff;
+            out[offset + 1] = (value >>> 8) & 0xff;
         }
         return out;
     }
@@ -196,7 +194,7 @@ export class WaAppStateCrypto {
     generateValueMac(valueMacHmacKey, associatedData, iv, cipherText) {
         const octetLength = new Uint8Array(APP_STATE_MAC_OCTET_LENGTH);
         octetLength[octetLength.length - 1] = associatedData.byteLength & 0xff;
-        const full = hmacSha512Sign(valueMacHmacKey, concatBytes([associatedData, iv, cipherText, octetLength]));
+        const full = hmacSha512Sign(valueMacHmacKey, [associatedData, iv, cipherText, octetLength]);
         return full.subarray(0, APP_STATE_VALUE_MAC_LENGTH);
     }
     touchDerivedKeysCacheEntry(cacheKey, keys) {

package/dist/esm/auth/WaAuthClient.js

@@ -20,11 +20,18 @@ export class WaAuthClient {
     constructor(options, deps) {
         this.versionOverride = null;
         this.mobileAppVersionOverride = null;
+        /**
+         * Successful logins made by this instance, advertised as
+         * `connectAttemptCount`. Process-local by design – the persisted
+         * counterpart is `credentials.loginCounter`.
+         */
+        this.connectAttemptCount = 0;
         const device = resolveWaDeviceIdentity(options);
         this.options = Object.freeze({
             ...options,
             deviceBrowser: device.browser,
             deviceOsDisplayName: device.osDisplayName,
+            deviceOsVersion: device.osVersion ?? undefined,
             devicePlatform: device.platform,
             requireFullSync: options.requireFullSync
         });
@@ -122,8 +129,10 @@ export class WaAuthClient {
         const mobileAppVersionOverride = this.mobileAppVersionOverride;
         this.mobileAppVersionOverride = null;
         return buildCommsConfig(this.logger, this.requireCredentials(), socketOptions, {
+            connectAttemptCount: this.connectAttemptCount,
             deviceBrowser: this.options.deviceBrowser,
             deviceOsDisplayName: this.options.deviceOsDisplayName,
+            deviceOsVersion: this.options.deviceOsVersion,
             requireFullSync: this.options.requireFullSync,
             version: override ?? this.options.version,
             mobileTransport: this.options.mobileTransport,
@@ -236,10 +245,19 @@ export class WaAuthClient {
      * Persists the per-connection success attributes from the server (LID,
      * display name, companion key, last-success ts, props versions, ...). Only
      * persists when at least one attribute actually changed.
+     *
+     * Pass `countsAsLogin` only for the server `success` node: it advances the
+     * login counters advertised as `lc` / `connectAttemptCount`. Callers that
+     * merely reuse this to persist a single attribute (a push-name change, for
+     * instance) must leave it unset.
      */
-    async persistSuccessAttributes(attributes) {
+    async persistSuccessAttributes(attributes, { countsAsLogin = false } = {}) {
+        if (countsAsLogin) {
+            this.connectAttemptCount += 1;
+        }
         let persistDiff;
         const computeDiff = (current, next) => ({
+            loginCounterChanged: next.loginCounter !== current.loginCounter,
             lidChanged: next.meLid !== current.meLid,
             displayNameChanged: next.meDisplayName !== current.meDisplayName,
             companionChanged: (current.companionEncStatic === undefined) !==
@@ -259,6 +277,9 @@ export class WaAuthClient {
             meDisplayName: attributes.meDisplayName ?? credentials.meDisplayName,
             companionEncStatic: attributes.companionEncStatic ?? credentials.companionEncStatic,
             lastSuccessTs: attributes.lastSuccessTs ?? credentials.lastSuccessTs,
+            loginCounter: countsAsLogin
+                ? (credentials.loginCounter ?? 0) + 1
+                : credentials.loginCounter,
             propsVersion: attributes.propsVersion ?? credentials.propsVersion,
             abPropsVersion: attributes.abPropsVersion ?? credentials.abPropsVersion,
             connectionLocation: attributes.connectionLocation ?? credentials.connectionLocation,

package/dist/esm/auth/credentials-flow.js

@@ -174,6 +174,8 @@ export async function buildCommsConfig(logger, credentials, socketOptions, clien
                 ? {
                     username: loginIdentity.username,
                     device: loginIdentity.device,
+                    loginCounter: credentials.loginCounter ?? 0,
+                    connectAttemptCount: clientOptions.connectAttemptCount ?? 0,
                     deviceBrowser: clientOptions.deviceBrowser,
                     deviceOsDisplayName: clientOptions.deviceOsDisplayName,
                     versionBase
@@ -185,6 +187,7 @@ export async function buildCommsConfig(logger, credentials, socketOptions, clien
                     signedPreKey: credentials.signedPreKey,
                     deviceBrowser: clientOptions.deviceBrowser,
                     deviceOsDisplayName: clientOptions.deviceOsDisplayName,
+                    deviceOsVersion: clientOptions.deviceOsVersion,
                     requireFullSync: clientOptions.requireFullSync,
                     versionBase
                 }