zapo-js 0.1.2 → 0.3.0

package/dist/esm/store/locks/pre-key.lock.js

@@ -0,0 +1,27 @@
+import { SharedExclusiveGate } from '../../infra/perf/SharedExclusiveGate.js';
+import { StoreLock } from '../../infra/perf/StoreLock.js';
+const WA_PREKEY_KEY = 'prekey:prekeys';
+const WA_PREKEY_SERVER_KEY = 'prekey:serverHasPreKeys';
+const WA_PREKEY_CLEAR_KEY = 'prekey:clear';
+export function withPreKeyLock(store) {
+    const lock = new StoreLock();
+    const gate = new SharedExclusiveGate();
+    const destroyStore = store;
+    return {
+        putPreKey: (record) => gate.runShared(() => lock.run(WA_PREKEY_KEY, () => store.putPreKey(record))),
+        getOrGenPreKeys: (count, generator) => gate.runShared(() => lock.run(WA_PREKEY_KEY, () => store.getOrGenPreKeys(count, generator))),
+        getPreKeyById: (keyId) => gate.runShared(() => store.getPreKeyById(keyId)),
+        getPreKeysById: (keyIds) => gate.runShared(() => store.getPreKeysById(keyIds)),
+        consumePreKeyById: (keyId) => gate.runShared(() => lock.run(WA_PREKEY_KEY, () => store.consumePreKeyById(keyId))),
+        getOrGenSinglePreKey: (generator) => gate.runShared(() => lock.run(WA_PREKEY_KEY, () => store.getOrGenSinglePreKey(generator))),
+        markKeyAsUploaded: (keyId) => gate.runShared(() => lock.run(WA_PREKEY_KEY, () => store.markKeyAsUploaded(keyId))),
+        setServerHasPreKeys: (value) => gate.runShared(() => lock.run(WA_PREKEY_SERVER_KEY, () => store.setServerHasPreKeys(value))),
+        getServerHasPreKeys: () => gate.runShared(() => store.getServerHasPreKeys()),
+        clear: () => gate.runExclusive(() => lock.run(WA_PREKEY_CLEAR_KEY, () => store.clear())),
+        destroy: async () => {
+            await gate.close();
+            await lock.shutdown();
+            await destroyStore.destroy?.();
+        }
+    };
+}

package/dist/esm/store/locks/privacy-token.lock.js

@@ -0,0 +1,18 @@
+import { SharedExclusiveGate } from '../../infra/perf/SharedExclusiveGate.js';
+import { StoreLock } from '../../infra/perf/StoreLock.js';
+export function withPrivacyTokenLock(store) {
+    const lock = new StoreLock();
+    const gate = new SharedExclusiveGate();
+    return {
+        destroy: async () => {
+            await gate.close();
+            await lock.shutdown();
+            await store.destroy?.();
+        },
+        upsert: (record) => gate.runShared(() => lock.run(`pt:${record.jid}`, () => store.upsert(record))),
+        upsertBatch: (records) => gate.runExclusive(() => store.upsertBatch(records)),
+        getByJid: (jid) => gate.runShared(() => store.getByJid(jid)),
+        deleteByJid: (jid) => gate.runShared(() => lock.run(`pt:${jid}`, () => store.deleteByJid(jid))),
+        clear: () => gate.runExclusive(() => store.clear())
+    };
+}

package/dist/esm/store/locks/retry.lock.js

