zapo-js 0.1.2 → 0.3.0

package/dist/esm/client/messages.js

@@ -1,11 +1,12 @@
+import { createReadStream } from 'node:fs';
+import { cleanupTempFile, hasMediaProcessingTasks, isReadableStream, parseWebpAnimation, readFileHead, resolveMediaInputs, runMediaProcessor } from './media.js';
 import { parseMediaConnResponse } from '../media/conn.js';
 import { MEDIA_CONN_CACHE_GRACE_MS, MEDIA_UPLOAD_PATHS } from '../media/constants.js';
 import { WaMediaCrypto } from '../media/WaMediaCrypto.js';
 import { isSendMediaMessage } from '../message/content.js';
 import { WA_DEFAULTS } from '../protocol/constants.js';
 import { buildMediaConnIq } from '../transport/node/builders/media.js';
-import { bytesToBase64UrlSafe } from '../util/bytes.js';
-import { TEXT_DECODER, toBytesView } from '../util/bytes.js';
+import { bytesToBase64UrlSafe, TEXT_DECODER } from '../util/bytes.js';
 import { toError } from '../util/primitives.js';
 export async function buildMediaMessageContent(options, content) {
     if (typeof content === 'string') {
@@ -31,86 +32,198 @@ export async function getMediaConn(options, forceRefresh = false) {
     options.setMediaConnCache(mediaConn);
     return mediaConn;
 }
+function needsSidecar(content) {
+    return content.type === 'video' || content.type === 'ptv' || content.type === 'audio';
+}
+function resolveUploadType(content) {
+    if (content.type === 'video' && content.gifPlayback)
+        return 'gif';
+    if (content.type === 'audio' && content.ptt)
+        return 'ptt';
+    return content.type;
+}
+function resolveMimetype(content) {
+    if (content.mimetype)
+        return content.mimetype;
+    if (content.type === 'sticker')
+        return 'image/webp';
+    throw new Error(`mimetype is required for ${content.type} messages`);
+}
 async function buildMediaMessage(options, content) {
-    const mediaBytes = toBytesView(content.media);
-    const uploaded = await uploadMedia(options, content, mediaBytes);
-    const mediaKeyTimestamp = Math.floor(Date.now() / 1000);
-    const common = {
-        url: uploaded.url,
-        mimetype: content.mimetype,
-        fileSha256: uploaded.fileSha256,
-        fileLength: mediaBytes.byteLength,
-        mediaKey: uploaded.mediaKey,
-        fileEncSha256: uploaded.fileEncSha256,
-        directPath: uploaded.directPath,
-        mediaKeyTimestamp
-    };
-    switch (content.type) {
-        case 'image':
-            return {
-                imageMessage: {
-                    ...common,
-                    caption: content.caption,
-                    width: content.width,
-                    height: content.height
-                }
-            };
-        case 'video':
-            return {
-                videoMessage: {
-                    ...common,
-                    caption: content.caption,
-                    gifPlayback: content.gifPlayback,
-                    seconds: content.seconds,
-                    width: content.width,
-                    height: content.height,
-                    metadataUrl: uploaded.metadataUrl
-                }
-            };
-        case 'audio':
-            return {
-                audioMessage: {
-                    ...common,
-                    seconds: content.seconds,
-                    ptt: content.ptt
-                }
-            };
-        case 'document':
-            return {
-                documentMessage: {
-                    ...common,
-                    caption: content.caption,
-                    fileName: content.fileName ?? 'file',
-                    title: content.fileName ?? undefined
-                }
-            };
-        case 'sticker':
-            return {
-                stickerMessage: {
-                    ...common,
-                    width: content.width,
-                    height: content.height
+    const needsTempFile = hasMediaProcessingTasks(options.media, content) ||
+        (content.type === 'sticker' && content.firstFrameLength === undefined);
+    const resolved = await resolveMediaInputs(needsTempFile, content.media);
+    try {
+        let detectedFirstFrameLength;
+        if (content.type === 'sticker' &&
+            content.firstFrameLength === undefined &&
+            resolved.processorInput) {
+            const input = resolved.processorInput;
+            const header = typeof input === 'string' ? await readFileHead(input, 100) : input.subarray(0, 100);
+            detectedFirstFrameLength = parseWebpAnimation(header)?.firstFrameLength;
+        }
+        const firstFrameLength = content.type === 'sticker'
+            ? (content.firstFrameLength ?? detectedFirstFrameLength)
+            : undefined;
+        const uploadPromise = isReadableStream(resolved.uploadMedia)
+            ? uploadMediaStream(options, content, resolved.uploadMedia, firstFrameLength)
+            : uploadMediaBytes(options, content, resolved.uploadMedia, firstFrameLength);
+        const processPromise = runMediaProcessor(options.media, resolved.processorInput, content, options.logger);
+        const [uploadResult, processResult] = await Promise.allSettled([
+            uploadPromise,
+            processPromise
+        ]);
+        if (uploadResult.status === 'rejected')
+            throw uploadResult.reason;
+        if (processResult.status === 'rejected')
+            throw processResult.reason;
+        const uploaded = uploadResult.value;
+        const processed = processResult.value;
+        const mediaKeyTimestamp = Math.floor(Date.now() / 1000);
+        const uploadedFields = {
+            url: uploaded.url,
+            fileSha256: uploaded.fileSha256,
+            fileLength: uploaded.fileLength,
+            mediaKey: uploaded.mediaKey,
+            fileEncSha256: uploaded.fileEncSha256,
+            directPath: uploaded.directPath,
+            mediaKeyTimestamp,
+            mimetype: resolveMimetype(content)
+        };
+        function spread(c) {
+            const result = {};
+            for (const key in c) {
+                if (key !== 'type' &&
+                    key !== 'media' &&
+                    key !== 'fileLength' &&
+                    key !== 'mimetype') {
+                    result[key] = c[key];
                 }
-            };
-        default:
-            throw new Error(`unsupported media type: ${content.type}`);
+            }
+            return result;
+        }
+        switch (content.type) {
+            case 'image':
+                return {
+                    imageMessage: {
+                        ...spread(content),
+                        ...uploadedFields,
+                        width: content.width ?? processed.width,
+                        height: content.height ?? processed.height,
+                        jpegThumbnail: content.jpegThumbnail ?? processed.jpegThumbnail
+                    }
+                };
+            case 'video':
+                return {
+                    videoMessage: {
+                        ...spread(content),
+                        ...uploadedFields,
+                        seconds: content.seconds ?? processed.seconds,
+                        width: content.width ?? processed.width,
+                        height: content.height ?? processed.height,
+                        jpegThumbnail: content.jpegThumbnail ?? processed.jpegThumbnail,
+                        streamingSidecar: uploaded.streamingSidecar,
+                        metadataUrl: uploaded.metadataUrl
+                    }
+                };
+            case 'ptv':
+                return {
+                    ptvMessage: {
+                        ...spread(content),
+                        ...uploadedFields,
+                        seconds: content.seconds ?? processed.seconds,
+                        width: content.width ?? processed.width,
+                        height: content.height ?? processed.height,
+                        jpegThumbnail: content.jpegThumbnail ?? processed.jpegThumbnail,
+                        streamingSidecar: uploaded.streamingSidecar
+                    }
+                };
+            case 'audio':
+                return {
+                    audioMessage: {
+                        ...spread(content),
+                        ...uploadedFields,
+                        seconds: content.seconds ?? processed.seconds,
+                        streamingSidecar: uploaded.streamingSidecar,
+                        waveform: content.waveform ?? processed.waveform
+                    }
+                };
+            case 'document':
+                return {
+                    documentMessage: {
+                        ...spread(content),
+                        ...uploadedFields,
+                        fileName: content.fileName ?? 'file',
+                        title: content.title ?? content.fileName ?? undefined,
+                        jpegThumbnail: content.jpegThumbnail ?? processed.jpegThumbnail
+                    }
+                };
+            case 'sticker':
+                return {
+                    stickerMessage: {
+                        ...spread(content),
+                        ...uploadedFields,
+                        width: content.width ?? processed.width,
+                        height: content.height ?? processed.height,
+                        pngThumbnail: content.pngThumbnail ?? processed.pngThumbnail,
+                        isAnimated: content.isAnimated ??
+                            processed.isAnimated ??
+                            firstFrameLength !== undefined,
+                        firstFrameLength: content.firstFrameLength ?? uploaded.firstFrameLength,
+                        firstFrameSidecar: content.firstFrameSidecar ?? uploaded.firstFrameSidecar,
+                        stickerSentTs: content.stickerSentTs ?? Date.now()
+                    }
+                };
+            default:
+                throw new Error(`unsupported media message type: ${String(content.type)}`);
+        }
+    }
+    finally {
+        if (resolved.tempFilePath) {
+            await cleanupTempFile(resolved.tempFilePath);
+        }
+    }
+}
+function buildUploadUrl(host, uploadType, auth, fileEncSha256) {
+    const hashToken = bytesToBase64UrlSafe(fileEncSha256);
+    const uploadPath = MEDIA_UPLOAD_PATHS[uploadType];
+    if (!uploadPath) {
+        throw new Error(`unknown media upload type: ${String(uploadType)}`);
+    }
+    return `https://${host}${uploadPath}/${hashToken}?auth=${encodeURIComponent(auth)}&token=${encodeURIComponent(hashToken)}`;
+}
+function parseUploadResponse(body, status) {
+    if (status < 200 || status >= 300) {
+        throw new Error(`media upload failed with status ${status}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(TEXT_DECODER.decode(body));
+    }
+    catch (error) {
+        throw new Error(`media upload returned invalid json: ${toError(error).message}`);
     }
+    if (!parsed.url || !parsed.direct_path) {
+        throw new Error('media upload response missing url/direct_path');
+    }
+    return {
+        url: parsed.url,
+        directPath: parsed.direct_path,
+        ...(parsed.metadata_url ? { metadataUrl: parsed.metadata_url } : {})
+    };
 }
-async function uploadMedia(options, content, mediaBytes) {
+async function uploadMediaBytes(options, content, mediaBytes, firstFrameLength) {
+    const uploadType = resolveUploadType(content);
     const mediaKey = await WaMediaCrypto.generateMediaKey();
-    const uploadType = content.type === 'video' && content.gifPlayback
-        ? 'gif'
-        : content.type === 'audio' && content.ptt
-            ? 'ptt'
-            : content.type;
     const [encrypted, mediaConn] = await Promise.all([
-        WaMediaCrypto.encryptBytes(uploadType, mediaKey, mediaBytes),
+        WaMediaCrypto.encryptBytes(uploadType, mediaKey, mediaBytes, {
+            sidecar: needsSidecar(content),
+            firstFrameLength
+        }),
         getMediaConn(options)
     ]);
     const selectedHost = mediaConn.hosts.find((host) => !host.isFallback)?.hostname ?? mediaConn.hosts[0].hostname;
-    const uploadPath = MEDIA_UPLOAD_PATHS[uploadType];
-    const hashToken = bytesToBase64UrlSafe(encrypted.fileEncSha256);
-    const uploadUrl = `https://${selectedHost}${uploadPath}/${hashToken}?auth=${encodeURIComponent(mediaConn.auth)}&token=${encodeURIComponent(hashToken)}`;
+    const uploadUrl = buildUploadUrl(selectedHost, uploadType, mediaConn.auth, encrypted.fileEncSha256);
     options.logger.debug('sending media upload request', {
         mediaType: content.type,
         uploadType,
@@ -121,28 +234,68 @@ async function uploadMedia(options, content, mediaBytes) {
         method: 'POST',
         body: encrypted.ciphertextHmac,
         contentLength: encrypted.ciphertextHmac.byteLength,
-        contentType: content.mimetype
+        contentType: resolveMimetype(content)
     });
-    const uploadBody = await options.mediaTransfer.readResponseBytes(uploadResponse);
-    if (!uploadResponse.ok) {
-        throw new Error(`media upload failed with status ${uploadResponse.status}`);
-    }
-    let parsedBody;
-    try {
-        parsedBody = JSON.parse(TEXT_DECODER.decode(uploadBody));
-    }
-    catch (error) {
-        throw new Error(`media upload returned invalid json: ${toError(error).message}`);
-    }
-    if (!parsedBody.url || !parsedBody.direct_path) {
-        throw new Error('media upload response missing url/direct_path');
-    }
+    const responseBody = await options.mediaTransfer.readResponseBytes(uploadResponse);
+    const parsed = parseUploadResponse(responseBody, uploadResponse.status);
     return {
-        url: parsedBody.url,
-        directPath: parsedBody.direct_path,
+        ...parsed,
         mediaKey,
         fileSha256: encrypted.fileSha256,
         fileEncSha256: encrypted.fileEncSha256,
-        ...(parsedBody.metadata_url ? { metadataUrl: parsedBody.metadata_url } : {})
+        fileLength: mediaBytes.byteLength,
+        streamingSidecar: encrypted.streamingSidecar,
+        firstFrameSidecar: encrypted.firstFrameSidecar,
+        firstFrameLength
     };
 }
+async function uploadMediaStream(options, content, stream, firstFrameLength) {
+    const uploadType = resolveUploadType(content);
+    const mediaKey = await WaMediaCrypto.generateMediaKey();
+    const encResult = await WaMediaCrypto.encryptToFile(uploadType, mediaKey, stream, {
+        sidecar: needsSidecar(content),
+        firstFrameLength
+    });
+    let readStream;
+    try {
+        const mediaConn = await getMediaConn(options);
+        const selectedHost = mediaConn.hosts.find((host) => !host.isFallback)?.hostname ??
+            mediaConn.hosts[0].hostname;
+        const uploadUrl = buildUploadUrl(selectedHost, uploadType, mediaConn.auth, encResult.fileEncSha256);
+        options.logger.debug('sending media stream upload request', {
+            mediaType: content.type,
+            uploadType,
+            host: selectedHost,
+            encryptedSize: encResult.fileSize
+        });
+        readStream = createReadStream(encResult.filePath);
+        const uploadResponse = await options.mediaTransfer.uploadStream({
+            url: uploadUrl,
+            method: 'POST',
+            body: readStream,
+            contentLength: encResult.fileSize,
+            contentType: resolveMimetype(content)
+        });
+        const responseBody = await options.mediaTransfer.readResponseBytes(uploadResponse);
+        const parsed = parseUploadResponse(responseBody, uploadResponse.status);
+        return {
+            ...parsed,
+            mediaKey,
+            fileSha256: encResult.fileSha256,
+            fileEncSha256: encResult.fileEncSha256,
+            fileLength: encResult.plaintextLength,
+            streamingSidecar: encResult.streamingSidecar,
+            firstFrameSidecar: encResult.firstFrameSidecar,
+            firstFrameLength
+        };
+    }
+    finally {
+        if (readStream && !readStream.closed) {
+            await new Promise((resolve) => {
+                readStream.once('close', resolve);
+                readStream.destroy();
+            });
+        }
+        await WaMediaCrypto.cleanupEncryptedFile(encResult.filePath);
+    }
+}

package/dist/esm/client/messaging/fanout.js

@@ -1,21 +1,20 @@
-import { normalizeDeviceJid, splitJid, toUserJid } from '../../protocol/jid.js';
+import { PromiseDedup } from '../../infra/perf/PromiseDedup.js';
+import { isHostedDeviceJid, normalizeDeviceJid, splitJid, toUserJid } from '../../protocol/jid.js';
 import { toError } from '../../util/primitives.js';
 export function createDeviceFanoutResolver(options) {
     const { signalDeviceSync, getCurrentMeJid, getCurrentMeLid, logger } = options;
-    const requireCurrentMeJid = (context) => {
-        const meJid = getCurrentMeJid();
-        if (meJid) {
-            return meJid;
-        }
-        throw new Error(`${context} requires registered meJid`);
-    };
+    const dedup = new PromiseDedup();
     const resolveDirectFanoutDeviceJids = async (recipientJid, selfDeviceJidForRecipient) => {
         const recipientUserJid = toUserJid(recipientJid);
         const meUserJid = toUserJid(selfDeviceJidForRecipient);
         const targets = recipientUserJid === meUserJid ? [recipientUserJid] : [recipientUserJid, meUserJid];
         try {
             const synced = await signalDeviceSync.syncDeviceList(targets);
-            const byUser = new Map(synced.map((entry) => [toUserJid(entry.jid), entry.deviceJids]));
+            const byUser = new Map();
+            for (let index = 0; index < synced.length; index += 1) {
+                const entry = synced[index];
+                byUser.set(toUserJid(entry.jid), entry.deviceJids);
+            }
             const fanout = new Set();
             const recipientDevices = byUser.get(recipientUserJid) ?? [];
             if (recipientDevices.length === 0) {
@@ -45,7 +44,7 @@ export function createDeviceFanoutResolver(options) {
             return [recipientUserJid];
         }
     };
-    const resolveGroupParticipantDeviceJids = async (participantUserJids) => {
+    const resolveGroupParticipantDeviceJidsInternal = async (participantUserJids) => {
         const meDeviceJids = new Set();
         const meJid = getCurrentMeJid();
         if (meJid) {
@@ -71,7 +70,11 @@ export function createDeviceFanoutResolver(options) {
                 });
             }
         }
-        const candidateUsers = [...new Set(participantUserJids)];
+        const candidateUserSet = new Set();
+        for (let index = 0; index < participantUserJids.length; index += 1) {
+            candidateUserSet.add(participantUserJids[index]);
+        }
+        const candidateUsers = Array.from(candidateUserSet);
         if (candidateUsers.length === 0) {
             return [];
         }
@@ -89,6 +92,9 @@ export function createDeviceFanoutResolver(options) {
                 }
                 for (const deviceJid of entry.deviceJids) {
                     const normalizedDeviceJid = normalizeDeviceJid(deviceJid);
+                    if (isHostedDeviceJid(normalizedDeviceJid)) {
+                        continue;
+                    }
                     if (meDeviceJids.has(normalizedDeviceJid)) {
                         continue;
                     }
@@ -122,7 +128,10 @@ export function createDeviceFanoutResolver(options) {
         }
     };
     const resolveOwnPeerDeviceJids = async () => {
-        const meJid = requireCurrentMeJid('resolveOwnPeerDeviceJids');
+        const meJid = getCurrentMeJid();
+        if (!meJid) {
+            throw new Error('resolveOwnPeerDeviceJids requires registered meJid');
+        }
         const meUserJid = toUserJid(meJid);
         const meDevices = new Set();
         meDevices.add(normalizeDeviceJid(meJid));
@@ -177,6 +186,7 @@ export function createDeviceFanoutResolver(options) {
         }
         return meLid;
     };
+    const resolveGroupParticipantDeviceJids = (participantUserJids) => dedup.run(`group:${participantUserJids.join(',')}`, () => resolveGroupParticipantDeviceJidsInternal(participantUserJids));
     return {
         resolveDirectFanoutDeviceJids,
         resolveGroupParticipantDeviceJids,

package/dist/esm/client/messaging/participants.js

@@ -1,7 +1,9 @@
+import { PromiseDedup } from '../../infra/perf/PromiseDedup.js';
 import { toUserJid } from '../../protocol/jid.js';
 import { toError } from '../../util/primitives.js';
 export function createGroupParticipantsCache(options) {
     const { participantsStore, queryGroupParticipantJids, logger } = options;
+    const dedup = new PromiseDedup();
     const sanitizeParticipantUsers = (participants) => {
         const deduped = new Set();
         for (const participant of participants) {
@@ -117,7 +119,7 @@ export function createGroupParticipantsCache(options) {
         }
         return sanitizeParticipantUsers(candidates);
     };
-    const refreshParticipantUsers = async (groupJid) => {
+    const refreshParticipantUsers = (groupJid) => dedup.run(`refresh:${groupJid}`, async () => {
         const queried = await queryGroupParticipantJids(groupJid);
         const participants = sanitizeParticipantUsers(queried);
         await participantsStore.upsertGroupParticipants({
@@ -126,14 +128,14 @@ export function createGroupParticipantsCache(options) {
             updatedAtMs: Date.now()
         });
         return participants;
-    };
-    const resolveParticipantUsers = async (groupJid) => {
+    });
+    const resolveParticipantUsers = (groupJid) => dedup.run(`resolve:${groupJid}`, async () => {
         const cached = await participantsStore.getGroupParticipants(groupJid);
         if (cached && cached.participants.length > 0) {
             return sanitizeParticipantUsers(cached.participants);
         }
         return refreshParticipantUsers(groupJid);
-    };
+    });
     const mutateFromGroupEvent = async (event) => {
         const groupJid = resolveGroupJidForParticipantCacheEvent(event);
         if (!groupJid) {

package/dist/esm/client/persistence/WriteBehindPersistence.js

@@ -0,0 +1,125 @@
+import { BackgroundQueue } from '../../infra/perf/BackgroundQueue.js';
+import { toError } from '../../util/primitives.js';
+function mergeThread(previous, incoming) {
+    return {
+        jid: incoming.jid,
+        name: incoming.name ?? previous.name,
+        unreadCount: incoming.unreadCount ?? previous.unreadCount,
+        archived: incoming.archived ?? previous.archived,
+        pinned: incoming.pinned ?? previous.pinned,
+        muteEndMs: incoming.muteEndMs ?? previous.muteEndMs,
+        markedAsUnread: incoming.markedAsUnread ?? previous.markedAsUnread,
+        ephemeralExpiration: incoming.ephemeralExpiration ?? previous.ephemeralExpiration
+    };
+}
+function mergeContact(previous, incoming) {
+    return {
+        jid: incoming.jid,
+        displayName: incoming.displayName ?? previous.displayName,
+        pushName: incoming.pushName ?? previous.pushName,
+        lid: incoming.lid ?? previous.lid,
+        phoneNumber: incoming.phoneNumber ?? previous.phoneNumber,
+        lastUpdatedMs: Math.max(previous.lastUpdatedMs, incoming.lastUpdatedMs)
+    };
+}
+export class WriteBehindPersistence {
+    constructor(stores, logger, options = {}) {
+        this.logger = logger;
+        this.flushTimeoutMs = options.flushTimeoutMs ?? 5000;
+        const queueOptions = (domain) => ({
+            maxPendingKeys: options.maxPendingKeys ?? 4096,
+            maxWriteConcurrency: options.maxWriteConcurrency ?? 4,
+            flushTimeoutMs: this.flushTimeoutMs,
+            onError: (key, error, attempt) => {
+                this.logger.warn('write-behind error', {
+                    domain,
+                    key,
+                    attempt,
+                    message: toError(error).message
+                });
+            },
+            onPressure: (pendingKeys) => {
+                this.logger.warn('write-behind pressure', {
+                    domain,
+                    pendingKeys
+                });
+            },
+            onDiscard: (key) => {
+                this.logger.warn('write-behind discarded pending write', {
+                    domain,
+                    key
+                });
+            }
+        });
+        this.queues = {
+            messages: new BackgroundQueue((_key, value) => stores.messageStore.upsert(value), queueOptions('messages')),
+            threads: new BackgroundQueue((_key, value) => stores.threadStore.upsert(value), {
+                ...queueOptions('threads'),
+                coalesce: (previous, incoming) => mergeThread(previous, incoming)
+            }),
+            contacts: new BackgroundQueue((_key, value) => stores.contactStore.upsert(value), {
+                ...queueOptions('contacts'),
+                coalesce: (previous, incoming) => mergeContact(previous, incoming)
+            })
+        };
+    }
+    persistMessage(record) {
+        this.queues.messages.enqueue(`msg:${record.id}`, record);
+    }
+    persistMessageAsync(record) {
+        return this.queues.messages.enqueueAsync(`msg:${record.id}`, record);
+    }
+    persistThread(record) {
+        this.queues.threads.enqueue(`thread:${record.jid}`, record);
+    }
+    persistThreadAsync(record) {
+        return this.queues.threads.enqueueAsync(`thread:${record.jid}`, record);
+    }
+    persistContact(record) {
+        this.queues.contacts.enqueue(`contact:${record.jid}`, record);
+    }
+    persistContactAsync(record) {
+        return this.queues.contacts.enqueueAsync(`contact:${record.jid}`, record);
+    }
+    async flush(timeoutMs = this.flushTimeoutMs) {
+        const [messages, threads, contacts] = await Promise.all([
+            this.queues.messages.flush(timeoutMs),
+            this.queues.threads.flush(timeoutMs),
+            this.queues.contacts.flush(timeoutMs)
+        ]);
+        const result = this.toDrainResult(messages, threads, contacts);
+        if (result.remaining > 0) {
+            this.logger.warn('write-behind flush finished with pending writes', {
+                messagesRemaining: messages.remaining,
+                threadsRemaining: threads.remaining,
+                contactsRemaining: contacts.remaining
+            });
+        }
+        return result;
+    }
+    async destroy(timeoutMs = this.flushTimeoutMs) {
+        const [messages, threads, contacts] = await Promise.all([
+            this.queues.messages.destroy(timeoutMs),
+            this.queues.threads.destroy(timeoutMs),
+            this.queues.contacts.destroy(timeoutMs)
+        ]);
+        const result = this.toDrainResult(messages, threads, contacts);
+        if (result.remaining > 0) {
+            this.logger.warn('write-behind destroy finished with pending writes', {
+                messagesRemaining: messages.remaining,
+                threadsRemaining: threads.remaining,
+                contactsRemaining: contacts.remaining
+            });
+        }
+        return result;
+    }
+    toDrainResult(messages, threads, contacts) {
+        return {
+            messages,
+            threads,
+            contacts,
+            flushed: messages.flushed + threads.flushed + contacts.flushed,
+            remaining: messages.remaining + threads.remaining + contacts.remaining
+        };
+    }
+}

package/dist/esm/client/tokens/cs-token.js

@@ -0,0 +1,46 @@
+import { hmacSign, importHmacKey } from '../../crypto/core/index.js';
+import { TEXT_ENCODER } from '../../util/bytes.js';
+import { setBoundedMapEntry } from '../../util/collections.js';
+const CS_TOKEN_CACHE_MAX = 5;
+export class CsTokenGenerator {
+    constructor() {
+        this.cachedKey = null;
+        this.cachedSalt = null;
+        this.cache = new Map();
+    }
+    async generate(nctSalt, accountLid) {
+        const cached = this.cache.get(accountLid);
+        if (cached && this.isSameSalt(nctSalt)) {
+            return cached;
+        }
+        const key = await this.resolveKey(nctSalt);
+        const result = await hmacSign(key, TEXT_ENCODER.encode(accountLid));
+        setBoundedMapEntry(this.cache, accountLid, result, CS_TOKEN_CACHE_MAX);
+        return result;
+    }
+    invalidate() {
+        this.cachedKey = null;
+        this.cachedSalt = null;
+        this.cache.clear();
+    }
+    isSameSalt(salt) {
+        if (!this.cachedSalt || this.cachedSalt.length !== salt.length) {
+            return false;
+        }
+        for (let i = 0; i < salt.length; i += 1) {
+            if (this.cachedSalt[i] !== salt[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    async resolveKey(salt) {
+        if (this.cachedKey && this.isSameSalt(salt)) {
+            return this.cachedKey;
+        }
+        this.cachedKey = await importHmacKey(salt);
+        this.cachedSalt = salt;
+        this.cache.clear();
+        return this.cachedKey;
+    }
+}