zapo-js 1.8.0 → 1.8.2

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

@@ -15,6 +15,11 @@ export declare class WaOfflineResumeCoordinator {
     private state;
     private totalStanzas;
     private pendingStanzas;
+    private batchInFlight;
+    private batchRetries;
+    private resumeGeneration;
+    private lastBatchRequestMs;
+    private batchTimeout;
     private stanzaTimeout;
     constructor(options: WaOfflineResumeCoordinatorOptions);
     get isComplete(): boolean;
@@ -24,6 +29,23 @@ export declare class WaOfflineResumeCoordinator {
     trackOfflineStanza(): void;
     reset(): void;
     private completeResume;
+    /**
+     * Ask the server for the next window of queued stanzas, at most one request
+     * per `REQUEST_DEBOUNCE_MS` and never while one is still outstanding. Only a
+     * delivered stanza schedules a request, so the loop winds down on its own
+     * once the queue dries up; the resume itself ends on the terminal `offline`
+     * bulletin or on the stanza timeout, never on the preview counter, which is
+     * a progress estimate rather than an authoritative total.
+     */
+    private scheduleNextBatch;
+    private requestOfflineBatch;
+    /**
+     * A rejected request delivers no stanza, and only a delivered stanza
+     * schedules the next one, so without a retry here a single transport blip
+     * strands the whole queue until the stanza timeout. `generation` pins the
+     * outcome to the resume that issued it: a rejection from a torn-down resume
+     * must not clear the current one's in-flight flag or retry on its behalf.
+     */
     private sendOfflineBatch;
     private resetStanzaTimeout;
     private clearTimers;

package/dist/client/coordinators/WaOfflineResumeCoordinator.js

@@ -5,6 +5,8 @@ const offline_1 = require("../../transport/node/builders/offline");
 const primitives_1 = require("../../util/primitives");
 const WA_OFFLINE_RESUME = Object.freeze({
     BATCH_SIZE: 200,
+    REQUEST_DEBOUNCE_MS: 100,
+    MAX_BATCH_RETRIES: 3,
     STANZA_TIMEOUT_MS: 60000
 });
 const WA_OFFLINE_RESUME_STATE = Object.freeze({
@@ -19,6 +21,11 @@ class WaOfflineResumeCoordinator {
         this.state = WA_OFFLINE_RESUME_STATE.INIT;
         this.totalStanzas = 0;
         this.pendingStanzas = 0;
+        this.batchInFlight = false;
+        this.batchRetries = 0;
+        this.resumeGeneration = 0;
+        this.lastBatchRequestMs = 0;
+        this.batchTimeout = null;
         this.stanzaTimeout = null;
     }
     get isComplete() {
@@ -32,6 +39,10 @@ class WaOfflineResumeCoordinator {
         this.state = WA_OFFLINE_RESUME_STATE.RESUMING;
         this.totalStanzas = stanzaCount;
         this.pendingStanzas = stanzaCount;
+        this.batchInFlight = false;
+        this.batchRetries = 0;
+        this.resumeGeneration += 1;
+        this.lastBatchRequestMs = 0;
         this.logger.info('offline resume started', {
             totalStanzas: stanzaCount
         });
@@ -41,7 +52,7 @@ class WaOfflineResumeCoordinator {
             remainingStanzas: stanzaCount,
             forced: false
         });
-        void this.sendOfflineBatch();
+        this.requestOfflineBatch();
         this.resetStanzaTimeout();
     }
     handleOfflineComplete(serverStanzaCount) {
@@ -55,17 +66,24 @@ class WaOfflineResumeCoordinator {
             return;
         }
         this.pendingStanzas = Math.max(0, this.pendingStanzas - 1);
+        this.batchInFlight = false;
         this.resetStanzaTimeout();
+        this.scheduleNextBatch();
     }
     reset() {
         this.clearTimers();
         this.state = WA_OFFLINE_RESUME_STATE.INIT;
         this.totalStanzas = 0;
         this.pendingStanzas = 0;
+        this.batchInFlight = false;
+        this.batchRetries = 0;
+        this.resumeGeneration += 1;
+        this.lastBatchRequestMs = 0;
     }
     completeResume(forced, serverStanzaCount) {
         this.clearTimers();
         this.state = WA_OFFLINE_RESUME_STATE.COMPLETE;
+        this.batchInFlight = false;
         this.logger.info('offline resume complete', {
             totalStanzas: this.totalStanzas,
             remainingStanzas: this.pendingStanzas,
@@ -79,14 +97,73 @@ class WaOfflineResumeCoordinator {
             forced
         });
     }
-    async sendOfflineBatch() {
+    /**
+     * Ask the server for the next window of queued stanzas, at most one request
+     * per `REQUEST_DEBOUNCE_MS` and never while one is still outstanding. Only a
+     * delivered stanza schedules a request, so the loop winds down on its own
+     * once the queue dries up; the resume itself ends on the terminal `offline`
+     * bulletin or on the stanza timeout, never on the preview counter, which is
+     * a progress estimate rather than an authoritative total.
+     */
+    scheduleNextBatch() {
+        if (this.batchInFlight || this.batchTimeout !== null) {
+            return;
+        }
+        const elapsedMs = Date.now() - this.lastBatchRequestMs;
+        if (elapsedMs >= WA_OFFLINE_RESUME.REQUEST_DEBOUNCE_MS) {
+            this.requestOfflineBatch();
+            return;
+        }
+        this.batchTimeout = setTimeout(() => {
+            this.batchTimeout = null;
+            if (this.state === WA_OFFLINE_RESUME_STATE.RESUMING) {
+                this.scheduleNextBatch();
+            }
+        }, WA_OFFLINE_RESUME.REQUEST_DEBOUNCE_MS - elapsedMs);
+    }
+    requestOfflineBatch() {
+        this.batchInFlight = true;
+        this.lastBatchRequestMs = Date.now();
+        this.logger.debug('offline batch requested', {
+            batchSize: WA_OFFLINE_RESUME.BATCH_SIZE,
+            remainingStanzas: this.pendingStanzas
+        });
+        void this.sendOfflineBatch(this.resumeGeneration);
+    }
+    /**
+     * A rejected request delivers no stanza, and only a delivered stanza
+     * schedules the next one, so without a retry here a single transport blip
+     * strands the whole queue until the stanza timeout. `generation` pins the
+     * outcome to the resume that issued it: a rejection from a torn-down resume
+     * must not clear the current one's in-flight flag or retry on its behalf.
+     */
+    async sendOfflineBatch(generation) {
         try {
             await this.runtime.sendNode((0, offline_1.buildOfflineBatchNode)(WA_OFFLINE_RESUME.BATCH_SIZE));
+            if (generation === this.resumeGeneration) {
+                this.batchRetries = 0;
+            }
         }
         catch (err) {
-            this.logger.warn('offline batch request failed', {
+            if (generation !== this.resumeGeneration ||
+                this.state !== WA_OFFLINE_RESUME_STATE.RESUMING) {
+                return;
+            }
+            this.batchInFlight = false;
+            this.batchRetries += 1;
+            if (this.batchRetries > WA_OFFLINE_RESUME.MAX_BATCH_RETRIES) {
+                this.logger.warn('offline batch request failed, giving up', {
+                    attempts: this.batchRetries,
+                    remainingStanzas: this.pendingStanzas,
+                    message: (0, primitives_1.toError)(err).message
+                });
+                return;
+            }
+            this.logger.debug('offline batch request failed, retrying', {
+                attempt: this.batchRetries,
                 message: (0, primitives_1.toError)(err).message
             });
+            this.scheduleNextBatch();
         }
     }
     resetStanzaTimeout() {
@@ -109,6 +186,10 @@ class WaOfflineResumeCoordinator {
             clearTimeout(this.stanzaTimeout);
             this.stanzaTimeout = null;
         }
+        if (this.batchTimeout !== null) {
+            clearTimeout(this.batchTimeout);
+            this.batchTimeout = null;
+        }
     }
 }
 exports.WaOfflineResumeCoordinator = WaOfflineResumeCoordinator;

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/client/types.d.ts

@@ -1458,9 +1458,19 @@ export interface WaClientEventMap {
 export interface WaOfflineResumeEvent {
     readonly status: 'resuming' | 'complete';
     readonly totalStanzas: number;
-    /** `0` on the terminal `'complete'` event. */
+    /**
+     * Stanzas still outstanding against `totalStanzas`, counted down from the
+     * server's preview figure. That figure is an estimate, so a clean finish
+     * can still report a small non-zero remainder. Read it together with
+     * `forced`: a remainder alongside `forced: true` is the case where the
+     * flush was cut short and the rest stays queued for the next connection.
+     */
     readonly remainingStanzas: number;
-    /** `true` when triggered by an explicit catch-up request rather than auto-resume on reconnect. */
+    /**
+     * `true` when the resume was closed by the client because the server went
+     * quiet for 60s instead of by the server's terminal `offline` bulletin.
+     * Pair with `remainingStanzas` to tell a clean finish from a cut-short one.
+     */
     readonly forced: boolean;
 }
 export interface WaOfflineThreadPreview {

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/WaOfflineResumeCoordinator.js

@@ -2,6 +2,8 @@ import { buildOfflineBatchNode } from '../../transport/node/builders/offline.js'
 import { toError } from '../../util/primitives.js';
 const WA_OFFLINE_RESUME = Object.freeze({
     BATCH_SIZE: 200,
+    REQUEST_DEBOUNCE_MS: 100,
+    MAX_BATCH_RETRIES: 3,
     STANZA_TIMEOUT_MS: 60000
 });
 const WA_OFFLINE_RESUME_STATE = Object.freeze({
@@ -16,6 +18,11 @@ export class WaOfflineResumeCoordinator {
         this.state = WA_OFFLINE_RESUME_STATE.INIT;
         this.totalStanzas = 0;
         this.pendingStanzas = 0;
+        this.batchInFlight = false;
+        this.batchRetries = 0;
+        this.resumeGeneration = 0;
+        this.lastBatchRequestMs = 0;
+        this.batchTimeout = null;
         this.stanzaTimeout = null;
     }
     get isComplete() {
@@ -29,6 +36,10 @@ export class WaOfflineResumeCoordinator {
         this.state = WA_OFFLINE_RESUME_STATE.RESUMING;
         this.totalStanzas = stanzaCount;
         this.pendingStanzas = stanzaCount;
+        this.batchInFlight = false;
+        this.batchRetries = 0;
+        this.resumeGeneration += 1;
+        this.lastBatchRequestMs = 0;
         this.logger.info('offline resume started', {
             totalStanzas: stanzaCount
         });
@@ -38,7 +49,7 @@ export class WaOfflineResumeCoordinator {
             remainingStanzas: stanzaCount,
             forced: false
         });
-        void this.sendOfflineBatch();
+        this.requestOfflineBatch();
         this.resetStanzaTimeout();
     }
     handleOfflineComplete(serverStanzaCount) {
@@ -52,17 +63,24 @@ export class WaOfflineResumeCoordinator {
             return;
         }
         this.pendingStanzas = Math.max(0, this.pendingStanzas - 1);
+        this.batchInFlight = false;
         this.resetStanzaTimeout();
+        this.scheduleNextBatch();
     }
     reset() {
         this.clearTimers();
         this.state = WA_OFFLINE_RESUME_STATE.INIT;
         this.totalStanzas = 0;
         this.pendingStanzas = 0;
+        this.batchInFlight = false;
+        this.batchRetries = 0;
+        this.resumeGeneration += 1;
+        this.lastBatchRequestMs = 0;
     }
     completeResume(forced, serverStanzaCount) {
         this.clearTimers();
         this.state = WA_OFFLINE_RESUME_STATE.COMPLETE;
+        this.batchInFlight = false;
         this.logger.info('offline resume complete', {
             totalStanzas: this.totalStanzas,
             remainingStanzas: this.pendingStanzas,
@@ -76,14 +94,73 @@ export class WaOfflineResumeCoordinator {
             forced
         });
     }
-    async sendOfflineBatch() {
+    /**
+     * Ask the server for the next window of queued stanzas, at most one request
+     * per `REQUEST_DEBOUNCE_MS` and never while one is still outstanding. Only a
+     * delivered stanza schedules a request, so the loop winds down on its own
+     * once the queue dries up; the resume itself ends on the terminal `offline`
+     * bulletin or on the stanza timeout, never on the preview counter, which is
+     * a progress estimate rather than an authoritative total.
+     */
+    scheduleNextBatch() {
+        if (this.batchInFlight || this.batchTimeout !== null) {
+            return;
+        }
+        const elapsedMs = Date.now() - this.lastBatchRequestMs;
+        if (elapsedMs >= WA_OFFLINE_RESUME.REQUEST_DEBOUNCE_MS) {
+            this.requestOfflineBatch();
+            return;
+        }
+        this.batchTimeout = setTimeout(() => {
+            this.batchTimeout = null;
+            if (this.state === WA_OFFLINE_RESUME_STATE.RESUMING) {
+                this.scheduleNextBatch();
+            }
+        }, WA_OFFLINE_RESUME.REQUEST_DEBOUNCE_MS - elapsedMs);
+    }
+    requestOfflineBatch() {
+        this.batchInFlight = true;
+        this.lastBatchRequestMs = Date.now();
+        this.logger.debug('offline batch requested', {
+            batchSize: WA_OFFLINE_RESUME.BATCH_SIZE,
+            remainingStanzas: this.pendingStanzas
+        });
+        void this.sendOfflineBatch(this.resumeGeneration);
+    }
+    /**
+     * A rejected request delivers no stanza, and only a delivered stanza
+     * schedules the next one, so without a retry here a single transport blip
+     * strands the whole queue until the stanza timeout. `generation` pins the
+     * outcome to the resume that issued it: a rejection from a torn-down resume
+     * must not clear the current one's in-flight flag or retry on its behalf.
+     */
+    async sendOfflineBatch(generation) {
         try {
             await this.runtime.sendNode(buildOfflineBatchNode(WA_OFFLINE_RESUME.BATCH_SIZE));
+            if (generation === this.resumeGeneration) {
+                this.batchRetries = 0;
+            }
         }
         catch (err) {
-            this.logger.warn('offline batch request failed', {
+            if (generation !== this.resumeGeneration ||
+                this.state !== WA_OFFLINE_RESUME_STATE.RESUMING) {
+                return;
+            }
+            this.batchInFlight = false;
+            this.batchRetries += 1;
+            if (this.batchRetries > WA_OFFLINE_RESUME.MAX_BATCH_RETRIES) {
+                this.logger.warn('offline batch request failed, giving up', {
+                    attempts: this.batchRetries,
+                    remainingStanzas: this.pendingStanzas,
+                    message: toError(err).message
+                });
+                return;
+            }
+            this.logger.debug('offline batch request failed, retrying', {
+                attempt: this.batchRetries,
                 message: toError(err).message
             });
+            this.scheduleNextBatch();
         }
     }
     resetStanzaTimeout() {
@@ -106,5 +183,9 @@ export class WaOfflineResumeCoordinator {
             clearTimeout(this.stanzaTimeout);
             this.stanzaTimeout = null;
         }
+        if (this.batchTimeout !== null) {
+            clearTimeout(this.batchTimeout);
+            this.batchTimeout = null;
+        }
     }
 }

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',