@@ -0,0 +1,29 @@
+import { SharedExclusiveGate } from '../../infra/perf/SharedExclusiveGate.js';
+import { StoreLock } from '../../infra/perf/StoreLock.js';
+const WA_RETRY_CLEANUP_KEY = 'retry:cleanup';
+const WA_RETRY_CLEAR_KEY = 'retry:clear';
+export function withRetryLock(store) {
+    const lock = new StoreLock();
+    const gate = new SharedExclusiveGate();
+    return {
+        getTtlMs: store.getTtlMs?.bind(store),
+        supportsRawReplayPayload: store.supportsRawReplayPayload?.bind(store),
+        destroy: async () => {
+            await gate.close();
+            await lock.shutdown();
+            await store.destroy?.();
+        },
+        getOutboundRequesterStatus: (messageId, requesterDeviceJid) => gate.runShared(() => store.getOutboundRequesterStatus(messageId, requesterDeviceJid)),
+        upsertOutboundMessage: (record) => gate.runShared(() => lock.run(`retry:outbound:${record.messageId}`, () => store.upsertOutboundMessage(record))),
+        deleteOutboundMessage: (messageId) => gate.runShared(() => lock.run(`retry:outbound:${messageId}`, () => store.deleteOutboundMessage(messageId))),
+        getOutboundMessage: (messageId) => gate.runShared(() => store.getOutboundMessage(messageId)),
+        updateOutboundMessageState: (messageId, state, updatedAtMs, expiresAtMs) => gate.runShared(() => lock.run(`retry:outbound:${messageId}`, () => store.updateOutboundMessageState(messageId, state, updatedAtMs, expiresAtMs))),
+        markOutboundRequesterDelivered: (messageId, requesterDeviceJid, updatedAtMs, expiresAtMs) => gate.runShared(() => lock.runMany([
+            `retry:outbound:${messageId}`,
+            `retry:outbound:${messageId}:${requesterDeviceJid}`
+        ], () => store.markOutboundRequesterDelivered(messageId, requesterDeviceJid, updatedAtMs, expiresAtMs))),
+        incrementInboundCounter: (messageId, requesterJid, updatedAtMs, expiresAtMs) => gate.runShared(() => lock.run(`retry:inbound:${messageId}:${requesterJid}`, () => store.incrementInboundCounter(messageId, requesterJid, updatedAtMs, expiresAtMs))),
+        cleanupExpired: (nowMs) => gate.runExclusive(() => lock.run(WA_RETRY_CLEANUP_KEY, () => store.cleanupExpired(nowMs))),
+        clear: () => gate.runExclusive(() => lock.run(WA_RETRY_CLEAR_KEY, () => store.clear()))
+    };
+}

package/dist/esm/store/locks/sender-key.lock.js

@@ -0,0 +1,52 @@
+import { SharedExclusiveGate } from '../../infra/perf/SharedExclusiveGate.js';
+import { StoreLock } from '../../infra/perf/StoreLock.js';
+import { signalAddressKey } from '../../protocol/jid.js';
+const WA_SENDER_KEY_CLEAR_KEY = 'senderKey:clear';
+function senderKeyLockKey(groupId, sender) {
+    return `senderKey:${groupId}:${signalAddressKey(sender)}`;
+}
+function senderDistributionLockKey(groupId, sender) {
+    return `senderKeyDistribution:${groupId}:${signalAddressKey(sender)}`;
+}
+function senderAnyLockKey(sender) {
+    return `senderKey:any:${signalAddressKey(sender)}`;
+}
+export function withSenderKeyLock(store) {
+    const lock = new StoreLock();
+    const gate = new SharedExclusiveGate();
+    const destroyStore = store;
+    return {
+        upsertSenderKey: (record) => gate.runShared(() => lock.runMany([
+            senderAnyLockKey(record.sender),
+            senderKeyLockKey(record.groupId, record.sender)
+        ], () => store.upsertSenderKey(record))),
+        upsertSenderKeyDistribution: (record) => gate.runShared(() => lock.runMany([
+            senderAnyLockKey(record.sender),
+            senderDistributionLockKey(record.groupId, record.sender)
+        ], () => store.upsertSenderKeyDistribution(record))),
+        upsertSenderKeyDistributions: (records) => gate.runShared(() => lock.runMany(records.flatMap((record) => [
+            senderAnyLockKey(record.sender),
+            senderDistributionLockKey(record.groupId, record.sender)
+        ]), () => store.upsertSenderKeyDistributions(records))),
+        getGroupSenderKeyList: (groupId) => gate.runShared(() => store.getGroupSenderKeyList(groupId)),
+        getDeviceSenderKey: (groupId, sender) => gate.runShared(() => store.getDeviceSenderKey(groupId, sender)),
+        getDeviceSenderKeyDistributions: (groupId, senders) => gate.runShared(() => store.getDeviceSenderKeyDistributions(groupId, senders)),
+        deleteDeviceSenderKey: (target, groupId) => gate.runShared(() => lock.runMany(groupId
+            ? [
+                senderAnyLockKey(target),
+                senderKeyLockKey(groupId, target),
+                senderDistributionLockKey(groupId, target)
+            ]
+            : [senderAnyLockKey(target)], () => store.deleteDeviceSenderKey(target, groupId))),
+        markForgetSenderKey: (groupId, participants) => gate.runShared(() => lock.runMany(participants.flatMap((participant) => [
+            senderAnyLockKey(participant),
+            senderKeyLockKey(groupId, participant)
+        ]), () => store.markForgetSenderKey(groupId, participants))),
+        clear: () => gate.runExclusive(() => lock.run(WA_SENDER_KEY_CLEAR_KEY, () => store.clear())),
+        destroy: async () => {
+            await gate.close();
+            await lock.shutdown();
+            await destroyStore.destroy?.();
+        }
+    };
+}

