zapo-js 1.6.2 → 1.7.0

package/dist/client/persistence/WriteBehindPersistence.js

@@ -12,7 +12,8 @@ function mergeThread(previous, incoming) {
         pinned: incoming.pinned ?? previous.pinned,
         muteEndMs: incoming.muteEndMs ?? previous.muteEndMs,
         markedAsUnread: incoming.markedAsUnread ?? previous.markedAsUnread,
-        ephemeralExpiration: incoming.ephemeralExpiration ?? previous.ephemeralExpiration
+        ephemeralExpiration: incoming.ephemeralExpiration ?? previous.ephemeralExpiration,
+        ephemeralSettingTimestamp: incoming.ephemeralSettingTimestamp ?? previous.ephemeralSettingTimestamp
     };
 }
 function mergeContact(previous, incoming) {

package/dist/client/persistence/ephemeral-setting.d.ts

@@ -0,0 +1,42 @@
+import type { WriteBehindPersistence } from '../persistence/WriteBehindPersistence';
+import type { WaIncomingMessageEvent } from '../types';
+import type { Logger } from '../../infra/log/types';
+import type { Proto } from '../../proto';
+import type { WaChatMetadataStore } from '../../store/contracts/chat-metadata.store';
+export interface WaPersistIncomingEphemeralSettingOptions {
+    readonly logger: Logger;
+    readonly writeBehind: WriteBehindPersistence;
+    readonly event: WaIncomingMessageEvent;
+    readonly protocolMessage: Proto.Message.IProtocolMessage;
+    readonly chatMetadataStore: WaChatMetadataStore;
+}
+/**
+ * Persists a 1:1 `EPHEMERAL_SETTING` protocol message so outgoing sends pick up
+ * the peer's change without waiting for history sync. Groups are skipped –
+ * their timer comes from group notifications, not protocol messages.
+ */
+export declare function persistIncomingEphemeralSetting(options: WaPersistIncomingEphemeralSettingOptions): void;
+export interface WaEphemeralObserverOptions {
+    readonly logger: Logger;
+    readonly chatMetadataStore: WaChatMetadataStore;
+}
+/**
+ * Builds the inbound observer that refreshes the chat-metadata cache from
+ * ordinary traffic. A peer stamps `contextInfo.ephemeralSettingTimestamp` on
+ * every message in a disappearing chat, making it the only continuously
+ * refreshed source - history sync and `EPHEMERAL_SETTING` are point-in-time.
+ *
+ * Never blocks and never rejects: the store round-trip is fire-and-forget.
+ * Messages repeating a value share one round-trip, so the batch an offline
+ * resume delivers costs a single read instead of one per message, while a
+ * message carrying a *different* value still gets its own round-trip rather
+ * than being swallowed by the one in flight.
+ *
+ * A write skips a setting older than the cached one, mirroring how the peer
+ * resolves it: highest timestamp wins. That check is not atomic with the
+ * write, so two round-trips that both read a cold cache can still land out of
+ * order and leave the older value behind. The next message from the chat
+ * corrects it, and a stale-but-older stamp loses to the peer's own value
+ * anyway, so this is not worth serializing the receive path over.
+ */
+export declare function createEphemeralObserver(options: WaEphemeralObserverOptions): (event: WaIncomingMessageEvent) => void;

package/dist/client/persistence/ephemeral-setting.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.persistIncomingEphemeralSetting = persistIncomingEphemeralSetting;
+exports.createEphemeralObserver = createEphemeralObserver;
+const PromiseDedup_1 = require("../../infra/perf/PromiseDedup");
+const context_info_1 = require("../../message/context-info");
+const jid_1 = require("../../protocol/jid");
+const message_1 = require("../../protocol/message");
+const primitives_1 = require("../../util/primitives");
+/**
+ * Persists a 1:1 `EPHEMERAL_SETTING` protocol message so outgoing sends pick up
+ * the peer's change without waiting for history sync. Groups are skipped –
+ * their timer comes from group notifications, not protocol messages.
+ */
+function persistIncomingEphemeralSetting(options) {
+    const { logger, writeBehind, event, protocolMessage, chatMetadataStore } = options;
+    const chatJid = event.key.remoteJid;
+    if (!chatJid || event.key.isGroup || (0, jid_1.isGroupJid)(chatJid)) {
+        return;
+    }
+    const expiration = protocolMessage.ephemeralExpiration ?? 0;
+    const rawTimestamp = protocolMessage.ephemeralSettingTimestamp !== undefined &&
+        protocolMessage.ephemeralSettingTimestamp !== null
+        ? (0, primitives_1.longToNumber)(protocolMessage.ephemeralSettingTimestamp)
+        : event.timestampSeconds;
+    const settingTimestamp = rawTimestamp !== undefined ? (0, message_1.normalizeEphemeralSettingSeconds)(rawTimestamp) : undefined;
+    void chatMetadataStore
+        .upsertChatMetadata({
+        chatJid,
+        ephemeralExpiration: expiration,
+        ...(settingTimestamp !== undefined
+            ? { ephemeralSettingTimestamp: settingTimestamp }
+            : {}),
+        updatedAtMs: Date.now()
+    })
+        .catch((error) => {
+        logger.debug('failed to cache incoming ephemeral setting', {
+            jid: chatJid,
+            message: (0, primitives_1.toError)(error).message
+        });
+    });
+    try {
+        writeBehind.persistThread({
+            jid: chatJid,
+            ephemeralExpiration: expiration,
+            ...(settingTimestamp !== undefined
+                ? { ephemeralSettingTimestamp: settingTimestamp }
+                : {})
+        });
+    }
+    catch (error) {
+        logger.warn('failed to persist incoming ephemeral setting', {
+            jid: chatJid,
+            expiration,
+            message: (0, primitives_1.toError)(error).message
+        });
+    }
+}
+/**
+ * Builds the inbound observer that refreshes the chat-metadata cache from
+ * ordinary traffic. A peer stamps `contextInfo.ephemeralSettingTimestamp` on
+ * every message in a disappearing chat, making it the only continuously
+ * refreshed source - history sync and `EPHEMERAL_SETTING` are point-in-time.
+ *
+ * Never blocks and never rejects: the store round-trip is fire-and-forget.
+ * Messages repeating a value share one round-trip, so the batch an offline
+ * resume delivers costs a single read instead of one per message, while a
+ * message carrying a *different* value still gets its own round-trip rather
+ * than being swallowed by the one in flight.
+ *
+ * A write skips a setting older than the cached one, mirroring how the peer
+ * resolves it: highest timestamp wins. That check is not atomic with the
+ * write, so two round-trips that both read a cold cache can still land out of
+ * order and leave the older value behind. The next message from the chat
+ * corrects it, and a stale-but-older stamp loses to the peer's own value
+ * anyway, so this is not worth serializing the receive path over.
+ */
+function createEphemeralObserver(options) {
+    const { logger, chatMetadataStore } = options;
+    const dedup = new PromiseDedup_1.PromiseDedup();
+    return (event) => {
+        const expiration = event.expirationSeconds;
+        if (expiration === undefined || expiration <= 0) {
+            return;
+        }
+        const chatJid = event.key.remoteJid;
+        if (!chatJid || event.key.isGroup || event.key.isNewsletter || (0, jid_1.isGroupJid)(chatJid)) {
+            return;
+        }
+        const raw = (0, context_info_1.pickIncomingEphemeralSettingTimestamp)(event.message);
+        if (raw === undefined) {
+            return;
+        }
+        const settingTimestamp = (0, message_1.normalizeEphemeralSettingSeconds)(raw);
+        void dedup
+            .run(`observe:${chatJid}:${expiration}:${settingTimestamp}`, async () => {
+            const cached = await chatMetadataStore.getChatMetadata(chatJid);
+            if (cached?.ephemeralSettingTimestamp === settingTimestamp &&
+                cached.ephemeralExpiration === expiration) {
+                return;
+            }
+            if (cached?.ephemeralSettingTimestamp !== undefined &&
+                cached.ephemeralSettingTimestamp > settingTimestamp) {
+                return;
+            }
+            await chatMetadataStore.upsertChatMetadata({
+                chatJid,
+                ephemeralExpiration: expiration,
+                ephemeralSettingTimestamp: settingTimestamp,
+                updatedAtMs: Date.now()
+            });
+        })
+            .catch((error) => {
+            logger.debug('failed to cache observed ephemeral setting', {
+                jid: chatJid,
+                message: (0, primitives_1.toError)(error).message
+            });
+        });
+    };
+}

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

@@ -0,0 +1,29 @@
+import type { WaAbPropName } from '../../abprops-spec';
+import type { WriteBehindPersistence } from '../persistence/WriteBehindPersistence';
+import type { WaClientEventMap } from '../types';
+import type { Logger } from '../../infra/log/types';
+import type { WaMediaTransferClient } from '../../media/transfer/WaMediaTransferClient';
+import { type Proto } from '../../proto';
+export interface WaGroupHistoryBundleInput {
+    /** The `messageHistoryBundle` payload carried by the incoming message. */
+    readonly bundle: Proto.Message.IMessageHistoryBundle;
+    /** Group the bundle was shared in - the `remoteJid` of the carrier message. */
+    readonly groupJid: string;
+    /** Member who shared the history (carrier message `participant`). */
+    readonly senderJid?: string;
+    /** Stanza id of the carrier message. */
+    readonly bundleMessageId?: string;
+    /** Carrier message `t` attr, in seconds - drives the bundle expiry check. */
+    readonly sentAtSeconds?: number;
+}
+export interface WaGroupHistoryDeps {
+    readonly logger: Logger;
+    readonly mediaTransfer: WaMediaTransferClient;
+    readonly writeBehind: WriteBehindPersistence;
+    readonly emitEvent: <K extends keyof WaClientEventMap>(event: K, ...args: Parameters<WaClientEventMap[K]>) => void;
+    readonly meJid?: string | null;
+    readonly meLid?: string | null;
+    readonly getAbPropNumber: (name: WaAbPropName) => number;
+}
+export declare function runGroupHistoryBundle(deps: WaGroupHistoryDeps, input: WaGroupHistoryBundleInput): Promise<void>;
+export declare function processGroupHistoryBundle(deps: WaGroupHistoryDeps, input: WaGroupHistoryBundleInput): Promise<void>;

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

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runGroupHistoryBundle = runGroupHistoryBundle;
+exports.processGroupHistoryBundle = processGroupHistoryBundle;
+const history_blob_1 = require("../persistence/history-blob");
+const group_history_1 = require("../../message/kinds/group-history");
+const _proto_1 = require("../../proto");
+const jid_1 = require("../../protocol/jid");
+const primitives_1 = require("../../util/primitives");
+const GROUP_HISTORY_MAX_PENDING_WRITES = 1024;
+async function runGroupHistoryBundle(deps, input) {
+    try {
+        await processGroupHistoryBundle(deps, input);
+    }
+    catch (error) {
+        deps.logger.warn('failed to process group history bundle', {
+            groupJid: input.groupJid,
+            id: input.bundleMessageId,
+            message: (0, primitives_1.toError)(error).message
+        });
+    }
+}
+async function processGroupHistoryBundle(deps, input) {
+    const logger = deps.logger.child({
+        groupJid: input.groupJid,
+        id: input.bundleMessageId
+    });
+    if (!(0, jid_1.isGroupJid)(input.groupJid)) {
+        logger.debug('skipping group history bundle outside a group');
+        return;
+    }
+    if (!isHistoryReceiver(deps, input.bundle)) {
+        logger.debug('skipping group history bundle not addressed to this account');
+        return;
+    }
+    const nowMs = Date.now();
+    const bundleTtlSeconds = deps.getAbPropNumber('group_history_bundle_time_limit_receiver_enforcement_secs');
+    if (input.sentAtSeconds !== undefined &&
+        nowMs > (input.sentAtSeconds + bundleTtlSeconds) * 1000) {
+        logger.debug('skipping expired group history bundle', {
+            sentAtSeconds: input.sentAtSeconds,
+            bundleTtlSeconds
+        });
+        return;
+    }
+    const blob = await (0, history_blob_1.downloadHistoryBlob)(deps.mediaTransfer, input.bundle, 'group-history', 'group history bundle');
+    const history = await (0, group_history_1.decodeGroupHistoryBundle)(blob);
+    const messageTtlSeconds = deps.getAbPropNumber('group_history_messages_time_limit_receiver_enforcement_secs');
+    const pendingWrites = [];
+    const dropped = { foreignChat: 0, ephemeralExpired: 0, tooOld: 0, stub: 0 };
+    let messagesCount = 0;
+    let oldestTimestampMs;
+    for (const source of [
+        { messages: history.messages, skipAgeCheck: false },
+        { messages: history.outOfWindowPinnedMessages, skipAgeCheck: true }
+    ]) {
+        for (const webMsg of source.messages) {
+            if (!webMsg.key?.id || !webMsg.message) {
+                dropped.stub += 1;
+                continue;
+            }
+            if (webMsg.key.remoteJid && webMsg.key.remoteJid !== input.groupJid) {
+                dropped.foreignChat += 1;
+                continue;
+            }
+            const timestampSeconds = (0, primitives_1.longToNumber)(webMsg.messageTimestamp);
+            if (isEphemeralExpired(webMsg, timestampSeconds, nowMs)) {
+                dropped.ephemeralExpired += 1;
+                continue;
+            }
+            if (!source.skipAgeCheck &&
+                timestampSeconds > 0 &&
+                (timestampSeconds + 2 * messageTtlSeconds) * 1000 < nowMs) {
+                dropped.tooOld += 1;
+                continue;
+            }
+            const timestampMs = timestampSeconds * 1000;
+            if (timestampMs > 0 &&
+                (oldestTimestampMs === undefined || timestampMs < oldestTimestampMs)) {
+                oldestTimestampMs = timestampMs;
+            }
+            pendingWrites[pendingWrites.length] = deps.writeBehind.persistMessageAsync({
+                id: webMsg.key.id,
+                threadJid: input.groupJid,
+                senderJid: webMsg.key.participant ?? undefined,
+                fromMe: webMsg.key.fromMe === true,
+                timestampMs: timestampMs || undefined,
+                messageBytes: _proto_1.proto.Message.encode(webMsg.message).finish()
+            });
+            if (pendingWrites.length >= GROUP_HISTORY_MAX_PENDING_WRITES) {
+                await (0, history_blob_1.flushPendingWrites)(pendingWrites);
+            }
+            messagesCount += 1;
+        }
+    }
+    await (0, history_blob_1.flushPendingWrites)(pendingWrites);
+    const droppedCount = dropped.foreignChat + dropped.ephemeralExpired + dropped.tooOld + dropped.stub;
+    logger.debug('processed group history bundle', {
+        messagesCount,
+        outOfWindowPinsCount: history.outOfWindowPinnedMessages.length,
+        droppedCount,
+        dropped
+    });
+    const event = {
+        groupJid: input.groupJid,
+        senderJid: input.senderJid,
+        bundleMessageId: input.bundleMessageId,
+        messagesCount,
+        outOfWindowPinsCount: history.outOfWindowPinnedMessages.length,
+        droppedCount,
+        oldestTimestampMs,
+        historyReceivers: [...(input.bundle.messageHistoryMetadata?.historyReceivers ?? [])]
+    };
+    deps.emitEvent('group_history_bundle', event);
+}
+/**
+ * A bundle is only ours to process when this account is listed in
+ * `historyReceivers`. The list may address us by either PN or LID, so both
+ * forms of the local identity are compared.
+ */
+function isHistoryReceiver(deps, bundle) {
+    const receivers = bundle.messageHistoryMetadata?.historyReceivers;
+    if (!receivers || receivers.length === 0) {
+        return false;
+    }
+    const meUserJid = deps.meJid ? (0, jid_1.toUserJid)(deps.meJid) : null;
+    const meUserLid = deps.meLid ? (0, jid_1.toUserJid)(deps.meLid) : null;
+    if (!meUserJid && !meUserLid) {
+        return false;
+    }
+    for (let index = 0; index < receivers.length; index += 1) {
+        const receiver = (0, jid_1.toUserJid)(receivers[index]);
+        if (receiver === meUserJid || receiver === meUserLid) {
+            return true;
+        }
+    }
+    return false;
+}
+function isEphemeralExpired(webMsg, timestampSeconds, nowMs) {
+    const duration = webMsg.ephemeralDuration;
+    if (!duration) {
+        return false;
+    }
+    const startSeconds = (0, primitives_1.longToNumber)(webMsg.ephemeralStartTimestamp) || timestampSeconds;
+    if (startSeconds <= 0) {
+        return false;
+    }
+    return (startSeconds + duration) * 1000 <= nowMs;
+}

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

@@ -0,0 +1,25 @@
+import type { WaMediaTransferClient } from '../../media/transfer/WaMediaTransferClient';
+import type { MediaCryptoType } from '../../media/types';
+/**
+ * Encrypted-blob fields shared by the history-sync notification and the
+ * group-history bundle: both point at a CDN object plus the key and hashes
+ * needed to decrypt and verify it.
+ */
+export interface WaHistoryBlobSource {
+    readonly directPath?: string | null;
+    readonly mediaKey?: Uint8Array | string | null;
+    readonly fileSha256?: Uint8Array | string | null;
+    readonly fileEncSha256?: Uint8Array | string | null;
+}
+/**
+ * Fetches and decrypts a history blob. `label` prefixes the field errors so a
+ * failure names which payload was malformed.
+ *
+ * @throws when `directPath` is absent or a key/hash field is missing.
+ */
+export declare function downloadHistoryBlob(mediaTransfer: WaMediaTransferClient, source: WaHistoryBlobSource, mediaType: MediaCryptoType, label: string): Promise<Uint8Array>;
+/**
+ * Awaits an accumulating write batch and empties it in place, so the caller can
+ * keep filling the same array instead of allocating a new one per chunk.
+ */
+export declare function flushPendingWrites(pendingWrites: Promise<void>[]): Promise<void>;

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

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadHistoryBlob = downloadHistoryBlob;
+exports.flushPendingWrites = flushPendingWrites;
+const bytes_1 = require("../../util/bytes");
+/**
+ * Fetches and decrypts a history blob. `label` prefixes the field errors so a
+ * failure names which payload was malformed.
+ *
+ * @throws when `directPath` is absent or a key/hash field is missing.
+ */
+async function downloadHistoryBlob(mediaTransfer, source, mediaType, label) {
+    if (!source.directPath) {
+        throw new Error(`${label} missing directPath`);
+    }
+    const mediaKey = (0, bytes_1.decodeProtoBytes)(source.mediaKey, `${label} mediaKey`);
+    const fileSha256 = (0, bytes_1.decodeProtoBytes)(source.fileSha256, `${label} fileSha256`);
+    const fileEncSha256 = (0, bytes_1.decodeProtoBytes)(source.fileEncSha256, `${label} fileEncSha256`);
+    return mediaTransfer.downloadAndDecrypt({
+        directPath: source.directPath,
+        mediaType,
+        mediaKey,
+        fileSha256,
+        fileEncSha256
+    });
+}
+/**
+ * Awaits an accumulating write batch and empties it in place, so the caller can
+ * keep filling the same array instead of allocating a new one per chunk.
+ */
+async function flushPendingWrites(pendingWrites) {
+    if (pendingWrites.length === 0) {
+        return;
+    }
+    const settled = Promise.all(pendingWrites);
+    pendingWrites.length = 0;
+    await settled;
+}

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

@@ -3,10 +3,12 @@ import type { WaClientEventMap } from '../types';
 import type { Logger } from '../../infra/log/types';
 import type { WaMediaTransferClient } from '../../media/transfer/WaMediaTransferClient';
 import { type Proto } from '../../proto';
+import type { WaChatMetadataStore } from '../../store/contracts/chat-metadata.store';
 interface WaHistorySyncDeps {
     readonly logger: Logger;
     readonly mediaTransfer: WaMediaTransferClient;
     readonly writeBehind: WriteBehindPersistence;
+    readonly chatMetadataStore?: WaChatMetadataStore;
     readonly emitEvent: <K extends keyof WaClientEventMap>(event: K, ...args: Parameters<WaClientEventMap[K]>) => void;
     readonly onPrivacyTokens?: (conversations: readonly {
         readonly jid: string;

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

@@ -4,8 +4,10 @@ exports.runHistorySyncNotification = runHistorySyncNotification;
 exports.processHistorySyncNotification = processHistorySyncNotification;
 const node_util_1 = require("node:util");
 const node_zlib_1 = require("node:zlib");
+const history_blob_1 = require("../persistence/history-blob");
 const _proto_1 = require("../../proto");
 const jid_1 = require("../../protocol/jid");
+const message_1 = require("../../protocol/message");
 const bytes_1 = require("../../util/bytes");
 const primitives_1 = require("../../util/primitives");
 const unzipAsync = (0, node_util_1.promisify)(node_zlib_1.unzip);
@@ -98,7 +100,7 @@ async function processHistorySyncNotification(deps, notification) {
                 lastUpdatedMs: nowMs
             });
         if (pendingWrites.length >= HISTORY_SYNC_MAX_PENDING_WRITES) {
-            await flushPendingWrites(pendingWrites);
+            await (0, history_blob_1.flushPendingWrites)(pendingWrites);
         }
     }
     for (const c of historySync.inlineContacts ?? []) {
@@ -117,7 +119,7 @@ async function processHistorySyncNotification(deps, notification) {
             lastUpdatedMs: nowMs
         });
         if (pendingWrites.length >= HISTORY_SYNC_MAX_PENDING_WRITES) {
-            await flushPendingWrites(pendingWrites);
+            await (0, history_blob_1.flushPendingWrites)(pendingWrites);
         }
     }
     let messagesCount = 0;
@@ -127,6 +129,25 @@ async function processHistorySyncNotification(deps, notification) {
             deps.logger.debug('skipping history sync conversation without thread jid');
             continue;
         }
+        const ephemeralExpiration = conversation.ephemeralExpiration ?? undefined;
+        const ephemeralSettingTimestamp = (0, message_1.normalizeEphemeralSettingSeconds)((0, primitives_1.longToNumber)(conversation.ephemeralSettingTimestamp)) || undefined;
+        if (deps.chatMetadataStore && ephemeralExpiration !== undefined) {
+            pendingWrites[pendingWrites.length] = deps.chatMetadataStore
+                .upsertChatMetadata({
+                chatJid: threadJid,
+                ephemeralExpiration,
+                ...(ephemeralSettingTimestamp !== undefined
+                    ? { ephemeralSettingTimestamp }
+                    : {}),
+                updatedAtMs: nowMs
+            })
+                .catch((error) => {
+                deps.logger.debug('failed to cache history sync chat metadata', {
+                    jid: threadJid,
+                    message: (0, primitives_1.toError)(error).message
+                });
+            });
+        }
         pendingWrites[pendingWrites.length] = deps.writeBehind.persistThreadAsync({
             jid: threadJid,
             name: conversation.name ?? undefined,
@@ -135,10 +156,11 @@ async function processHistorySyncNotification(deps, notification) {
             pinned: conversation.pinned ?? undefined,
             muteEndMs: (0, primitives_1.longToNumber)(conversation.muteEndTime) || undefined,
             markedAsUnread: conversation.markedAsUnread ?? undefined,
-            ephemeralExpiration: conversation.ephemeralExpiration ?? undefined
+            ephemeralExpiration,
+            ephemeralSettingTimestamp
         });
         if (pendingWrites.length >= HISTORY_SYNC_MAX_PENDING_WRITES) {
-            await flushPendingWrites(pendingWrites);
+            await (0, history_blob_1.flushPendingWrites)(pendingWrites);
         }
         if ((0, jid_1.isUserJid)(threadJid) || (conversation.lidJid ?? conversation.accountLid)) {
             const contactDisplay = conversation.displayName || conversation.username || undefined;
@@ -153,7 +175,7 @@ async function processHistorySyncNotification(deps, notification) {
                     lastUpdatedMs: nowMs
                 });
                 if (pendingWrites.length >= HISTORY_SYNC_MAX_PENDING_WRITES) {
-                    await flushPendingWrites(pendingWrites);
+                    await (0, history_blob_1.flushPendingWrites)(pendingWrites);
                 }
             }
         }
