zapo-js 1.8.0 → 1.8.2

package/dist/esm/media/container.js

@@ -0,0 +1,105 @@
+import { CONTAINER_SCAN_MAX_BYTES } from './constants.js';
+const BOX_HEADER_SIZE = 8;
+const LARGE_BOX_HEADER_SIZE = 16;
+const LARGE_BOX_SIZE_MARKER = 1;
+const BOX_TYPE_FTYP = 0x66747970;
+const BOX_TYPE_MOOV = 0x6d6f6f76;
+const BOX_TYPE_MDAT = 0x6d646174;
+function readU32(bytes, offset) {
+    return (((bytes[offset] << 24) |
+        (bytes[offset + 1] << 16) |
+        (bytes[offset + 2] << 8) |
+        bytes[offset + 3]) >>>
+        0);
+}
+/**
+ * Decides whether a media payload supports progressive playback, by walking
+ * the top-level ISO base media file format (mp4/mov/3gp/m4a) boxes over the
+ * leading bytes.
+ *
+ * An ISO-BMFF file is streamable only when its `moov` index box precedes the
+ * `mdat` payload box. With `mdat` first, a player has to reach the end of the
+ * download before it can start decoding, so advertising the file as seekable
+ * (by attaching a streaming sidecar) makes the recipient fail to open it
+ * instead of falling back to a plain download.
+ *
+ * Anything that is not ISO-BMFF - Ogg/Opus voice notes, for instance - is
+ * reported as streamable: those containers carry their index inline and have
+ * no equivalent failure mode.
+ *
+ * @param head - Leading bytes of the payload, starting at offset 0.
+ * @returns `true` when streamable, `false` when not, `null` when `head` is
+ *   too short to tell and the caller should retry with more bytes.
+ */
+export function scanStreamable(head) {
+    if (head.byteLength < BOX_HEADER_SIZE) {
+        return null;
+    }
+    if (readU32(head, 4) !== BOX_TYPE_FTYP) {
+        return true;
+    }
+    let offset = 0;
+    while (offset + BOX_HEADER_SIZE <= head.byteLength) {
+        const type = readU32(head, offset + 4);
+        if (type === BOX_TYPE_MOOV)
+            return true;
+        if (type === BOX_TYPE_MDAT)
+            return false;
+        let size = readU32(head, offset);
+        let headerSize = BOX_HEADER_SIZE;
+        if (size === LARGE_BOX_SIZE_MARKER) {
+            if (offset + LARGE_BOX_HEADER_SIZE > head.byteLength)
+                return null;
+            if (readU32(head, offset + BOX_HEADER_SIZE) !== 0)
+                return true;
+            size = readU32(head, offset + BOX_HEADER_SIZE + 4);
+            headerSize = LARGE_BOX_HEADER_SIZE;
+        }
+        else if (size === 0) {
+            return true;
+        }
+        if (size < headerSize)
+            return true;
+        offset += size;
+        if (offset > CONTAINER_SCAN_MAX_BYTES)
+            return true;
+    }
+    return offset > CONTAINER_SCAN_MAX_BYTES ? true : null;
+}
+/**
+ * Incremental front-end for {@link scanStreamable}, for callers that see the
+ * payload as a sequence of chunks. Buffers at most
+ * {@link CONTAINER_SCAN_MAX_BYTES} leading bytes and settles on `true` once
+ * that budget is spent without a verdict.
+ */
+export class WaStreamableScanner {
+    constructor() {
+        this.head = new Uint8Array(CONTAINER_SCAN_MAX_BYTES);
+        this.headLength = 0;
+        this.settled = null;
+    }
+    /** Verdict so far; `null` until enough leading bytes have been seen. */
+    get verdict() {
+        return this.settled;
+    }
+    /** Feeds the next payload chunk. Ignored once the verdict has settled. */
+    push(chunk) {
+        if (this.settled !== null || chunk.byteLength === 0) {
+            return;
+        }
+        const room = this.head.byteLength - this.headLength;
+        if (room > 0) {
+            const copied = Math.min(room, chunk.byteLength);
+            this.head.set(chunk.subarray(0, copied), this.headLength);
+            this.headLength += copied;
+        }
+        this.settled = scanStreamable(this.head.subarray(0, this.headLength));
+        if (this.settled === null && this.headLength === this.head.byteLength) {
+            this.settled = true;
+        }
+    }
+    /** Verdict to use once the payload has ended, defaulting to streamable. */
+    finish() {
+        return this.settled ?? true;
+    }
+}