package/dist/esm/store/locks/session.lock.js

@@ -0,0 +1,19 @@
+import { SharedExclusiveGate } from '../../infra/perf/SharedExclusiveGate.js';
+export function withSessionLock(store) {
+    const gate = new SharedExclusiveGate();
+    const destroyStore = store;
+    return {
+        hasSession: (address) => gate.runShared(() => store.hasSession(address)),
+        hasSessions: (addresses) => gate.runShared(() => store.hasSessions(addresses)),
+        getSession: (address) => gate.runShared(() => store.getSession(address)),
+        getSessionsBatch: (addresses) => gate.runShared(() => store.getSessionsBatch(addresses)),
+        setSession: (address, session) => gate.runShared(() => store.setSession(address, session)),
+        setSessionsBatch: (entries) => gate.runShared(() => store.setSessionsBatch(entries)),
+        deleteSession: (address) => gate.runShared(() => store.deleteSession(address)),
+        clear: () => gate.runExclusive(() => store.clear()),
+        destroy: async () => {
+            await gate.close();
+            await destroyStore.destroy?.();
+        }
+    };
+}

package/dist/esm/store/locks/signal.lock.js

@@ -0,0 +1,39 @@
+import { SharedExclusiveGate } from '../../infra/perf/SharedExclusiveGate.js';
+import { StoreLock } from '../../infra/perf/StoreLock.js';
+const WA_SIGNAL_REGISTRATION_KEY = 'signal:registration';
+const WA_SIGNAL_SIGNED_PREKEY_KEY = 'signal:signedPreKey';
+const WA_SIGNAL_CLEAR_KEY = 'signal:clear';
+export function withSignalLock(store) {
+    const lock = new StoreLock();
+    const gate = new SharedExclusiveGate();
+    const destroyStore = store;
+    let cachedRegInfo;
+    return {
+        getRegistrationInfo: () => gate.runShared(async () => {
+            if (cachedRegInfo !== undefined) {
+                return cachedRegInfo;
+            }
+            const info = await store.getRegistrationInfo();
+            cachedRegInfo = info;
+            return info;
+        }),
+        setRegistrationInfo: (info) => gate.runShared(() => lock.run(WA_SIGNAL_REGISTRATION_KEY, async () => {
+            await store.setRegistrationInfo(info);
+            cachedRegInfo = info;
+        })),
+        getSignedPreKey: () => gate.runShared(() => store.getSignedPreKey()),
+        setSignedPreKey: (record) => gate.runShared(() => lock.run(WA_SIGNAL_SIGNED_PREKEY_KEY, () => store.setSignedPreKey(record))),
+        getSignedPreKeyById: (keyId) => gate.runShared(() => store.getSignedPreKeyById(keyId)),
+        setSignedPreKeyRotationTs: (value) => gate.runShared(() => lock.run(WA_SIGNAL_SIGNED_PREKEY_KEY, () => store.setSignedPreKeyRotationTs(value))),
+        getSignedPreKeyRotationTs: () => gate.runShared(() => store.getSignedPreKeyRotationTs()),
+        clear: () => gate.runExclusive(() => lock.run(WA_SIGNAL_CLEAR_KEY, async () => {
+            await store.clear();
+            cachedRegInfo = undefined;
+        })),
+        destroy: async () => {
+            await gate.close();
+            await lock.shutdown();
+            await destroyStore.destroy?.();
+        }
+    };
+}

