zapo-js 1.6.2 → 1.7.1

package/dist/signal/session/SignalProtocol.js

@@ -25,6 +25,14 @@ class SignalProtocol {
         this.logger = logger;
         this.sessionMutationLock = new StoreLock_1.StoreLock();
     }
+    /**
+     * Loads the local registration identity once so batch callers can share
+     * it across many `prepareOutgoingSession` calls via
+     * `options.localIdentity` instead of re-reading the store per address.
+     */
+    async loadLocalIdentity() {
+        return (0, SignalSession_1.requireLocalIdentity)(this.stores.signal);
+    }
     /**
      * Builds an outgoing Signal session against a remote prekey bundle. Set
      * `options.reuseExisting` to skip the handshake when a session already
@@ -45,7 +53,7 @@ class SignalProtocol {
                 }
             }
             const [local, localOneTimeBase] = await Promise.all([
-                (0, SignalSession_1.requireLocalIdentity)(this.stores.signal),
+                options.localIdentity ?? (0, SignalSession_1.requireLocalIdentity)(this.stores.signal),
                 (0, SignalSession_1.generateSerializedKeyPair)()
             ]);
             const session = await (0, SignalSession_1.initiateSessionOutgoing)(local, remoteBundle, localOneTimeBase);
@@ -78,7 +86,7 @@ class SignalProtocol {
                 }
             }
             const [local, localOneTimeBase] = await Promise.all([
-                (0, SignalSession_1.requireLocalIdentity)(this.stores.signal),
+                options.localIdentity ?? (0, SignalSession_1.requireLocalIdentity)(this.stores.signal),
                 (0, SignalSession_1.generateSerializedKeyPair)()
             ]);
             const session = await (0, SignalSession_1.initiateSessionOutgoing)(local, remoteBundle, localOneTimeBase);
@@ -165,31 +173,24 @@ class SignalProtocol {
                     prefetchedByAddress.set((0, jid_1.signalAddressKey)(entry.address), entry.session);
                 }
             }
-            const uniqueAddressKeys = new Array(requests.length);
-            const uniqueAddresses = new Array(requests.length);
-            let uniqueAddressCount = 0;
+            const addressKeys = new Array(requests.length);
+            const seenAddressKeys = new Set();
+            const uniqueAddressKeys = [];
+            const uniqueAddresses = [];
             for (let index = 0; index < requests.length; index += 1) {
                 const address = requests[index].address;
                 const addressKey = (0, jid_1.signalAddressKey)(address);
-                let isDuplicate = false;
-                for (let dedupIndex = 0; dedupIndex < uniqueAddressCount; dedupIndex += 1) {
-                    if (uniqueAddressKeys[dedupIndex] === addressKey) {
-                        isDuplicate = true;
-                        break;
-                    }
-                }
-                if (isDuplicate) {
+                addressKeys[index] = addressKey;
+                if (seenAddressKeys.has(addressKey)) {
                     continue;
                 }
-                uniqueAddressKeys[uniqueAddressCount] = addressKey;
-                uniqueAddresses[uniqueAddressCount] = address;
-                uniqueAddressCount += 1;
+                seenAddressKeys.add(addressKey);
+                uniqueAddressKeys.push(addressKey);
+                uniqueAddresses.push(address);
             }
-            uniqueAddressKeys.length = uniqueAddressCount;
-            uniqueAddresses.length = uniqueAddressCount;
             const currentSessions = await this.stores.session.getSessionsBatch(uniqueAddresses);
             const latestSessionByAddress = new Map();
-            for (let index = 0; index < uniqueAddressCount; index += 1) {
+            for (let index = 0; index < uniqueAddresses.length; index += 1) {
                 const addressKey = uniqueAddressKeys[index];
                 const current = currentSessions[index];
                 if (current) {
@@ -207,7 +208,7 @@ class SignalProtocol {
             for (let index = 0; index < requests.length; index += 1) {
                 const request = requests[index];
                 const address = request.address;
-                const addressKey = (0, jid_1.signalAddressKey)(address);
+                const addressKey = addressKeys[index];
                 const session = latestSessionByAddress.get(addressKey);
                 if (!session) {
                     throw new Error('signal session not found');
@@ -216,7 +217,7 @@ class SignalProtocol {
                     !(0, bytes_1.uint8Equal)((0, _crypto_1.toSerializedPubKey)(request.expectedIdentity), session.remote.pubKey)) {
                     throw new Error('identity mismatch');
                 }
-                const [updatedSession, encrypted] = await (0, SignalRatchet_1.encryptMsg)(session, request.plaintext);
+                const [updatedSession, encrypted] = (0, SignalRatchet_1.encryptMsg)(session, request.plaintext);
                 latestSessionByAddress.set(addressKey, updatedSession);
                 sessionUpdatesByAddress.set(addressKey, {
                     address,

package/dist/signal/session/SignalRatchet.d.ts

@@ -12,13 +12,13 @@ export declare function deriveMsgKey(index: number, chainKey: Uint8Array): {
     readonly nextChainKey: Uint8Array;
     readonly messageKey: SignalMessageKey;
 };
-export declare function selectMessageKey(chain: SignalRecvChain, targetCounter: number): Promise<{
+export declare function selectMessageKey(chain: SignalRecvChain, targetCounter: number): {
     readonly messageKey: SignalMessageKey;
     readonly updatedChain: SignalRecvChain;
-}>;
-export declare function encryptMsg(session: SignalSessionRecord, plaintext: Uint8Array): Promise<readonly [SignalSessionRecord, {
+};
+export declare function encryptMsg(session: SignalSessionRecord, plaintext: Uint8Array): readonly [SignalSessionRecord, {
     type: 'msg' | 'pkmsg';
     ciphertext: Uint8Array;
-}]>;
+}];
 export declare function decryptMsg(session: SignalSessionRecord | null, parsed: ParsedSignalMessage, onPrevSessionDecryptError?: (error: Error, previousSessionIndex: number) => void): Promise<DecryptOutcome>;
 export declare function decryptMsgFromSession(session: SignalSessionRecord, message: ParsedSignalMessage | ParsedPreKeySignalMessage): Promise<readonly [SignalSessionRecord, Uint8Array]>;

package/dist/signal/session/SignalRatchet.js

@@ -27,8 +27,7 @@ function splitMsgKey(index, bytes) {
 function deriveMsgKey(index, chainKey) {
     return deriveMsgKeyFromChainKey(index, chainKey);
 }
-// eslint-disable-next-line @typescript-eslint/require-await
-async function selectMessageKey(chain, targetCounter) {
+function selectMessageKey(chain, targetCounter) {
     const delta = targetCounter - chain.nextMsgIndex;
     if (delta > constants_1.FUTURE_MESSAGES_MAX) {
         throw new Error('message too far in future');
@@ -108,8 +107,7 @@ function deriveMsgKeyFromChainKey(index, chainKey) {
         messageKey: splitMsgKey(index, expanded)
     };
 }
-// eslint-disable-next-line @typescript-eslint/require-await
-async function encryptMsg(session, plaintext) {
+function encryptMsg(session, plaintext) {
     const { nextChainKey, messageKey } = deriveMsgKey(session.sendChain.nextMsgIndex, session.sendChain.chainKey);
     const ciphertext = (0, _crypto_1.aesCbcEncrypt)(messageKey.cipherKey, messageKey.iv, plaintext);
     const signalPayload = _proto_1.proto.SignalMessage.encode({
@@ -118,13 +116,16 @@ async function encryptMsg(session, plaintext) {
         previousCounter: session.prevSendChainHighestIndex,
         ciphertext
     }).finish();
-    const versionedSignalPayload = (0, _crypto_1.prependVersion)(signalPayload, constants_1.SIGNAL_VERSION);
+    const versionedLength = 1 + signalPayload.length;
+    const signalMessage = new Uint8Array(versionedLength + constants_1.SIGNAL_MAC_SIZE);
+    signalMessage[0] = ((constants_1.SIGNAL_VERSION << 4) | constants_1.SIGNAL_VERSION) & 0xff;
+    signalMessage.set(signalPayload, 1);
     const mac = (0, _crypto_1.hmacSha256Sign)(messageKey.macKey, [
         session.local.pubKey,
         session.remote.pubKey,
-        versionedSignalPayload
+        signalMessage.subarray(0, versionedLength)
     ]);
-    const signalMessage = (0, bytes_1.concatBytes)([versionedSignalPayload, mac.subarray(0, constants_1.SIGNAL_MAC_SIZE)]);
+    signalMessage.set(mac.subarray(0, constants_1.SIGNAL_MAC_SIZE), versionedLength);
     let type = 'msg';
     let output = signalMessage;
     if (session.initialExchangeInfo) {
@@ -197,10 +198,14 @@ async function decryptMsg(session, parsed, onPrevSessionDecryptError) {
 }
 async function decryptMsgFromSession(session, message) {
     const ratchetPubKey = (0, _crypto_1.toSerializedPubKey)(message.ratchetPubKey);
-    const recvChainIndex = session.recvChains.findIndex((raw) => {
-        const key = raw.senderRatchetKey;
-        return key !== null && key !== undefined && (0, bytes_1.uint8Equal)(key, ratchetPubKey);
-    });
+    let recvChainIndex = -1;
+    for (let index = 0; index < session.recvChains.length; index += 1) {
+        const key = session.recvChains[index].senderRatchetKey;
+        if (key !== null && key !== undefined && (0, bytes_1.uint8Equal)(key, ratchetPubKey)) {
+            recvChainIndex = index;
+            break;
+        }
+    }
     let selectedMessageKey;
     let updatedSession;
     if (recvChainIndex === -1) {
@@ -211,10 +216,8 @@ async function decryptMsgFromSession(session, message) {
             chainKey: recvRatchet.chainKey,
             unusedMsgKeys: []
         };
-        const [selected, newSendRatchet] = await Promise.all([
-            selectMessageKey(freshRecvChain, message.counter),
-            (0, SignalSession_1.generateSerializedKeyPair)()
-        ]);
+        const selected = selectMessageKey(freshRecvChain, message.counter);
+        const newSendRatchet = await (0, SignalSession_1.generateSerializedKeyPair)();
         selectedMessageKey = selected.messageKey;
         const sendRatchet = await (0, SignalSession_1.calculateRatchet)(recvRatchet.rootKey, newSendRatchet, ratchetPubKey);
         const nextRecvChains = session.recvChains.slice(-MAX_TRACKED_RECV_CHAINS);
@@ -234,7 +237,7 @@ async function decryptMsgFromSession(session, message) {
     }
     else {
         const decoded = (0, encoding_1.decodeSignalRecvChain)(session.recvChains[recvChainIndex], `recvChains[${recvChainIndex}]`);
-        const selected = await selectMessageKey(decoded, message.counter);
+        const selected = selectMessageKey(decoded, message.counter);
         selectedMessageKey = selected.messageKey;
         const nextRecvChains = session.recvChains.slice();
         nextRecvChains[recvChainIndex] = (0, encoding_1.encodeSignalRecvChain)(selected.updatedChain);

package/dist/signal/session/SignalSession.d.ts

@@ -1,6 +1,13 @@
 import type { SignalSerializedKeyPair, SignalSessionRecord, SignalSessionSnapshot } from '../types';
 import type { WaSignalStore } from '../../store/contracts/signal.store';
-interface LocalIdentityContext {
+/**
+ * Local registration identity used to initiate outgoing Signal sessions.
+ *
+ * @sensitive `staticKeyPair.privKey` is the account's Signal identity
+ * private key. Do not `JSON.stringify`, log, or persist instances; the
+ * store layer is responsible for encryption at rest.
+ */
+export interface LocalIdentityContext {
     readonly regId: number;
     readonly staticKeyPair: SignalSerializedKeyPair;
 }