@@ -176,7 +198,7 @@ async function processHistorySyncNotification(deps, notification) {
                 messageBytes: _proto_1.proto.Message.encode(webMsg.message).finish()
             });
             if (pendingWrites.length >= HISTORY_SYNC_MAX_PENDING_WRITES) {
-                await flushPendingWrites(pendingWrites);
+                await (0, history_blob_1.flushPendingWrites)(pendingWrites);
             }
             messagesCount += 1;
         }
@@ -191,7 +213,7 @@ async function processHistorySyncNotification(deps, notification) {
             lastUpdatedMs: nowMs
         });
         if (pendingWrites.length >= HISTORY_SYNC_MAX_PENDING_WRITES) {
-            await flushPendingWrites(pendingWrites);
+            await (0, history_blob_1.flushPendingWrites)(pendingWrites);
         }
     }
     if (deps.onPrivacyTokens) {
@@ -226,35 +248,15 @@ async function processHistorySyncNotification(deps, notification) {
         chunkOrder: historySync.chunkOrder ?? undefined,
         progress: historySync.progress ?? undefined
     };
-    await flushPendingWrites(pendingWrites);
+    await (0, history_blob_1.flushPendingWrites)(pendingWrites);
     deps.emitEvent('history_sync_chunk', event);
     if (deps.onProcessed) {
         await deps.onProcessed(syncType);
     }
 }