package/dist/esm/store/locks/thread.lock.js

@@ -0,0 +1,21 @@
+import { SharedExclusiveGate } from '../../infra/perf/SharedExclusiveGate.js';
+import { StoreLock } from '../../infra/perf/StoreLock.js';
+const WA_THREAD_CLEAR_KEY = 'thread:clear';
+export function withThreadLock(store) {
+    const lock = new StoreLock();
+    const gate = new SharedExclusiveGate();
+    const destroyStore = store;
+    return {
+        upsert: (record) => gate.runShared(() => lock.run(`thread:${record.jid}`, () => store.upsert(record))),
+        upsertBatch: (records) => gate.runShared(() => lock.runMany(records.map((record) => `thread:${record.jid}`), () => store.upsertBatch(records))),
+        getByJid: (jid) => gate.runShared(() => store.getByJid(jid)),
+        list: (limit) => gate.runShared(() => store.list(limit)),
+        deleteByJid: (jid) => gate.runShared(() => lock.run(`thread:${jid}`, () => store.deleteByJid(jid))),
+        clear: () => gate.runExclusive(() => lock.run(WA_THREAD_CLEAR_KEY, () => store.clear())),
+        destroy: async () => {
+            await gate.close();
+            await lock.shutdown();
+            await destroyStore.destroy?.();
+        }
+    };
+}

package/dist/esm/store/noop.store.js

@@ -1,4 +1,12 @@
 const EMPTY_STORE_LIST = Object.freeze([]);