package/dist/esm/media/crypto/WaMediaCrypto.js

@@ -8,6 +8,7 @@ import { hkdf } from '../../crypto/core/hkdf.js';
 import { aesCbcDecrypt, aesCbcEncryptWithTrailer, hmacSha256Sign, sha256 } from '../../crypto/core/primitives.js';
 import { randomBytesAsync } from '../../crypto/core/random.js';
 import { ENC_KEY_END, ENC_KEY_START, HMAC_TRUNCATED_SIZE, IV_SIZE, MAC_KEY_END, MAC_KEY_START, MEDIA_HKDF_SIZE, SIDECAR_CHUNK_SIZE, SIDECAR_HMAC_SIZE } from '../constants.js';
+import { scanStreamable, WaStreamableScanner } from '../container.js';
 import { getWaMediaHkdfInfo, WA_APP_STATE_KEY_TYPES } from '../../protocol/constants.js';
 import { assertByteLength, toBytesView, toChunkBytes, uint8TimingSafeEqual } from '../../util/bytes.js';
 import { toError } from '../../util/primitives.js';
@@ -105,7 +106,7 @@ export class WaMediaCrypto {
         const signature = mac.subarray(0, HMAC_TRUNCATED_SIZE);
         ciphertextHmac.set(signature, cipherLength);
         let streamingSidecar;
-        if (options?.sidecar !== false) {
+        if (options?.sidecar !== false && scanStreamable(plaintext) !== false) {
             const acc = new SidecarAccumulator(keys.macKey, plaintext.byteLength);
             acc.push(keys.iv);
             acc.push(ciphertext);
@@ -219,7 +220,8 @@ async function pumpEncryption(plaintext, output, keys, computeSidecar, firstFram
     const plainHash = createHash('sha256');
     const encHash = createHash('sha256');
     const hmac = createHmac('sha256', keys.macKey);
-    const sidecar = computeSidecar ? new SidecarAccumulator(keys.macKey, expectedFileSize) : null;
+    let sidecar = computeSidecar ? new SidecarAccumulator(keys.macKey, expectedFileSize) : null;
+    const scanner = computeSidecar ? new WaStreamableScanner() : null;
     const ffTarget = firstFrameLength !== undefined
         ? IV_SIZE + Math.ceil(firstFrameLength / AES_BLOCK_SIZE) * AES_BLOCK_SIZE
         : 0;
@@ -249,6 +251,11 @@ async function pumpEncryption(plaintext, output, keys, computeSidecar, firstFram
                 continue;
             plaintextLength += plainChunk.byteLength;
             plainHash.update(plainChunk);
+            if (scanner !== null && scanner.verdict === null) {
+                scanner.push(plainChunk);
+                if (scanner.verdict === false)
+                    sidecar = null;
+            }
             await consumeCiphertext(cipher.update(plainChunk));
         }
         await consumeCiphertext(cipher.final());

package/dist/esm/message/crypto/phash.js

@@ -9,39 +9,84 @@ const CHAR_AT = 0x40;
 const CHAR_C = 0x63;
 const CHAR_U = 0x75;
 const CHAR_S = 0x73;
-const MAX_PARTICIPANTS = 2048;
-const PER_WID_BYTES = 96;
-const SCRATCH = new Uint8Array(MAX_PARTICIPANTS * PER_WID_BYTES);
-const OFFSETS = new Uint32Array(MAX_PARTICIPANTS + 1);
-const ORDER = new Uint32Array(MAX_PARTICIPANTS);
+/**
+ * Upper bound on the bytes the canonical rewrite can add to a single jid: the
+ * `.0:` agent marker plus a device digit when the input carries neither, plus
+ * the `c.us` server substitution.
+ */
+const CANONICAL_GROWTH_BYTES = 4 + WA_DEFAULTS.HOST_DOMAIN.length;
+/**
+ * Largest canonical buffer kept alive between calls (the index arrays scale
+ * with it). Lists above this bound are rare enough that a throwaway allocation
+ * beats holding the memory for the life of the process.
+ */
+const RETAINED_SCRATCH_BYTES = 1024 * 1024;
+const RETAINED = {
+    scratch: new Uint8Array(0),
+    offsets: new Uint32Array(0),
+    order: new Uint32Array(0)
+};
+/**
+ * Computes the v2 participant hash (`2:<base64>`) attached to group and
+ * broadcast-list fanouts.
+ *
+ * Every participant is canonicalized to `<user>.0:<device>@<server>`, the set
+ * is sorted bytewise and hashed as a single SHA-256 stream. There is no
+ * participant ceiling: the canonical buffer grows to fit the list, so a group
+ * whose members resolve to tens of thousands of devices still hashes.
+ *
+ * @param participants device jids, in any order
+ * @returns the `2:`-prefixed phash, or `'2:'` when the list is empty
+ */
 export function computePhashV2(participants) {
-    if (participants.length === 0)
-        return '2:';
     const n = participants.length;
-    if (n > MAX_PARTICIPANTS) {
-        throw new Error(`phash participant count ${n} exceeds MAX_PARTICIPANTS ${MAX_PARTICIPANTS}`);
+    if (n === 0)
+        return '2:';
+    let requiredBytes = 0;
+    for (let i = 0; i < n; i += 1) {
+        requiredBytes += participants[i].length + CANONICAL_GROWTH_BYTES;
     }
+    const { scratch, offsets, order } = acquireBuffers(n, requiredBytes);
     let off = 0;
     for (let i = 0; i < n; i += 1) {
-        OFFSETS[i] = off;
-        const nextOff = writeCanonicalUtf8(SCRATCH, off, participants[i]);
-        if (nextOff > SCRATCH.length) {
-            throw new Error(`phash canonical buffer overflow at participant ${i}: needs ${nextOff} bytes, scratch is ${SCRATCH.length}`);
-        }
-        off = nextOff;
+        offsets[i] = off;
+        off = writeCanonicalUtf8(scratch, off, participants[i]);
+    }
+    offsets[n] = off;
+    if (off > scratch.length) {
+        throw new Error(`phash canonical buffer overflow: needs ${off} bytes, scratch is ${scratch.length}`);
     }
-    OFFSETS[n] = off;
     for (let i = 0; i < n; i += 1)
-        ORDER[i] = i;
-    ORDER.subarray(0, n).sort((a, b) => compareScratchSlice(SCRATCH, OFFSETS, a, b));
+        order[i] = i;
+    const ranked = order.subarray(0, n);
+    ranked.sort((a, b) => compareScratchSlice(scratch, offsets, a, b));
     const parts = new Array(n);
     for (let i = 0; i < n; i += 1) {
-        const idx = ORDER[i];
-        parts[i] = SCRATCH.subarray(OFFSETS[idx], OFFSETS[idx + 1]);
+        const idx = ranked[i];
+        parts[i] = scratch.subarray(offsets[idx], offsets[idx + 1]);
     }
     const digest = sha256(parts);
     return `2:${bytesToBase64(digest.subarray(0, PHASH_DIGEST_PREFIX))}`;
 }
+function acquireBuffers(participantCount, requiredBytes) {
+    if (requiredBytes > RETAINED_SCRATCH_BYTES) {
+        return {
+            scratch: new Uint8Array(requiredBytes),
+            offsets: new Uint32Array(participantCount + 1),
+            order: new Uint32Array(participantCount)
+        };
+    }
+    if (RETAINED.scratch.length < requiredBytes) {
+        const nextBytes = Math.max(requiredBytes, RETAINED.scratch.length * 2);
+        RETAINED.scratch = new Uint8Array(Math.min(RETAINED_SCRATCH_BYTES, nextBytes));
+    }
+    if (RETAINED.order.length < participantCount) {
+        const capacity = Math.max(participantCount, RETAINED.order.length * 2);
+        RETAINED.offsets = new Uint32Array(capacity + 1);
+        RETAINED.order = new Uint32Array(capacity);
+    }
+    return RETAINED;
+}
 function writeCanonicalUtf8(out, start, jid) {
     const atIndex = jid.indexOf('@');
     if (atIndex < 1 || atIndex >= jid.length - 1) {

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

@@ -125,6 +125,32 @@ function buildIncomingEventRawNode(node) {
         content: children
     };
 }
+/**
+ * Resolves who authored a {@link proto.IWebMessageInfo}. The top-level
+ * `participant` wins over `key.participant` - history sync carries the group
+ * sender in the former and leaves the latter empty on a large share of records.
+ * A self-sent group/broadcast message with neither falls back to this account,
+ * preferring `originalSelfAuthorUserJidString` over `meJid` (the current account
+ * user JID) so a message authored under a previous identity keeps its author.
+ *
+ * The participant fields are read whatever the thread type is, matching how
+ * WhatsApp Web builds the author: only the self-sent fallback is gated on
+ * group/broadcast. A 1:1 record normally carries neither, so this returns
+ * `undefined` there and the caller supplies the thread JID instead.
+ *
+ * `threadJid` overrides `key.remoteJid` for carriers that know the thread out
+ * of band, such as a group history bundle whose records may omit it.
+ */
+export function resolveWebMessageInfoAuthor(webMessageInfo, meJid, threadJid) {
+    const key = webMessageInfo.key ?? {};
+    const chatJid = threadJid ?? key.remoteJid ?? undefined;
+    const isGroupOrBroadcast = chatJid ? isGroupJid(chatJid) || isBroadcastJid(chatJid) : false;
+    const rawSelfAuthor = webMessageInfo.originalSelfAuthorUserJidString ?? meJid ?? undefined;
+    const selfAuthor = key.fromMe === true && isGroupOrBroadcast && rawSelfAuthor
+        ? toUserJid(rawSelfAuthor)
+        : undefined;
+    return webMessageInfo.participant ?? key.participant ?? selfAuthor ?? undefined;
+}
 /**
  * Rebuilds a `message` event from a recovered {@link proto.IWebMessageInfo}
  * (placeholder resend). `meJid` is the current account user JID, used as the
@@ -137,9 +163,7 @@ export function buildRecoveredIncomingEvent(webMessageInfo, meJid) {
     const fromMe = key.fromMe === true;
     const isGroup = chatJid ? isGroupJid(chatJid) : false;
     const isBroadcast = chatJid ? isBroadcastJid(chatJid) : false;
-    const rawSelfAuthor = webMessageInfo.originalSelfAuthorUserJidString ?? meJid ?? undefined;
-    const selfAuthor = fromMe && (isGroup || isBroadcast) && rawSelfAuthor ? toUserJid(rawSelfAuthor) : undefined;
-    const participant = webMessageInfo.participant ?? key.participant ?? selfAuthor;
+    const participant = resolveWebMessageInfoAuthor(webMessageInfo, meJid);
     const pushName = webMessageInfo.pushName ?? undefined;
     const rawSender = fromMe ? undefined : isGroup || isBroadcast ? participant : chatJid;
     const sender = rawSender ? parseJidFull(rawSender) : null;

package/dist/media/constants.d.ts

@@ -9,6 +9,12 @@ export declare const MAC_KEY_END = 80;
 export declare const HMAC_TRUNCATED_SIZE = 10;
 export declare const SIDECAR_CHUNK_SIZE = 65536;
 export declare const SIDECAR_HMAC_SIZE = 10;
+/**
+ * Leading bytes buffered when deciding whether a payload supports progressive
+ * playback. The top-level boxes that settle it sit at the very front of the
+ * file, so this only has to survive a few small boxes before `moov`/`mdat`.
+ */
+export declare const CONTAINER_SCAN_MAX_BYTES = 1024;
 export type MediaUploadKind = 'image' | 'video' | 'audio' | 'document' | 'sticker' | 'gif' | 'ptt' | 'ptv' | 'ads-image' | 'ads-video' | 'group-history' | 'md-app-state' | 'md-msg-hist' | 'music-artwork' | 'newsletter-music-artwork' | 'sticker-pack' | 'thumbnail-document' | 'thumbnail-image' | 'thumbnail-link' | 'thumbnail-sticker-pack' | 'thumbnail-video' | 'waffle-image' | 'waffle-video';
 export declare const MEDIA_UPLOAD_PATHS: Readonly<Record<MediaUploadKind, string>>;
 export type NewsletterMediaKind = 'image' | 'video' | 'audio' | 'document' | 'sticker' | 'sticker-pack' | 'gif' | 'ptt' | 'ptv' | 'thumbnail-link';

package/dist/media/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NEWSLETTER_MEDIA_UPLOAD_PATHS = exports.PPS_UPLOAD_PATHS = exports.MEDIA_UPLOAD_PATHS = exports.SIDECAR_HMAC_SIZE = exports.SIDECAR_CHUNK_SIZE = exports.HMAC_TRUNCATED_SIZE = exports.MAC_KEY_END = exports.MAC_KEY_START = exports.ENC_KEY_END = exports.ENC_KEY_START = exports.IV_SIZE = exports.MEDIA_HKDF_SIZE = exports.MEDIA_CONN_CACHE_GRACE_MS = exports.DEFAULT_MEDIA_HOSTS = void 0;
+exports.NEWSLETTER_MEDIA_UPLOAD_PATHS = exports.PPS_UPLOAD_PATHS = exports.MEDIA_UPLOAD_PATHS = exports.CONTAINER_SCAN_MAX_BYTES = exports.SIDECAR_HMAC_SIZE = exports.SIDECAR_CHUNK_SIZE = exports.HMAC_TRUNCATED_SIZE = exports.MAC_KEY_END = exports.MAC_KEY_START = exports.ENC_KEY_END = exports.ENC_KEY_START = exports.IV_SIZE = exports.MEDIA_HKDF_SIZE = exports.MEDIA_CONN_CACHE_GRACE_MS = exports.DEFAULT_MEDIA_HOSTS = void 0;
 exports.DEFAULT_MEDIA_HOSTS = Object.freeze([
     'mmg.whatsapp.net',
     'mmg-fallback.whatsapp.net'
@@ -15,6 +15,12 @@ exports.MAC_KEY_END = 80;
 exports.HMAC_TRUNCATED_SIZE = 10;
 exports.SIDECAR_CHUNK_SIZE = 65536;
 exports.SIDECAR_HMAC_SIZE = 10;
+/**
+ * Leading bytes buffered when deciding whether a payload supports progressive
+ * playback. The top-level boxes that settle it sit at the very front of the
+ * file, so this only has to survive a few small boxes before `moov`/`mdat`.
+ */
+exports.CONTAINER_SCAN_MAX_BYTES = 1024;
 exports.MEDIA_UPLOAD_PATHS = Object.freeze({
     image: '/mms/image',
     video: '/mms/video',

package/dist/media/container.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Verdict of {@link scanStreamable}: `true` when the payload can be played
+ * back while it downloads, `false` when it cannot, `null` while the leading
+ * bytes seen so far are not enough to decide.
+ */
+export type WaStreamableVerdict = boolean | null;
+/**
+ * Decides whether a media payload supports progressive playback, by walking
+ * the top-level ISO base media file format (mp4/mov/3gp/m4a) boxes over the
+ * leading bytes.
+ *
+ * An ISO-BMFF file is streamable only when its `moov` index box precedes the
+ * `mdat` payload box. With `mdat` first, a player has to reach the end of the
+ * download before it can start decoding, so advertising the file as seekable
+ * (by attaching a streaming sidecar) makes the recipient fail to open it
+ * instead of falling back to a plain download.
+ *
+ * Anything that is not ISO-BMFF - Ogg/Opus voice notes, for instance - is
+ * reported as streamable: those containers carry their index inline and have
+ * no equivalent failure mode.
+ *
+ * @param head - Leading bytes of the payload, starting at offset 0.
+ * @returns `true` when streamable, `false` when not, `null` when `head` is
+ *   too short to tell and the caller should retry with more bytes.
+ */
+export declare function scanStreamable(head: Uint8Array): WaStreamableVerdict;
+/**
+ * Incremental front-end for {@link scanStreamable}, for callers that see the
+ * payload as a sequence of chunks. Buffers at most
+ * {@link CONTAINER_SCAN_MAX_BYTES} leading bytes and settles on `true` once
+ * that budget is spent without a verdict.
+ */
+export declare class WaStreamableScanner {
+    private readonly head;
+    private headLength;
+    private settled;
+    /** Verdict so far; `null` until enough leading bytes have been seen. */
+    get verdict(): WaStreamableVerdict;
+    /** Feeds the next payload chunk. Ignored once the verdict has settled. */
+    push(chunk: Uint8Array): void;
+    /** Verdict to use once the payload has ended, defaulting to streamable. */
+    finish(): boolean;
+}

package/dist/media/container.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaStreamableScanner = void 0;
+exports.scanStreamable = scanStreamable;
+const constants_1 = require("./constants");
+const BOX_HEADER_SIZE = 8;
+const LARGE_BOX_HEADER_SIZE = 16;
+const LARGE_BOX_SIZE_MARKER = 1;
+const BOX_TYPE_FTYP = 0x66747970;
+const BOX_TYPE_MOOV = 0x6d6f6f76;
+const BOX_TYPE_MDAT = 0x6d646174;
+function readU32(bytes, offset) {
+    return (((bytes[offset] << 24) |
+        (bytes[offset + 1] << 16) |
+        (bytes[offset + 2] << 8) |
+        bytes[offset + 3]) >>>
+        0);
+}
+/**
+ * Decides whether a media payload supports progressive playback, by walking
+ * the top-level ISO base media file format (mp4/mov/3gp/m4a) boxes over the
+ * leading bytes.
+ *
+ * An ISO-BMFF file is streamable only when its `moov` index box precedes the
+ * `mdat` payload box. With `mdat` first, a player has to reach the end of the
+ * download before it can start decoding, so advertising the file as seekable
+ * (by attaching a streaming sidecar) makes the recipient fail to open it
+ * instead of falling back to a plain download.
+ *
+ * Anything that is not ISO-BMFF - Ogg/Opus voice notes, for instance - is
+ * reported as streamable: those containers carry their index inline and have
+ * no equivalent failure mode.
+ *
+ * @param head - Leading bytes of the payload, starting at offset 0.
+ * @returns `true` when streamable, `false` when not, `null` when `head` is
+ *   too short to tell and the caller should retry with more bytes.
+ */
+function scanStreamable(head) {
+    if (head.byteLength < BOX_HEADER_SIZE) {
+        return null;
+    }
+    if (readU32(head, 4) !== BOX_TYPE_FTYP) {
+        return true;
+    }
+    let offset = 0;
+    while (offset + BOX_HEADER_SIZE <= head.byteLength) {
+        const type = readU32(head, offset + 4);
+        if (type === BOX_TYPE_MOOV)
+            return true;
+        if (type === BOX_TYPE_MDAT)
+            return false;
+        let size = readU32(head, offset);
+        let headerSize = BOX_HEADER_SIZE;
+        if (size === LARGE_BOX_SIZE_MARKER) {
+            if (offset + LARGE_BOX_HEADER_SIZE > head.byteLength)
+                return null;
+            if (readU32(head, offset + BOX_HEADER_SIZE) !== 0)
+                return true;
+            size = readU32(head, offset + BOX_HEADER_SIZE + 4);
+            headerSize = LARGE_BOX_HEADER_SIZE;
+        }
+        else if (size === 0) {
+            return true;
+        }
+        if (size < headerSize)
+            return true;
+        offset += size;
+        if (offset > constants_1.CONTAINER_SCAN_MAX_BYTES)
+            return true;
+    }
+    return offset > constants_1.CONTAINER_SCAN_MAX_BYTES ? true : null;
+}
+/**
+ * Incremental front-end for {@link scanStreamable}, for callers that see the
+ * payload as a sequence of chunks. Buffers at most
+ * {@link CONTAINER_SCAN_MAX_BYTES} leading bytes and settles on `true` once
+ * that budget is spent without a verdict.
+ */
+class WaStreamableScanner {
+    constructor() {
+        this.head = new Uint8Array(constants_1.CONTAINER_SCAN_MAX_BYTES);
+        this.headLength = 0;
+        this.settled = null;
+    }
+    /** Verdict so far; `null` until enough leading bytes have been seen. */
+    get verdict() {
+        return this.settled;
+    }
+    /** Feeds the next payload chunk. Ignored once the verdict has settled. */
+    push(chunk) {
+        if (this.settled !== null || chunk.byteLength === 0) {
+            return;
+        }
+        const room = this.head.byteLength - this.headLength;
+        if (room > 0) {
+            const copied = Math.min(room, chunk.byteLength);
+            this.head.set(chunk.subarray(0, copied), this.headLength);
+            this.headLength += copied;
+        }
+        this.settled = scanStreamable(this.head.subarray(0, this.headLength));
+        if (this.settled === null && this.headLength === this.head.byteLength) {
+            this.settled = true;
+        }
+    }
+    /** Verdict to use once the payload has ended, defaulting to streamable. */
+    finish() {
+        return this.settled ?? true;
+    }
+}
+exports.WaStreamableScanner = WaStreamableScanner;

package/dist/media/crypto/WaMediaCrypto.js

@@ -11,6 +11,7 @@ const hkdf_1 = require("../../crypto/core/hkdf");
 const primitives_1 = require("../../crypto/core/primitives");
 const random_1 = require("../../crypto/core/random");
 const constants_1 = require("../constants");
+const container_1 = require("../container");
 const constants_2 = require("../../protocol/constants");
 const bytes_1 = require("../../util/bytes");
 const primitives_2 = require("../../util/primitives");
@@ -108,7 +109,7 @@ class WaMediaCrypto {
         const signature = mac.subarray(0, constants_1.HMAC_TRUNCATED_SIZE);
         ciphertextHmac.set(signature, cipherLength);
         let streamingSidecar;
-        if (options?.sidecar !== false) {
+        if (options?.sidecar !== false && (0, container_1.scanStreamable)(plaintext) !== false) {
             const acc = new SidecarAccumulator(keys.macKey, plaintext.byteLength);
             acc.push(keys.iv);
             acc.push(ciphertext);
@@ -223,7 +224,8 @@ async function pumpEncryption(plaintext, output, keys, computeSidecar, firstFram
     const plainHash = (0, node_crypto_1.createHash)('sha256');
     const encHash = (0, node_crypto_1.createHash)('sha256');
     const hmac = (0, node_crypto_1.createHmac)('sha256', keys.macKey);
-    const sidecar = computeSidecar ? new SidecarAccumulator(keys.macKey, expectedFileSize) : null;
+    let sidecar = computeSidecar ? new SidecarAccumulator(keys.macKey, expectedFileSize) : null;
+    const scanner = computeSidecar ? new container_1.WaStreamableScanner() : null;
     const ffTarget = firstFrameLength !== undefined
         ? constants_1.IV_SIZE + Math.ceil(firstFrameLength / AES_BLOCK_SIZE) * AES_BLOCK_SIZE
         : 0;
@@ -253,6 +255,11 @@ async function pumpEncryption(plaintext, output, keys, computeSidecar, firstFram
                 continue;
             plaintextLength += plainChunk.byteLength;
             plainHash.update(plainChunk);
+            if (scanner !== null && scanner.verdict === null) {
+                scanner.push(plainChunk);
+                if (scanner.verdict === false)
+                    sidecar = null;
+            }
             await consumeCiphertext(cipher.update(plainChunk));
         }
         await consumeCiphertext(cipher.final());

package/dist/message/crypto/phash.d.ts

@@ -1 +1,13 @@
+/**
+ * Computes the v2 participant hash (`2:<base64>`) attached to group and
+ * broadcast-list fanouts.
+ *
+ * Every participant is canonicalized to `<user>.0:<device>@<server>`, the set
+ * is sorted bytewise and hashed as a single SHA-256 stream. There is no
+ * participant ceiling: the canonical buffer grows to fit the list, so a group
+ * whose members resolve to tens of thousands of devices still hashes.
+ *
+ * @param participants device jids, in any order
+ * @returns the `2:`-prefixed phash, or `'2:'` when the list is empty
+ */
 export declare function computePhashV2(participants: readonly string[]): string;

package/dist/message/crypto/phash.js

@@ -12,39 +12,84 @@ const CHAR_AT = 0x40;
 const CHAR_C = 0x63;
 const CHAR_U = 0x75;
 const CHAR_S = 0x73;
-const MAX_PARTICIPANTS = 2048;
-const PER_WID_BYTES = 96;
-const SCRATCH = new Uint8Array(MAX_PARTICIPANTS * PER_WID_BYTES);
-const OFFSETS = new Uint32Array(MAX_PARTICIPANTS + 1);
-const ORDER = new Uint32Array(MAX_PARTICIPANTS);
+/**
+ * Upper bound on the bytes the canonical rewrite can add to a single jid: the
+ * `.0:` agent marker plus a device digit when the input carries neither, plus
+ * the `c.us` server substitution.
+ */
+const CANONICAL_GROWTH_BYTES = 4 + constants_1.WA_DEFAULTS.HOST_DOMAIN.length;
+/**
+ * Largest canonical buffer kept alive between calls (the index arrays scale
+ * with it). Lists above this bound are rare enough that a throwaway allocation
+ * beats holding the memory for the life of the process.
+ */
+const RETAINED_SCRATCH_BYTES = 1024 * 1024;
+const RETAINED = {
+    scratch: new Uint8Array(0),
+    offsets: new Uint32Array(0),
+    order: new Uint32Array(0)
+};
+/**
+ * Computes the v2 participant hash (`2:<base64>`) attached to group and
+ * broadcast-list fanouts.
+ *
+ * Every participant is canonicalized to `<user>.0:<device>@<server>`, the set
+ * is sorted bytewise and hashed as a single SHA-256 stream. There is no
+ * participant ceiling: the canonical buffer grows to fit the list, so a group
+ * whose members resolve to tens of thousands of devices still hashes.
+ *
+ * @param participants device jids, in any order
+ * @returns the `2:`-prefixed phash, or `'2:'` when the list is empty
+ */
 function computePhashV2(participants) {
-    if (participants.length === 0)
-        return '2:';
     const n = participants.length;
-    if (n > MAX_PARTICIPANTS) {
-        throw new Error(`phash participant count ${n} exceeds MAX_PARTICIPANTS ${MAX_PARTICIPANTS}`);
+    if (n === 0)
+        return '2:';
+    let requiredBytes = 0;
+    for (let i = 0; i < n; i += 1) {
+        requiredBytes += participants[i].length + CANONICAL_GROWTH_BYTES;
     }
+    const { scratch, offsets, order } = acquireBuffers(n, requiredBytes);
     let off = 0;
     for (let i = 0; i < n; i += 1) {
-        OFFSETS[i] = off;
-        const nextOff = writeCanonicalUtf8(SCRATCH, off, participants[i]);
-        if (nextOff > SCRATCH.length) {
-            throw new Error(`phash canonical buffer overflow at participant ${i}: needs ${nextOff} bytes, scratch is ${SCRATCH.length}`);
-        }
-        off = nextOff;
+        offsets[i] = off;
+        off = writeCanonicalUtf8(scratch, off, participants[i]);
+    }
+    offsets[n] = off;
+    if (off > scratch.length) {
+        throw new Error(`phash canonical buffer overflow: needs ${off} bytes, scratch is ${scratch.length}`);
     }
-    OFFSETS[n] = off;
     for (let i = 0; i < n; i += 1)
-        ORDER[i] = i;
-    ORDER.subarray(0, n).sort((a, b) => compareScratchSlice(SCRATCH, OFFSETS, a, b));
+        order[i] = i;
+    const ranked = order.subarray(0, n);
+    ranked.sort((a, b) => compareScratchSlice(scratch, offsets, a, b));
     const parts = new Array(n);
     for (let i = 0; i < n; i += 1) {
-        const idx = ORDER[i];
-        parts[i] = SCRATCH.subarray(OFFSETS[idx], OFFSETS[idx + 1]);
+        const idx = ranked[i];
+        parts[i] = scratch.subarray(offsets[idx], offsets[idx + 1]);
     }
     const digest = (0, core_1.sha256)(parts);
     return `2:${(0, bytes_1.bytesToBase64)(digest.subarray(0, PHASH_DIGEST_PREFIX))}`;
 }
+function acquireBuffers(participantCount, requiredBytes) {
+    if (requiredBytes > RETAINED_SCRATCH_BYTES) {
+        return {
+            scratch: new Uint8Array(requiredBytes),
+            offsets: new Uint32Array(participantCount + 1),
+            order: new Uint32Array(participantCount)
+        };
+    }
+    if (RETAINED.scratch.length < requiredBytes) {
+        const nextBytes = Math.max(requiredBytes, RETAINED.scratch.length * 2);
+        RETAINED.scratch = new Uint8Array(Math.min(RETAINED_SCRATCH_BYTES, nextBytes));
+    }
+    if (RETAINED.order.length < participantCount) {
+        const capacity = Math.max(participantCount, RETAINED.order.length * 2);
+        RETAINED.offsets = new Uint32Array(capacity + 1);
+        RETAINED.order = new Uint32Array(capacity);
+    }
+    return RETAINED;
+}
 function writeCanonicalUtf8(out, start, jid) {
     const atIndex = jid.indexOf('@');
     if (atIndex < 1 || atIndex >= jid.length - 1) {