package/dist/signal/session/encoding.d.ts

@@ -17,6 +17,11 @@ export declare function decodeSignalSessionSnapshot(session: Proto.ISessionStruc
 /**
  * Serializes a {@link SignalSessionRecord} (current + previous sessions) into
  * the Signal `RecordStructure` protobuf encoding used by the session stores.
+ *
+ * The `previousSessions` segment only depends on the `prevSessions` array,
+ * which every mutation path replaces wholesale (never edits in place), so its
+ * encoded bytes are cached per array instance and only the current session is
+ * re-encoded on the per-message write path.
  */
 export declare function encodeSignalSessionRecord(record: SignalSessionRecord): Uint8Array;
 /**

package/dist/signal/session/encoding.js

@@ -152,15 +152,37 @@ function decodeSignalSessionSnapshot(session, field) {
         aliceBaseKey
     };
 }
+const prevSessionsSuffixCache = new WeakMap();
 /**
  * Serializes a {@link SignalSessionRecord} (current + previous sessions) into
  * the Signal `RecordStructure` protobuf encoding used by the session stores.
+ *
+ * The `previousSessions` segment only depends on the `prevSessions` array,
+ * which every mutation path replaces wholesale (never edits in place), so its
+ * encoded bytes are cached per array instance and only the current session is
+ * re-encoded on the per-message write path.
  */
 function encodeSignalSessionRecord(record) {
-    return _proto_1.proto.RecordStructure.encode({
-        currentSession: encodeSignalSessionSnapshot(record),
-        previousSessions: record.prevSessions
+    const prevSessions = record.prevSessions;
+    if (prevSessions.length === 0) {
+        return _proto_1.proto.RecordStructure.encode({
+            currentSession: encodeSignalSessionSnapshot(record)
+        }).finish();
+    }
+    let suffix = prevSessionsSuffixCache.get(prevSessions);
+    if (!suffix) {
+        suffix = _proto_1.proto.RecordStructure.encode({
+            previousSessions: prevSessions
+        }).finish();
+        prevSessionsSuffixCache.set(prevSessions, suffix);
+    }
+    const current = _proto_1.proto.RecordStructure.encode({
+        currentSession: encodeSignalSessionSnapshot(record)
     }).finish();
+    const out = new Uint8Array(current.length + suffix.length);
+    out.set(current, 0);
+    out.set(suffix, current.length);
+    return out;
 }
 /**
  * Decodes a Signal `RecordStructure` payload (as stored on disk) back into a

package/dist/signal/session/resolver.js

@@ -183,6 +183,7 @@ function createSignalSessionResolver(options) {
         const preparePromises = new Array(missingIndices.length);
         let prepareCount = 0;
         const missingBundleTargets = [];
+        let localIdentityPromise = null;
         for (let index = 0; index < missingIndices.length; index += 1) {
             const targetIndex = missingIndices[index];
             const targetJid = normalizedTargetJids[targetIndex];
@@ -212,11 +213,13 @@ function createSignalSessionResolver(options) {
             const targetAddress = normalizedTargetAddresses[targetIndex];
             const bundle = batchResult.bundle;
             prepareTargetIndices[prepareCount] = targetIndex;
-            preparePromises[prepareCount] = signalProtocol
-                .prepareOutgoingSession(targetAddress, bundle, {
+            localIdentityPromise ?? (localIdentityPromise = signalProtocol.loadLocalIdentity());
+            preparePromises[prepareCount] = localIdentityPromise
+                .then((localIdentity) => signalProtocol.prepareOutgoingSession(targetAddress, bundle, {
                 reuseExisting: true,
-                knownAbsent: true
-            })
+                knownAbsent: true,
+                localIdentity
+            }))
                 .then((prep) => ({
                 session: prep.session,
                 remoteIdentity: prep.remoteIdentity
@@ -239,6 +242,7 @@ function createSignalSessionResolver(options) {
         const batchEntries = [];
         const entryToTargetIndex = [];
         const fallbackIndices = [];
+        const fallbackIndexSet = new Set();
         for (let i = 0; i < prepareTargetIndices.length; i += 1) {
             const targetIndex = prepareTargetIndices[i];
             const result = prepareResults[i];
@@ -274,6 +278,7 @@ function createSignalSessionResolver(options) {
                 message: normalized.message
             });
             for (let i = 0; i < entryToTargetIndex.length; i += 1) {
+                fallbackIndexSet.add(entryToTargetIndex[i]);
                 fallbackIndices.push(entryToTargetIndex[i]);
             }
             persistResult = { resolved: [], skipped: [] };
@@ -302,7 +307,8 @@ function createSignalSessionResolver(options) {
             if (skippedByAddressKey.has(addrKey)) {
                 continue;
             }
-            if (!fallbackIndices.includes(targetIndex)) {
+            if (!fallbackIndexSet.has(targetIndex)) {
+                fallbackIndexSet.add(targetIndex);
                 fallbackIndices.push(targetIndex);
             }
         }

package/dist/store/contracts/chat-metadata.store.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Protocol-derived per-chat state, cached so an outgoing send never depends on
+ * a user-configured archive being reachable.
+ *
+ * Distinct from the `threads` mailbox domain, which is the user-facing chat
+ * archive (name, unread, archived, pinned, mute). This domain holds state the
+ * runtime derives from the protocol and can always rebuild: history sync, an
+ * `EPHEMERAL_SETTING` protocol message, or an incoming `ContextInfo` all
+ * repopulate it. Losing it costs freshness, never data.
+ *
+ * The `threads` record persists the same disappearing-message fields as the
+ * durable copy; this domain is the hot path's source and falls back to it on a
+ * cold miss - the same relationship `messageSecret` has with the archived
+ * message bytes.
+ */
+export interface WaChatMetadataSnapshot {
+    readonly chatJid: string;
+    /** Disappearing-message lifetime in seconds. `0` when the chat is not ephemeral. */
+    readonly ephemeralExpiration?: number;
+    /**
+     * Unix seconds when disappearing mode was enabled. History sync delivers
+     * milliseconds and `ContextInfo` seconds; ingest normalizes before writing.
+     */
+    readonly ephemeralSettingTimestamp?: number;
+    readonly updatedAtMs: number;
+}
+export interface WaChatMetadataStore {
+    destroy?(): Promise<void>;
+    upsertChatMetadata(snapshot: WaChatMetadataSnapshot): Promise<void>;
+    getChatMetadata(chatJid: string, nowMs?: number): Promise<WaChatMetadataSnapshot | null>;
+    deleteChatMetadata(chatJid: string): Promise<number>;
+    cleanupExpired(nowMs: number): Promise<number>;
+    clear(): Promise<void>;
+}

package/dist/store/contracts/chat-metadata.store.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/store/contracts/group-metadata.store.d.ts

@@ -2,6 +2,13 @@ export interface WaGroupMetadataSnapshot {
     readonly groupJid: string;
     readonly participants: readonly string[];
     readonly ephemeral?: number;
+    /**
+     * `<ephemeral trigger>` from the group metadata, mirrored into
+     * `contextInfo.disappearingMode.trigger` on outgoing group messages. Absent
+     * when the group reports no trigger - the field is then omitted on the wire
+     * rather than defaulted.
+     */
+    readonly ephemeralTrigger?: number;
     readonly updatedAtMs: number;
 }
 export interface WaGroupMetadataStore {

package/dist/store/contracts/thread.store.d.ts

@@ -7,6 +7,12 @@ export interface WaStoredThreadRecord {
     readonly muteEndMs?: number;
     readonly markedAsUnread?: boolean;
     readonly ephemeralExpiration?: number;
+    /**
+     * Unix seconds when disappearing mode was enabled, normalized on ingest to
+     * the unit `ContextInfo` uses on the wire. Set only for ephemeral 1:1 chats;
+     * groups do not carry it on outgoing messages.
+     */
+    readonly ephemeralSettingTimestamp?: number;
 }
 export interface WaThreadStore {
     upsert(record: WaStoredThreadRecord): Promise<void>;

package/dist/store/createStore.d.ts

@@ -1,4 +1,4 @@
-import type { WaCreateStoreOptions, WaCreateStoreOptionsStrict, WaStore } from './types';
+import type { WaCreateStoreOptions, WaCreateStoreOptionsStrictFor, WaStore, WaStoreBackendMap } from './types';
 /**
  * Builds a {@link WaStore} from the configured providers/backends. Each call
  * to `store.session(sessionId)` returns a cached, lock-wrapped per-domain
@@ -18,6 +18,14 @@ import type { WaCreateStoreOptions, WaCreateStoreOptionsStrict, WaStore } from '
  *   messageSecret) stay opt-in and default to memory - they are small,
  *   hot, and cheap to rebuild.
  *
+ * **Domain coverage:** the backend map is inferred, so each domain only
+ * accepts the backends whose bundle actually declares it. A backend that
+ * covers part of the matrix (`WaStoreBackend<'auth', never>`, say) can only
+ * be named on the domains it implements - the rest fall back to `'memory'`
+ * / `'none'`, checked by the compiler rather than by the
+ * `backend '<name>' does not provide <kind>.<domain>` throw on first
+ * `session()`.
+ *
  * @example
  * ```ts
  * // Persistent setup with @zapo-js/store-sqlite (recommended for production)
@@ -51,4 +59,4 @@ export declare function createStore(options?: Omit<WaCreateStoreOptions<never>,
     readonly backends?: undefined;
     readonly providers?: undefined;
 }): WaStore;
-export declare function createStore<B extends string>(options: WaCreateStoreOptionsStrict<B>): WaStore;
+export declare function createStore<TBackends extends WaStoreBackendMap>(options: WaCreateStoreOptionsStrictFor<TBackends>): WaStore;

package/dist/store/createStore.js

@@ -22,6 +22,7 @@ const signal_lock_1 = require("./locks/signal.lock");
 const thread_lock_1 = require("./locks/thread.lock");
 const appstate_store_1 = require("./memory/appstate.store");
 const auth_store_1 = require("./memory/auth.store");
+const chat_metadata_store_1 = require("./memory/chat-metadata.store");
 const contact_store_1 = require("./memory/contact.store");
 const device_list_store_1 = require("./memory/device-list.store");
 const group_metadata_store_1 = require("./memory/group-metadata.store");
@@ -41,6 +42,7 @@ const primitives_1 = require("../util/primitives");
 const DEFAULT_CACHE_TTLS_MS = Object.freeze({
     retryMs: 60 * 1000,
     groupMetadataMs: 5 * 60 * 1000,
+    chatMetadataMs: 30 * 60 * 1000,
     deviceListMs: 5 * 60 * 1000,
     messageSecretMs: 30 * 60 * 1000
 });
@@ -87,7 +89,7 @@ function resolveStore(sessionId, backends, provider, domain, kind, fallback) {
 }
 function createStore(options) {
     options = options ?? {};
-    const backends = (options.backends ?? {});
+    const backends = options.backends ?? {};
     const providers = options.providers ?? {};
     const cacheProviders = options.cacheProviders ?? {};
     const cacheLayer = options.cacheLayer ?? {};
@@ -109,6 +111,7 @@ function createStore(options) {
     const cacheTtlsMs = Object.freeze({
         retry: (0, coercion_1.resolvePositive)(options.memory?.cacheTtlMs?.retryMs, DEFAULT_CACHE_TTLS_MS.retryMs, 'memory.cacheTtlMs.retryMs'),
         groupMetadata: (0, coercion_1.resolvePositive)(options.memory?.cacheTtlMs?.groupMetadataMs, DEFAULT_CACHE_TTLS_MS.groupMetadataMs, 'memory.cacheTtlMs.groupMetadataMs'),
+        chatMetadata: (0, coercion_1.resolvePositive)(options.memory?.cacheTtlMs?.chatMetadataMs, DEFAULT_CACHE_TTLS_MS.chatMetadataMs, 'memory.cacheTtlMs.chatMetadataMs'),
         deviceList: (0, coercion_1.resolvePositive)(options.memory?.cacheTtlMs?.deviceListMs, DEFAULT_CACHE_TTLS_MS.deviceListMs, 'memory.cacheTtlMs.deviceListMs'),
         messageSecret: (0, coercion_1.resolvePositive)(options.memory?.cacheTtlMs?.messageSecretMs, DEFAULT_CACHE_TTLS_MS.messageSecretMs, 'memory.cacheTtlMs.messageSecretMs')
     });
@@ -174,6 +177,15 @@ function createStore(options) {
                         })
                     })
                     : noop_store_1.NOOP_GROUP_METADATA_STORE)),
+                chatMetadata: resolveStore(id, backends, cacheProviders.chatMetadata ?? 'memory', 'chatMetadata', 'caches', () => cacheProviders.chatMetadata === 'memory' || !cacheProviders.chatMetadata
+                    ? new chat_metadata_store_1.WaChatMetadataMemoryStore(cacheTtlsMs.chatMetadata, {
+                        maxChats: ml.chatMetadataChats,
+                        logger: memoryLogger?.child({
+                            domain: 'chatMetadata',
+                            sessionId: id
+                        })
+                    })
+                    : noop_store_1.NOOP_CHAT_METADATA_STORE),
                 deviceList: (0, device_list_lock_1.withDeviceListLock)(resolveStore(id, backends, cacheProviders.deviceList ?? 'memory', 'deviceList', 'caches', () => cacheProviders.deviceList === 'memory' || !cacheProviders.deviceList
                     ? new device_list_store_1.WaDeviceListMemoryStore(cacheTtlsMs.deviceList, {
                         maxUsers: ml.deviceListUsers,
@@ -221,12 +233,14 @@ function createStore(options) {
                 const cleared = await Promise.allSettled([
                     target.retry.clear(),
                     target.groupMetadata.clear(),
+                    target.chatMetadata.clear(),
                     target.deviceList.clear(),
                     target.messageSecret.clear()
                 ]);
                 const destroyed = await Promise.allSettled([
                     destroyIfSupported(target.retry),
                     destroyIfSupported(target.groupMetadata),
+                    destroyIfSupported(target.chatMetadata),
                     destroyIfSupported(target.deviceList),
                     destroyIfSupported(target.messageSecret)
                 ]);
@@ -310,6 +324,9 @@ function createStore(options) {
                 get groupMetadata() {
                     return caches.groupMetadata;
                 },
+                get chatMetadata() {
+                    return caches.chatMetadata;
+                },
                 get deviceList() {
                     return caches.deviceList;
                 },

package/dist/store/index.d.ts

@@ -1,4 +1,4 @@
-export type { WaCreateStoreOptions, WaCreateStoreOptionsStrict, WaStore, WaStoreBackend, WaCacheDomain, WaStoreDomain, WaStoreMemoryLimitSelection, WaStoreSession } from './types';
+export type { WaAnyStoreBackend, WaBackendsProviding, WaCreateStoreOptions, WaCreateStoreOptionsStrict, WaCreateStoreOptionsStrictFor, WaStore, WaStoreBackend, WaStoreBackendMap, WaCacheDomain, WaCacheDomainContracts, WaStoreDomain, WaStoreDomainContracts, WaStoreMemoryLimitSelection, WaStoreSession } from './types';
 export { createStore } from './createStore';
 export type { WaAuthStore } from './contracts/auth.store';
 export type { WaContactStore, WaStoredContactRecord } from './contracts/contact.store';
@@ -6,6 +6,7 @@ export type { WaDeviceListSnapshot, WaDeviceListStore } from './contracts/device
 export type { WaMessageSecretEntry, WaMessageSecretStore } from './contracts/message-secret.store';
 export type { WaMessageStore, WaStoredMessageRecord } from './contracts/message.store';
 export type { WaGroupMetadataSnapshot, WaGroupMetadataStore } from './contracts/group-metadata.store';
+export type { WaChatMetadataSnapshot, WaChatMetadataStore } from './contracts/chat-metadata.store';
 export type { WaAppStateCollectionStateUpdate, WaAppStateCollectionStoreState, WaAppStateStore } from './contracts/appstate.store';
 export type { WaIdentityStore } from './contracts/identity.store';
 export type { WaPreKeyStore } from './contracts/pre-key.store';
@@ -24,6 +25,7 @@ export { WaIdentityMemoryStore } from './memory/identity.store';
 export { SenderKeyMemoryStore } from './memory/sender-key.store';
 export { WaRetryMemoryStore } from './memory/retry.store';
 export { WaGroupMetadataMemoryStore } from './memory/group-metadata.store';
+export { WaChatMetadataMemoryStore } from './memory/chat-metadata.store';
 export { WaDeviceListMemoryStore } from './memory/device-list.store';
 export { WaContactMemoryStore } from './memory/contact.store';
 export { WaMessageSecretMemoryStore } from './memory/message-secret.store';

package/dist/store/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WaPrivacyTokenMemoryStore = exports.WaThreadMemoryStore = exports.WaMessageMemoryStore = exports.WaMessageSecretMemoryStore = exports.WaContactMemoryStore = exports.WaDeviceListMemoryStore = exports.WaGroupMetadataMemoryStore = exports.WaRetryMemoryStore = exports.SenderKeyMemoryStore = exports.WaIdentityMemoryStore = exports.WaSessionMemoryStore = exports.WaPreKeyMemoryStore = exports.WaSignalMemoryStore = exports.WaAuthMemoryStore = exports.WaAppStateMemoryStore = exports.createStore = void 0;
+exports.WaPrivacyTokenMemoryStore = exports.WaThreadMemoryStore = exports.WaMessageMemoryStore = exports.WaMessageSecretMemoryStore = exports.WaContactMemoryStore = exports.WaDeviceListMemoryStore = exports.WaChatMetadataMemoryStore = exports.WaGroupMetadataMemoryStore = exports.WaRetryMemoryStore = exports.SenderKeyMemoryStore = exports.WaIdentityMemoryStore = exports.WaSessionMemoryStore = exports.WaPreKeyMemoryStore = exports.WaSignalMemoryStore = exports.WaAuthMemoryStore = exports.WaAppStateMemoryStore = exports.createStore = void 0;
 var createStore_1 = require("./createStore");
 Object.defineProperty(exports, "createStore", { enumerable: true, get: function () { return createStore_1.createStore; } });
 var appstate_store_1 = require("./memory/appstate.store");
@@ -21,6 +21,8 @@ var retry_store_1 = require("./memory/retry.store");
 Object.defineProperty(exports, "WaRetryMemoryStore", { enumerable: true, get: function () { return retry_store_1.WaRetryMemoryStore; } });
 var group_metadata_store_1 = require("./memory/group-metadata.store");
 Object.defineProperty(exports, "WaGroupMetadataMemoryStore", { enumerable: true, get: function () { return group_metadata_store_1.WaGroupMetadataMemoryStore; } });
+var chat_metadata_store_1 = require("./memory/chat-metadata.store");
+Object.defineProperty(exports, "WaChatMetadataMemoryStore", { enumerable: true, get: function () { return chat_metadata_store_1.WaChatMetadataMemoryStore; } });
 var device_list_store_1 = require("./memory/device-list.store");
 Object.defineProperty(exports, "WaDeviceListMemoryStore", { enumerable: true, get: function () { return device_list_store_1.WaDeviceListMemoryStore; } });
 var contact_store_1 = require("./memory/contact.store");

package/dist/store/memory/chat-metadata.store.d.ts

@@ -0,0 +1,26 @@
+import type { Logger } from '../../infra/log/types';
+import type { WaChatMetadataSnapshot, WaChatMetadataStore } from '../contracts/chat-metadata.store';
+export interface WaChatMetadataMemoryStoreOptions {
+    readonly maxChats?: number;
+    /**
+     * Logger for capacity-saturation warnings. Emits a single `warn` the first
+     * time the bounded map evicts an entry; later evictions are silent.
+     */
+    readonly logger?: Logger;
+}
+export declare class WaChatMetadataMemoryStore implements WaChatMetadataStore {
+    private readonly records;
+    private readonly ttlMs;
+    private readonly maxChats;
+    private readonly cleanup;
+    private readonly logger;
+    private capacityWarned;
+    constructor(ttlMs?: number, options?: WaChatMetadataMemoryStoreOptions);
+    private warnCapacity;
+    upsertChatMetadata(snapshot: WaChatMetadataSnapshot): Promise<void>;
+    getChatMetadata(chatJid: string, nowMs?: number): Promise<WaChatMetadataSnapshot | null>;
+    deleteChatMetadata(chatJid: string): Promise<number>;
+    cleanupExpired(nowMs: number): Promise<number>;
+    clear(): Promise<void>;
+    destroy(): Promise<void>;
+}

package/dist/store/memory/chat-metadata.store.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaChatMetadataMemoryStore = void 0;
+const coercion_1 = require("../../util/coercion");
+const collections_1 = require("../../util/collections");
+const DEFAULTS = Object.freeze({
+    ttlMs: 30 * 60 * 1000,
+    maxChats: 2048
+});
+class WaChatMetadataMemoryStore {
+    constructor(ttlMs = DEFAULTS.ttlMs, options = {}) {
+        if (!Number.isFinite(ttlMs) || ttlMs <= 0) {
+            throw new Error('chatMetadata ttlMs must be a positive finite number');
+        }
+        this.records = new Map();
+        this.ttlMs = ttlMs;
+        this.maxChats = (0, coercion_1.resolvePositive)(options.maxChats, DEFAULTS.maxChats, 'WaChatMetadataMemoryStoreOptions.maxChats');
+        this.logger = options.logger;
+        this.capacityWarned = false;
+        this.cleanup = (0, collections_1.createPeriodicCleanup)(ttlMs, () => {
+            void this.cleanupExpired(Date.now());
+        });
+    }
+    warnCapacity() {
+        if (this.capacityWarned || !this.logger)
+            return;
+        this.capacityWarned = true;
+        this.logger.warn('chat metadata store at capacity, evicting oldest', {
+            max: this.maxChats
+        });
+    }
+    async upsertChatMetadata(snapshot) {
+        (0, collections_1.setBoundedMapEntry)(this.records, snapshot.chatJid, {
+            ...snapshot,
+            expiresAtMs: snapshot.updatedAtMs + this.ttlMs
+        }, this.maxChats, () => this.warnCapacity());
+    }
+    async getChatMetadata(chatJid, nowMs = Date.now()) {
+        const record = this.records.get(chatJid);
+        if (!record) {
+            return null;
+        }
+        if (record.expiresAtMs <= nowMs) {
+            this.records.delete(chatJid);
+            return null;
+        }
+        return record;
+    }
+    async deleteChatMetadata(chatJid) {
+        return this.records.delete(chatJid) ? 1 : 0;
+    }
+    async cleanupExpired(nowMs) {
+        let removed = 0;
+        for (const [chatJid, record] of this.records) {
+            if (record.expiresAtMs > nowMs)
+                continue;
+            this.records.delete(chatJid);
+            removed += 1;
+        }
+        return removed;
+    }
+    async clear() {
+        this.records.clear();
+    }
+    async destroy() {
+        this.cleanup.destroy();
+        await this.clear();
+    }
+}
+exports.WaChatMetadataMemoryStore = WaChatMetadataMemoryStore;

package/dist/store/noop.store.d.ts

@@ -1,3 +1,4 @@
+import type { WaChatMetadataStore } from './contracts/chat-metadata.store';
 import type { WaContactStore } from './contracts/contact.store';
 import type { WaDeviceListStore } from './contracts/device-list.store';
 import type { WaGroupMetadataStore } from './contracts/group-metadata.store';
@@ -10,5 +11,6 @@ export declare const NOOP_MESSAGE_STORE: WaMessageStore;
 export declare const NOOP_THREAD_STORE: WaThreadStore;
 export declare const NOOP_CONTACT_STORE: WaContactStore;
 export declare const NOOP_RETRY_STORE: WaRetryStore;
+export declare const NOOP_CHAT_METADATA_STORE: WaChatMetadataStore;
 export declare const NOOP_GROUP_METADATA_STORE: WaGroupMetadataStore;
 export declare const NOOP_DEVICE_LIST_STORE: WaDeviceListStore;