+export const NOOP_MESSAGE_SECRET_STORE = Object.freeze({
+    get: async (_messageId) => null,
+    getBatch: async (messageIds) => new Array(messageIds.length).fill(null),
+    set: async (_messageId, _entry) => { },
+    setBatch: async (_entries) => { },
+    cleanupExpired: async (_nowMs) => 0,
+    clear: async () => { }
+});
 export const NOOP_MESSAGE_STORE = Object.freeze({
     upsert: async (_record) => { },
     upsertBatch: async (_records) => { },
@@ -22,6 +30,18 @@ export const NOOP_CONTACT_STORE = Object.freeze({
     deleteByJid: async (_jid) => 0,
     clear: async () => { }
 });
+export const NOOP_RETRY_STORE = Object.freeze({
+    getOutboundRequesterStatus: async () => null,
+    upsertOutboundMessage: async (_record) => { },
+    deleteOutboundMessage: async (_messageId) => 0,
+    getOutboundMessage: async (_messageId) => null,
+    updateOutboundMessageState: async () => { },
+    markOutboundRequesterDelivered: async () => { },
+    incrementInboundCounter: async () => 0,
+    cleanupExpired: async (_nowMs) => 0,
+    clear: async () => { },
+    destroy: async () => { }
+});
 export const NOOP_PARTICIPANTS_STORE = Object.freeze({
     upsertGroupParticipants: async (_snapshot) => { },
     getGroupParticipants: async (_groupJid, _nowMs) => null,
@@ -32,7 +52,7 @@ export const NOOP_PARTICIPANTS_STORE = Object.freeze({
 });
 export const NOOP_DEVICE_LIST_STORE = Object.freeze({
     upsertUserDevicesBatch: async (_snapshots) => { },
-    getUserDevicesBatch: async (userJids, _nowMs) => userJids.map(() => null),
+    getUserDevicesBatch: async (userJids, _nowMs) => new Array(userJids.length).fill(null),
     deleteUserDevices: async (_userJid) => 0,
     cleanupExpired: async (_nowMs) => 0,
     clear: async () => { },

package/dist/esm/store/providers/memory/appstate.store.js

@@ -7,13 +7,6 @@ const DEFAULT_APPSTATE_MEMORY_STORE_LIMITS = Object.freeze({
     syncKeys: 4096,
     collectionEntries: 50000
 });
-function toBoundedMap(entries, maxEntries) {
-    const map = new Map();
-    for (const [key, value] of entries) {
-        setBoundedMapEntry(map, key, value, maxEntries);
-    }
-    return map;
-}
 export class WaAppStateMemoryStore {
     constructor(initial, options = {}) {
         this.keys = new Map();
@@ -28,11 +21,15 @@ export class WaAppStateMemoryStore {
                 if (!collection) {
                     continue;
                 }
+                const indexValueMap = new Map();
+                for (const [key, value] of Object.entries(collection.indexValueMap)) {
+                    setBoundedMapEntry(indexValueMap, key, value, this.maxCollectionEntries);
+                }
                 this.collections.set(collectionName, {
                     initialized: true,
                     version: collection.version,
                     hash: collection.hash,
-                    indexValueMap: toBoundedMap(Object.entries(collection.indexValueMap), this.maxCollectionEntries)
+                    indexValueMap
                 });
             }
         }
@@ -65,14 +62,22 @@ export class WaAppStateMemoryStore {
         }
         return inserted;
     }
-    async getSyncKey(keyId) {
-        return this.keys.get(bytesToHex(keyId)) ?? null;
+    async getSyncKeysBatch(keyIds) {
+        const keys = new Array(keyIds.length);
+        for (let index = 0; index < keyIds.length; index += 1) {
+            keys[index] = this.keys.get(bytesToHex(keyIds[index])) ?? null;
+        }
+        return keys;
     }
     async getSyncKeyData(keyId) {
         return this.keys.get(bytesToHex(keyId))?.keyData ?? null;
     }
     async getSyncKeyDataBatch(keyIds) {
-        return keyIds.map((keyId) => this.keys.get(bytesToHex(keyId))?.keyData ?? null);
+        const keys = new Array(keyIds.length);
+        for (let index = 0; index < keyIds.length; index += 1) {
+            keys[index] = this.keys.get(bytesToHex(keyIds[index]))?.keyData ?? null;
+        }
+        return keys;
     }
     async getActiveSyncKey() {
         return pickActiveSyncKey(this.keys.values());
@@ -93,28 +98,21 @@ export class WaAppStateMemoryStore {
     async getCollectionStates(collections) {
         const result = new Array(collections.length);
         for (let index = 0; index < collections.length; index += 1) {
-            const collection = collections[index];
-            let state = this.collections.get(collection);
-            if (!state) {
-                state = {
-                    initialized: false,
-                    version: 0,
-                    hash: APP_STATE_EMPTY_LT_HASH,
-                    indexValueMap: new Map()
-                };
-                this.collections.set(collection, state);
-            }
-            result[index] = state;
+            result[index] = await this.getCollectionState(collections[index]);
         }
         return result;
     }
     async setCollectionStates(updates) {
         for (const update of updates) {
+            const indexValueMap = new Map();
+            for (const [key, value] of update.indexValueMap.entries()) {
+                setBoundedMapEntry(indexValueMap, key, value, this.maxCollectionEntries);
+            }
             this.collections.set(update.collection, {
                 initialized: true,
                 version: update.version,
                 hash: update.hash,
-                indexValueMap: toBoundedMap(update.indexValueMap.entries(), this.maxCollectionEntries)
+                indexValueMap
             });
         }
     }

package/dist/esm/store/providers/memory/device-list.store.js

@@ -6,6 +6,9 @@ const DEFAULTS = Object.freeze({
 });
 export class WaDeviceListMemoryStore {
     constructor(ttlMs = DEFAULTS.ttlMs, options = {}) {
+        if (!Number.isFinite(ttlMs) || ttlMs <= 0) {
+            throw new Error('device-list ttlMs must be a positive finite number');
+        }
         this.records = new Map();
         this.ttlMs = ttlMs;
         this.maxUsers = resolvePositive(options.maxUsers, DEFAULTS.maxUsers, 'WaDeviceListMemoryStoreOptions.maxUsers');
@@ -24,17 +27,22 @@ export class WaDeviceListMemoryStore {
         }
     }
     async getUserDevicesBatch(userJids, nowMs = Date.now()) {
-        return userJids.map((userJid) => {
+        const snapshots = new Array(userJids.length);
+        for (let index = 0; index < userJids.length; index += 1) {
+            const userJid = userJids[index];
             const record = this.records.get(userJid);
             if (!record) {
-                return null;
+                snapshots[index] = null;
+                continue;
             }
             if (record.expiresAtMs <= nowMs) {
                 this.records.delete(userJid);
-                return null;
+                snapshots[index] = null;
+                continue;
             }
-            return record;
-        });
+            snapshots[index] = record;
+        }
+        return snapshots;
     }
     async deleteUserDevices(userJid) {
         return this.records.delete(userJid) ? 1 : 0;

package/dist/esm/store/providers/memory/identity.store.js

@@ -0,0 +1,31 @@
+import { signalAddressKey } from '../../../protocol/jid.js';
+import { resolvePositive } from '../../../util/coercion.js';
+import { setBoundedMapEntry } from '../../../util/collections.js';
+const DEFAULT_MAX_REMOTE_IDENTITIES = 8192;
+export class WaIdentityMemoryStore {
+    constructor(options = {}) {
+        this.remoteIdentities = new Map();
+        this.maxRemoteIdentities = resolvePositive(options.maxRemoteIdentities, DEFAULT_MAX_REMOTE_IDENTITIES, 'WaIdentityMemoryStoreOptions.maxRemoteIdentities');
+    }
+    async getRemoteIdentity(address) {
+        return this.remoteIdentities.get(signalAddressKey(address)) ?? null;
+    }
+    async getRemoteIdentities(addresses) {
+        const result = new Array(addresses.length);
+        for (let i = 0; i < addresses.length; i += 1) {
+            result[i] = this.remoteIdentities.get(signalAddressKey(addresses[i])) ?? null;
+        }
+        return result;
+    }
+    async setRemoteIdentity(address, identityKey) {
+        setBoundedMapEntry(this.remoteIdentities, signalAddressKey(address), identityKey, this.maxRemoteIdentities);
+    }
+    async setRemoteIdentities(entries) {
+        for (const entry of entries) {
+            setBoundedMapEntry(this.remoteIdentities, signalAddressKey(entry.address), entry.identityKey, this.maxRemoteIdentities);
+        }
+    }
+    async clear() {
+        this.remoteIdentities.clear();
+    }
+}

package/dist/esm/store/providers/memory/message-secret.store.js

@@ -0,0 +1,81 @@
+import { resolvePositive } from '../../../util/coercion.js';
+import { resolveCleanupIntervalMs, setBoundedMapEntry } from '../../../util/collections.js';
+const DEFAULTS = Object.freeze({
+    ttlMs: 30 * 60 * 1000,
+    maxSecrets: 10000
+});
+export class WaMessageSecretMemoryStore {
+    constructor(ttlMs = DEFAULTS.ttlMs, options = {}) {
+        if (!Number.isFinite(ttlMs) || ttlMs <= 0) {
+            throw new Error('message-secret ttlMs must be a positive finite number');
+        }
+        this.secrets = new Map();
+        this.ttlMs = ttlMs;
+        this.maxSecrets = resolvePositive(options.maxSecrets, DEFAULTS.maxSecrets, 'WaMessageSecretMemoryStoreOptions.maxSecrets');
+        this.cleanupTimer = setInterval(() => {
+            void this.cleanupExpired(Date.now());
+        }, resolveCleanupIntervalMs(ttlMs));
+        this.cleanupTimer.unref();
+    }
+    async get(messageId, nowMs = Date.now()) {
+        const cached = this.secrets.get(messageId);
+        if (!cached)
+            return null;
+        if (cached.expiresAtMs <= nowMs) {
+            this.secrets.delete(messageId);
+            return null;
+        }
+        return { secret: cached.secret, senderJid: cached.senderJid };
+    }
+    async getBatch(messageIds, nowMs = Date.now()) {
+        const result = new Array(messageIds.length);
+        for (let i = 0; i < messageIds.length; i += 1) {
+            const cached = this.secrets.get(messageIds[i]);
+            if (!cached) {
+                result[i] = null;
+                continue;
+            }
+            if (cached.expiresAtMs <= nowMs) {
+                this.secrets.delete(messageIds[i]);
+                result[i] = null;
+                continue;
+            }
+            result[i] = { secret: cached.secret, senderJid: cached.senderJid };
+        }
+        return result;
+    }
+    async set(messageId, entry) {
+        setBoundedMapEntry(this.secrets, messageId, {
+            secret: entry.secret,
+            senderJid: entry.senderJid,
+            expiresAtMs: Date.now() + this.ttlMs
+        }, this.maxSecrets);
+    }
+    async setBatch(entries) {
+        const nowMs = Date.now();
+        for (let i = 0; i < entries.length; i += 1) {
+            setBoundedMapEntry(this.secrets, entries[i].messageId, {
+                secret: entries[i].entry.secret,
+                senderJid: entries[i].entry.senderJid,
+                expiresAtMs: nowMs + this.ttlMs
+            }, this.maxSecrets);
+        }
+    }
+    async cleanupExpired(nowMs) {
+        let removed = 0;
+        for (const [messageId, entry] of this.secrets) {
+            if (entry.expiresAtMs > nowMs)
+                continue;
+            this.secrets.delete(messageId);
+            removed += 1;
+        }
+        return removed;
+    }
+    async clear() {
+        this.secrets.clear();
+    }
+    async destroy() {
+        clearInterval(this.cleanupTimer);
+        this.secrets.clear();
+    }
+}

package/dist/esm/store/providers/memory/participants.store.js

@@ -6,6 +6,9 @@ const DEFAULTS = Object.freeze({
 });
 export class WaParticipantsMemoryStore {
     constructor(ttlMs = DEFAULTS.ttlMs, options = {}) {
+        if (!Number.isFinite(ttlMs) || ttlMs <= 0) {
+            throw new Error('participants ttlMs must be a positive finite number');
+        }
         this.records = new Map();
         this.ttlMs = ttlMs;
         this.maxGroups = resolvePositive(options.maxGroups, DEFAULTS.maxGroups, 'WaParticipantsMemoryStoreOptions.maxGroups');

package/dist/esm/store/providers/memory/pre-key.store.js

@@ -0,0 +1,97 @@
+import { resolvePositive } from '../../../util/coercion.js';
+import { setBoundedMapEntry } from '../../../util/collections.js';
+const DEFAULT_MAX_PRE_KEYS = 4096;
+export class WaPreKeyMemoryStore {
+    constructor(options = {}) {
+        this.preKeys = new Map();
+        this.uploadedPreKeys = new Set();
+        this.serverHasPreKeys = false;
+        this.nextPreKeyId = 1;
+        this.maxPreKeys = resolvePositive(options.maxPreKeys, DEFAULT_MAX_PRE_KEYS, 'WaPreKeyMemoryStoreOptions.maxPreKeys');
+    }
+    async putPreKey(record) {
+        setBoundedMapEntry(this.preKeys, record.keyId, record, this.maxPreKeys, (keyId) => {
+            this.uploadedPreKeys.delete(keyId);
+        });
+        if (record.keyId >= this.nextPreKeyId) {
+            this.nextPreKeyId = record.keyId + 1;
+        }
+    }
+    async getOrGenPreKeys(count, generator) {
+        if (!Number.isSafeInteger(count) || count <= 0) {
+            throw new Error(`invalid prekey count: ${count}`);
+        }
+        const available = [];
+        const availableKeyIds = [];
+        for (const keyId of this.preKeys.keys()) {
+            if (!this.uploadedPreKeys.has(keyId)) {
+                availableKeyIds.push(keyId);
+            }
+        }
+        availableKeyIds.sort((left, right) => left - right);
+        for (let index = 0; index < availableKeyIds.length; index += 1) {
+            const keyId = availableKeyIds[index];
+            const record = this.preKeys.get(keyId);
+            if (!record) {
+                continue;
+            }
+            available.push(record);
+            if (available.length >= count) {
+                return available;
+            }
+        }
+        while (available.length < count) {
+            const record = await generator(this.nextPreKeyId++);
+            setBoundedMapEntry(this.preKeys, record.keyId, record, this.maxPreKeys, (keyId) => {
+                this.uploadedPreKeys.delete(keyId);
+            });
+            available.push(record);
+        }
+        return available;
+    }
+    async getPreKeyById(keyId) {
+        return this.preKeys.get(keyId) ?? null;
+    }
+    async getPreKeysById(keyIds) {
+        const result = new Array(keyIds.length);
+        for (let i = 0; i < keyIds.length; i += 1) {
+            result[i] = this.preKeys.get(keyIds[i]) ?? null;
+        }
+        return result;
+    }
+    async consumePreKeyById(keyId) {
+        const record = this.preKeys.get(keyId) ?? null;
+        if (!record) {
+            return null;
+        }
+        this.preKeys.delete(keyId);
+        this.uploadedPreKeys.delete(keyId);
+        return record;
+    }
+    async getOrGenSinglePreKey(generator) {
+        const preKeys = await this.getOrGenPreKeys(1, generator);
+        return preKeys[0];
+    }
+    async markKeyAsUploaded(keyId) {
+        if (keyId < 0 || keyId >= this.nextPreKeyId) {
+            throw new Error(`prekey ${keyId} is out of boundary`);
+        }
+        for (const candidate of this.preKeys.keys()) {
+            if (candidate <= keyId) {
+                this.uploadedPreKeys.add(candidate);
+            }
+        }
+    }
+    async setServerHasPreKeys(value) {
+        this.serverHasPreKeys = value;
+    }
+    async getServerHasPreKeys() {
+        return this.serverHasPreKeys;
+    }
+    async clear() {
+        this.preKeys.clear();
+        this.uploadedPreKeys.clear();
+        this.serverHasPreKeys = false;
+        this.nextPreKeyId = 1;
+    }
+}

package/dist/esm/store/providers/memory/privacy-token.store.js

@@ -0,0 +1,43 @@
+import { setBoundedMapEntry } from '../../../util/collections.js';
+const DEFAULT_MAX_ENTRIES = 10000;
+export class WaPrivacyTokenMemoryStore {
+    constructor(maxEntries = DEFAULT_MAX_ENTRIES) {
+        this.records = new Map();
+        this.maxEntries = maxEntries;
+    }
+    async upsert(record) {
+        const existing = this.records.get(record.jid);
+        const merged = existing ? this.mergeRecord(existing, record) : record;
+        setBoundedMapEntry(this.records, record.jid, merged, this.maxEntries);
+    }
+    async upsertBatch(records) {
+        for (let i = 0; i < records.length; i += 1) {
+            const record = records[i];
+            const existing = this.records.get(record.jid);
+            const merged = existing ? this.mergeRecord(existing, record) : record;
+            setBoundedMapEntry(this.records, record.jid, merged, this.maxEntries);
+        }
+    }
+    async getByJid(jid) {
+        return this.records.get(jid) ?? null;
+    }
+    async deleteByJid(jid) {
+        return this.records.delete(jid) ? 1 : 0;
+    }
+    async clear() {
+        this.records.clear();
+    }
+    async destroy() {
+        this.records.clear();
+    }
+    mergeRecord(existing, incoming) {
+        return {
+            jid: incoming.jid,
+            tcToken: incoming.tcToken ?? existing.tcToken,
+            tcTokenTimestamp: incoming.tcTokenTimestamp ?? existing.tcTokenTimestamp,
+            tcTokenSenderTimestamp: incoming.tcTokenSenderTimestamp ?? existing.tcTokenSenderTimestamp,
+            nctSalt: incoming.nctSalt ?? existing.nctSalt,
+            updatedAtMs: incoming.updatedAtMs
+        };
+    }
+}