zapo-js 1.8.0 → 1.8.1

package/dist/client/WaClient.js

@@ -278,7 +278,8 @@ class WaClientImpl 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: sendHistSyncReceipt
+                        onProcessed: sendHistSyncReceipt,
+                        meJid: this.deps.authClient.getCurrentCredentials()?.meJid
                     }, protocolMessage.historySyncNotification);
                 }
                 else if (sendHistSyncReceipt) {

package/dist/client/coordinators/WaRetryCoordinator.js

@@ -25,7 +25,7 @@ const RETRY_SESSION_BASE_KEY_CACHE_MAX_ENTRIES = 8192;
 // serialize on the prekey lock and hit the store); excess under flood is dropped.
 const DECRYPT_FAILURE_QUEUE_MAX_SIZE = 1024;
 const DECRYPT_FAILURE_QUEUE_MAX_CONCURRENCY = 8;
-const PLACEHOLDER_RESEND_RETRY_THRESHOLD = 3;
+const PLACEHOLDER_RESEND_RETRY_THRESHOLD = 4;
 const PLACEHOLDER_RESEND_BATCH_SIZE = 32;
 const PLACEHOLDER_RESEND_DEBOUNCE_MS = 200;
 const PLACEHOLDER_RESEND_FALLBACK_MAX_AGE_DAYS = 14;

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

@@ -4,6 +4,7 @@ exports.runGroupHistoryBundle = runGroupHistoryBundle;
 exports.processGroupHistoryBundle = processGroupHistoryBundle;
 const history_blob_1 = require("../persistence/history-blob");
 const group_history_1 = require("../../message/kinds/group-history");
+const incoming_1 = require("../../message/primitives/incoming");
 const _proto_1 = require("../../proto");
 const jid_1 = require("../../protocol/jid");
 const primitives_1 = require("../../util/primitives");
@@ -79,10 +80,12 @@ async function processGroupHistoryBundle(deps, input) {
             (oldestTimestampMs === undefined || timestampMs < oldestTimestampMs)) {
             oldestTimestampMs = timestampMs;
         }
+        const authorJid = (0, incoming_1.resolveWebMessageInfoAuthor)(webMsg, deps.meJid, input.groupJid);
         const write = deps.writeBehind.persistMessageAsync({
             id: webMsg.key.id,
             threadJid: input.groupJid,
-            senderJid: webMsg.key.participant ?? undefined,
+            senderJid: authorJid,
+            participantJid: authorJid,
             fromMe: webMsg.key.fromMe === true,
             timestampMs: timestampMs || undefined,
             messageBytes: _proto_1.proto.Message.encode(webMsg.message).finish()

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

@@ -33,6 +33,8 @@ interface WaHistorySyncDeps {
     readonly onNctSalt?: (salt: Uint8Array) => Promise<void>;
     /** Acks the chunk via the `hist_sync` receipt so the primary stops resending it. */
     readonly onProcessed?: (syncType: Proto.Message.HistorySyncType) => Promise<void>;
+    /** Author fallback for self-sent group messages that carry no participant. */
+    readonly meJid?: string | null;
 }
 export declare function runHistorySyncNotification(deps: WaHistorySyncDeps, notification: Proto.Message.IHistorySyncNotification): Promise<void>;
 /**

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

@@ -4,6 +4,7 @@ exports.CONVERSATION_FIELDS = exports.HISTORY_SYNC_FIELDS = void 0;
 exports.runHistorySyncNotification = runHistorySyncNotification;
 exports.processHistorySyncNotification = processHistorySyncNotification;
 const history_blob_1 = require("../persistence/history-blob");
+const incoming_1 = require("../../message/primitives/incoming");
 const _proto_1 = require("../../proto");
 const jid_1 = require("../../protocol/jid");
 const message_1 = require("../../protocol/message");
@@ -158,15 +159,7 @@ async function consumeHistorySyncStream(deps, inflated, state) {
                     parked[parked.length] = message;
                     return undefined;
                 }
-                state.messagesCount += 1;
-                pushWrite(state, deps.writeBehind.persistMessageAsync({
-                    id: message.id,
-                    threadJid,
-                    senderJid: message.senderJid,
-                    fromMe: message.fromMe,
-                    timestampMs: message.timestampMs,
-                    messageBytes: message.messageBytes
-                }));
+                persistHistoryMessage(deps, state, message, threadJid);
                 return maybeFlush(state);
             }
             if (headerParts) {
@@ -292,18 +285,35 @@ async function closeConversation(deps, state, headerParts, threadJid, parked) {
         }
     }
     for (const message of parked ?? []) {
-        state.messagesCount += 1;
-        pushWrite(state, deps.writeBehind.persistMessageAsync({
-            id: message.id,
-            threadJid: resolvedJid,
-            senderJid: message.senderJid,
-            fromMe: message.fromMe,
-            timestampMs: message.timestampMs,
-            messageBytes: message.messageBytes
-        }));
+        persistHistoryMessage(deps, state, message, resolvedJid);
     }
     await maybeFlush(state);
 }
+/**
+ * Resolves the author here rather than at decode time because a message may be
+ * read before its `Conversation.id`, and the thread type decides both the
+ * self-sent fallback and the shape of the record.
+ *
+ * `participantJid` carries the group/broadcast author and stays absent in 1:1
+ * threads, where `senderJid` falls back to the thread JID - the same shape the
+ * live message path persists. A group author that stays unresolved leaves both
+ * fields empty: writing the group JID there would read downstream as if the
+ * group itself had sent the message.
+ */
+function persistHistoryMessage(deps, state, message, threadJid) {
+    state.messagesCount += 1;
+    const authorJid = (0, incoming_1.resolveWebMessageInfoAuthor)(message.authorInfo, deps.meJid, threadJid);
+    const isGroupOrBroadcast = (0, jid_1.isGroupJid)(threadJid) || (0, jid_1.isBroadcastJid)(threadJid);
+    pushWrite(state, deps.writeBehind.persistMessageAsync({
+        id: message.id,
+        threadJid,
+        senderJid: isGroupOrBroadcast ? authorJid : (authorJid ?? threadJid),
+        participantJid: isGroupOrBroadcast ? authorJid : undefined,
+        fromMe: message.fromMe,
+        timestampMs: message.timestampMs,
+        messageBytes: message.messageBytes
+    }));
+}
 async function settleHistorySyncChunk(deps, state) {
     for (const pushname of state.pushnames) {
         if (!pushname.id) {
@@ -365,7 +375,11 @@ function readHistoryMessage(record) {
     const timestampMs = (0, primitives_1.longToNumber)(webMsg.messageTimestamp) * 1000;
     return {
         id: webMsg.key.id,
-        senderJid: webMsg.key.participant ?? undefined,
+        authorInfo: {
+            key: { fromMe: webMsg.key.fromMe, participant: webMsg.key.participant },
+            participant: webMsg.participant,
+            originalSelfAuthorUserJidString: webMsg.originalSelfAuthorUserJidString
+        },
         fromMe: webMsg.key.fromMe === true,
         timestampMs: timestampMs || undefined,
         messageBytes: _proto_1.proto.Message.encode(webMsg.message).finish()

package/dist/esm/client/WaClient.js

@@ -275,7 +275,8 @@ class WaClientImpl extends EventEmitter {
                         emitEvent: this.emit.bind(this),
                         onPrivacyTokens: (conversations) => this.deps.trustedContactToken.hydrateFromHistorySync(conversations),
                         onNctSalt: (salt) => this.deps.trustedContactToken.hydrateNctSaltFromHistorySync(salt),
-                        onProcessed: sendHistSyncReceipt
+                        onProcessed: sendHistSyncReceipt,
+                        meJid: this.deps.authClient.getCurrentCredentials()?.meJid
                     }, protocolMessage.historySyncNotification);
                 }
                 else if (sendHistSyncReceipt) {

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

@@ -22,7 +22,7 @@ const RETRY_SESSION_BASE_KEY_CACHE_MAX_ENTRIES = 8192;
 // serialize on the prekey lock and hit the store); excess under flood is dropped.
 const DECRYPT_FAILURE_QUEUE_MAX_SIZE = 1024;
 const DECRYPT_FAILURE_QUEUE_MAX_CONCURRENCY = 8;
-const PLACEHOLDER_RESEND_RETRY_THRESHOLD = 3;
+const PLACEHOLDER_RESEND_RETRY_THRESHOLD = 4;
 const PLACEHOLDER_RESEND_BATCH_SIZE = 32;
 const PLACEHOLDER_RESEND_DEBOUNCE_MS = 200;
 const PLACEHOLDER_RESEND_FALLBACK_MAX_AGE_DAYS = 14;

package/dist/esm/client/persistence/group-history.js

@@ -1,5 +1,6 @@
 import { flushPendingWrites, openHistoryBlobStream } from '../persistence/history-blob.js';
 import { streamGroupHistoryBundle } from '../../message/kinds/group-history.js';
+import { resolveWebMessageInfoAuthor } from '../../message/primitives/incoming.js';
 import { proto } from '../../proto.js';
 import { isGroupJid, toUserJid } from '../../protocol/jid.js';
 import { longToNumber, toError } from '../../util/primitives.js';
@@ -75,10 +76,12 @@ export async function processGroupHistoryBundle(deps, input) {
             (oldestTimestampMs === undefined || timestampMs < oldestTimestampMs)) {
             oldestTimestampMs = timestampMs;
         }
+        const authorJid = resolveWebMessageInfoAuthor(webMsg, deps.meJid, input.groupJid);
         const write = deps.writeBehind.persistMessageAsync({
             id: webMsg.key.id,
             threadJid: input.groupJid,
-            senderJid: webMsg.key.participant ?? undefined,
+            senderJid: authorJid,
+            participantJid: authorJid,
             fromMe: webMsg.key.fromMe === true,
             timestampMs: timestampMs || undefined,
             messageBytes: proto.Message.encode(webMsg.message).finish()

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

@@ -1,6 +1,7 @@
 import { flushPendingWrites, openHistoryBlobStream } from '../persistence/history-blob.js';
+import { resolveWebMessageInfoAuthor } from '../../message/primitives/incoming.js';
 import { proto } from '../../proto.js';
-import { isUserJid } from '../../protocol/jid.js';
+import { isBroadcastJid, isGroupJid, isUserJid } from '../../protocol/jid.js';
 import { normalizeEphemeralSettingSeconds } from '../../protocol/message.js';
 import { normalizeUsername } from '../../protocol/username.js';
 import { concatBytes, TEXT_DECODER } from '../../util/bytes.js';
@@ -153,15 +154,7 @@ async function consumeHistorySyncStream(deps, inflated, state) {
                     parked[parked.length] = message;
                     return undefined;
                 }
-                state.messagesCount += 1;
-                pushWrite(state, deps.writeBehind.persistMessageAsync({
-                    id: message.id,
-                    threadJid,
-                    senderJid: message.senderJid,
-                    fromMe: message.fromMe,
-                    timestampMs: message.timestampMs,
-                    messageBytes: message.messageBytes
-                }));
+                persistHistoryMessage(deps, state, message, threadJid);
                 return maybeFlush(state);
             }
             if (headerParts) {
@@ -287,18 +280,35 @@ async function closeConversation(deps, state, headerParts, threadJid, parked) {
         }
     }
     for (const message of parked ?? []) {
-        state.messagesCount += 1;
-        pushWrite(state, deps.writeBehind.persistMessageAsync({
-            id: message.id,
-            threadJid: resolvedJid,
-            senderJid: message.senderJid,
-            fromMe: message.fromMe,
-            timestampMs: message.timestampMs,
-            messageBytes: message.messageBytes
-        }));
+        persistHistoryMessage(deps, state, message, resolvedJid);
     }
     await maybeFlush(state);
 }
+/**
+ * Resolves the author here rather than at decode time because a message may be
+ * read before its `Conversation.id`, and the thread type decides both the
+ * self-sent fallback and the shape of the record.
+ *
+ * `participantJid` carries the group/broadcast author and stays absent in 1:1
+ * threads, where `senderJid` falls back to the thread JID - the same shape the
+ * live message path persists. A group author that stays unresolved leaves both
+ * fields empty: writing the group JID there would read downstream as if the
+ * group itself had sent the message.
+ */
+function persistHistoryMessage(deps, state, message, threadJid) {
+    state.messagesCount += 1;
+    const authorJid = resolveWebMessageInfoAuthor(message.authorInfo, deps.meJid, threadJid);
+    const isGroupOrBroadcast = isGroupJid(threadJid) || isBroadcastJid(threadJid);
+    pushWrite(state, deps.writeBehind.persistMessageAsync({
+        id: message.id,
+        threadJid,
+        senderJid: isGroupOrBroadcast ? authorJid : (authorJid ?? threadJid),
+        participantJid: isGroupOrBroadcast ? authorJid : undefined,
+        fromMe: message.fromMe,
+        timestampMs: message.timestampMs,
+        messageBytes: message.messageBytes
+    }));
+}
 async function settleHistorySyncChunk(deps, state) {
     for (const pushname of state.pushnames) {
         if (!pushname.id) {
@@ -360,7 +370,11 @@ function readHistoryMessage(record) {
     const timestampMs = longToNumber(webMsg.messageTimestamp) * 1000;
     return {
         id: webMsg.key.id,
-        senderJid: webMsg.key.participant ?? undefined,
+        authorInfo: {
+            key: { fromMe: webMsg.key.fromMe, participant: webMsg.key.participant },
+            participant: webMsg.participant,
+            originalSelfAuthorUserJidString: webMsg.originalSelfAuthorUserJidString
+        },
         fromMe: webMsg.key.fromMe === true,
         timestampMs: timestampMs || undefined,
         messageBytes: proto.Message.encode(webMsg.message).finish()

package/dist/esm/media/constants.js

@@ -12,6 +12,12 @@ export const MAC_KEY_END = 80;
 export const HMAC_TRUNCATED_SIZE = 10;
 export const SIDECAR_CHUNK_SIZE = 65536;
 export 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 const CONTAINER_SCAN_MAX_BYTES = 1024;
 export const MEDIA_UPLOAD_PATHS = Object.freeze({
     image: '/mms/image',
     video: '/mms/video',

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

@@ -24,6 +24,23 @@ interface WaIncomingMessageAckHandlerOptions {
     readonly emitUnhandledStanza?: (event: WaIncomingUnhandledStanzaEvent) => void;
     readonly emitDecryptedPayload?: (build: () => WaIncomingDecryptedPayloadEvent) => void;
 }
+/**
+ * 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 declare function resolveWebMessageInfoAuthor(webMessageInfo: proto.IWebMessageInfo, meJid?: string | null, threadJid?: string): string | undefined;
 /**
  * Rebuilds a `message` event from a recovered {@link proto.IWebMessageInfo}
  * (placeholder resend). `meJid` is the current account user JID, used as the

package/dist/message/primitives/incoming.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveWebMessageInfoAuthor = resolveWebMessageInfoAuthor;
 exports.buildRecoveredIncomingEvent = buildRecoveredIncomingEvent;
 exports.handleIncomingMessageAck = handleIncomingMessageAck;
 const context_info_1 = require("../context-info");
@@ -129,6 +130,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.
+ */
+function resolveWebMessageInfoAuthor(webMessageInfo, meJid, threadJid) {
+    const key = webMessageInfo.key ?? {};
+    const chatJid = threadJid ?? key.remoteJid ?? undefined;
+    const isGroupOrBroadcast = chatJid ? (0, jid_1.isGroupJid)(chatJid) || (0, jid_1.isBroadcastJid)(chatJid) : false;
+    const rawSelfAuthor = webMessageInfo.originalSelfAuthorUserJidString ?? meJid ?? undefined;
+    const selfAuthor = key.fromMe === true && isGroupOrBroadcast && rawSelfAuthor
+        ? (0, jid_1.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
@@ -141,9 +168,7 @@ function buildRecoveredIncomingEvent(webMessageInfo, meJid) {
     const fromMe = key.fromMe === true;
     const isGroup = chatJid ? (0, jid_1.isGroupJid)(chatJid) : false;
     const isBroadcast = chatJid ? (0, jid_1.isBroadcastJid)(chatJid) : false;
-    const rawSelfAuthor = webMessageInfo.originalSelfAuthorUserJidString ?? meJid ?? undefined;
-    const selfAuthor = fromMe && (isGroup || isBroadcast) && rawSelfAuthor ? (0, jid_1.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 ? (0, jid_1.parseJidFull)(rawSender) : null;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "zapo-js",
-    "version": "1.8.0",
+    "version": "1.8.1",
     "description": "High-performance WhatsApp Web TypeScript library",
     "license": "MIT",
     "author": "vinikjkkj <contact@vinicius.email> (https://github.com/vinikjkkj)",