-async function flushPendingWrites(pendingWrites) {
-    if (pendingWrites.length === 0) {
-        return;
-    }
-    const settled = Promise.all(pendingWrites);
-    pendingWrites.length = 0;
-    await settled;
-}
 async function downloadHistorySyncBlob(deps, notification) {
     if (notification.initialHistBootstrapInlinePayload) {
         return (0, bytes_1.decodeProtoBytes)(notification.initialHistBootstrapInlinePayload, 'initialHistBootstrapInlinePayload');
     }
-    if (!notification.directPath) {
-        throw new Error('history sync notification missing directPath');
-    }
-    const mediaKey = (0, bytes_1.decodeProtoBytes)(notification.mediaKey, 'history sync mediaKey');
-    const fileSha256 = (0, bytes_1.decodeProtoBytes)(notification.fileSha256, 'history sync fileSha256');
-    const fileEncSha256 = (0, bytes_1.decodeProtoBytes)(notification.fileEncSha256, 'history sync fileEncSha256');
-    return deps.mediaTransfer.downloadAndDecrypt({
-        directPath: notification.directPath,
-        mediaType: 'history',
-        mediaKey,
-        fileSha256,
-        fileEncSha256
-    });
+    return (0, history_blob_1.downloadHistoryBlob)(deps.mediaTransfer, notification, 'history', 'history sync');
 }