zapo-js 0.2.0 → 0.3.0

package/dist/esm/store/createStore.js

@@ -2,29 +2,38 @@ import { withAppStateLock } from './locks/appstate.lock.js';
 import { withAuthLock } from './locks/auth.lock.js';
 import { withContactLock } from './locks/contact.lock.js';
 import { withDeviceListLock } from './locks/device-list.lock.js';
+import { withIdentityLock } from './locks/identity.lock.js';
+import { withMessageSecretLock } from './locks/message-secret.lock.js';
 import { withMessageLock } from './locks/message.lock.js';
 import { withParticipantsLock } from './locks/participants.lock.js';
+import { withPreKeyLock } from './locks/pre-key.lock.js';
 import { withPrivacyTokenLock } from './locks/privacy-token.lock.js';
 import { withRetryLock } from './locks/retry.lock.js';
 import { withSenderKeyLock } from './locks/sender-key.lock.js';
+import { withSessionLock } from './locks/session.lock.js';
 import { withSignalLock } from './locks/signal.lock.js';
 import { withThreadLock } from './locks/thread.lock.js';
-import { NOOP_CONTACT_STORE, NOOP_DEVICE_LIST_STORE, NOOP_MESSAGE_STORE, NOOP_PARTICIPANTS_STORE, NOOP_THREAD_STORE } from './noop.store.js';
+import { NOOP_CONTACT_STORE, NOOP_DEVICE_LIST_STORE, NOOP_MESSAGE_SECRET_STORE, NOOP_MESSAGE_STORE, NOOP_PARTICIPANTS_STORE, NOOP_RETRY_STORE, NOOP_THREAD_STORE } from './noop.store.js';
 import { WaAppStateMemoryStore } from './providers/memory/appstate.store.js';
 import { WaContactMemoryStore } from './providers/memory/contact.store.js';
 import { WaDeviceListMemoryStore } from './providers/memory/device-list.store.js';
+import { WaIdentityMemoryStore } from './providers/memory/identity.store.js';
+import { WaMessageSecretMemoryStore } from './providers/memory/message-secret.store.js';
 import { WaMessageMemoryStore } from './providers/memory/message.store.js';
 import { WaParticipantsMemoryStore } from './providers/memory/participants.store.js';
+import { WaPreKeyMemoryStore } from './providers/memory/pre-key.store.js';
 import { WaPrivacyTokenMemoryStore } from './providers/memory/privacy-token.store.js';
 import { WaRetryMemoryStore } from './providers/memory/retry.store.js';
 import { SenderKeyMemoryStore } from './providers/memory/sender-key.store.js';
+import { WaSessionMemoryStore } from './providers/memory/session.store.js';
 import { WaSignalMemoryStore } from './providers/memory/signal.store.js';
 import { WaThreadMemoryStore } from './providers/memory/thread.store.js';
 import { resolvePositive } from '../util/coercion.js';
 const DEFAULT_CACHE_TTLS_MS = Object.freeze({
     retryMs: 60 * 1000,
     participantsMs: 5 * 60 * 1000,
-    deviceListMs: 5 * 60 * 1000
+    deviceListMs: 5 * 60 * 1000,
+    messageSecretMs: 30 * 60 * 1000
 });
 function hasDestroy(value) {
     return (!!value &&
@@ -58,7 +67,8 @@ export function createStore(options) {
     const cacheTtlsMs = Object.freeze({
         retry: resolvePositive(options.memory?.cacheTtlMs?.retryMs, DEFAULT_CACHE_TTLS_MS.retryMs, 'memory.cacheTtlMs.retryMs'),
         participants: resolvePositive(options.memory?.cacheTtlMs?.participantsMs, DEFAULT_CACHE_TTLS_MS.participantsMs, 'memory.cacheTtlMs.participantsMs'),
-        deviceList: resolvePositive(options.memory?.cacheTtlMs?.deviceListMs, DEFAULT_CACHE_TTLS_MS.deviceListMs, 'memory.cacheTtlMs.deviceListMs')
+        deviceList: resolvePositive(options.memory?.cacheTtlMs?.deviceListMs, DEFAULT_CACHE_TTLS_MS.deviceListMs, 'memory.cacheTtlMs.deviceListMs'),
+        messageSecret: resolvePositive(options.memory?.cacheTtlMs?.messageSecretMs, DEFAULT_CACHE_TTLS_MS.messageSecretMs, 'memory.cacheTtlMs.messageSecretMs')
     });
     const sessions = new Map();
     let storeDestroyed = false;
@@ -78,9 +88,10 @@ export function createStore(options) {
             const rawAuth = resolveStore(id, backends, providers.auth, 'auth', 'stores', () => {
                 throw new Error('providers.auth is required — register a backend or set providers.auth');
             });
-            const rawSignal = resolveStore(id, backends, providers.signal ?? 'memory', 'signal', 'stores', () => new WaSignalMemoryStore({
-                maxPreKeys: ml.signalPreKeys,
-                maxSessions: ml.signalSessions,
+            const rawSignal = resolveStore(id, backends, providers.signal ?? 'memory', 'signal', 'stores', () => new WaSignalMemoryStore());
+            const rawPreKey = resolveStore(id, backends, providers.preKey ?? 'memory', 'preKey', 'stores', () => new WaPreKeyMemoryStore({ maxPreKeys: ml.signalPreKeys }));
+            const rawSession = resolveStore(id, backends, providers.session ?? 'memory', 'session', 'stores', () => new WaSessionMemoryStore({ maxSessions: ml.signalSessions }));
+            const rawIdentity = resolveStore(id, backends, providers.identity ?? 'memory', 'identity', 'stores', () => new WaIdentityMemoryStore({
                 maxRemoteIdentities: ml.signalRemoteIdentities
             }));
             const rawSenderKey = resolveStore(id, backends, providers.senderKey ?? 'memory', 'senderKey', 'stores', () => new SenderKeyMemoryStore({
@@ -101,7 +112,12 @@ export function createStore(options) {
                 ? new WaContactMemoryStore({ maxContacts: ml.contacts })
                 : NOOP_CONTACT_STORE);
             const rawPrivacyToken = resolveStore(id, backends, providers.privacyToken ?? 'memory', 'privacyToken', 'stores', () => new WaPrivacyTokenMemoryStore(ml.privacyTokens));
-            const rawRetry = resolveStore(id, backends, cacheProviders.retry ?? 'memory', 'retry', 'caches', () => new WaRetryMemoryStore(cacheTtlsMs.retry));
+            const rawRetry = resolveStore(id, backends, cacheProviders.retry ?? 'memory', 'retry', 'caches', () => cacheProviders.retry === 'memory' || !cacheProviders.retry
+                ? new WaRetryMemoryStore(cacheTtlsMs.retry, {
+                    maxOutboundMessages: ml.retryOutboundMessages,
+                    maxInboundCounters: ml.retryInboundCounters
+                })
+                : NOOP_RETRY_STORE);
             const rawParticipants = resolveStore(id, backends, cacheProviders.participants ?? 'memory', 'participants', 'caches', () => cacheProviders.participants === 'memory'
                 ? new WaParticipantsMemoryStore(cacheTtlsMs.participants, {
                     maxGroups: ml.participantsGroups
@@ -112,14 +128,23 @@ export function createStore(options) {
                     maxUsers: ml.deviceListUsers
                 })
                 : NOOP_DEVICE_LIST_STORE);
+            const rawMessageSecret = resolveStore(id, backends, cacheProviders.messageSecret ?? 'none', 'messageSecret', 'caches', () => cacheProviders.messageSecret === 'memory'
+                ? new WaMessageSecretMemoryStore(cacheTtlsMs.messageSecret, {
+                    maxSecrets: ml.messageSecrets
+                })
+                : NOOP_MESSAGE_SECRET_STORE);
             const authStore = withAuthLock(rawAuth);
             const signalStore = withSignalLock(rawSignal);
+            const preKeyStore = withPreKeyLock(rawPreKey);
+            const sessionStore = withSessionLock(rawSession);
+            const identityStore = withIdentityLock(rawIdentity);
             const senderKeyStore = withSenderKeyLock(rawSenderKey);
             const appStateStore = withAppStateLock(rawAppState);
             const retryStore = withRetryLock(rawRetry);
             const participantsStore = withParticipantsLock(rawParticipants);
             const deviceListStore = withDeviceListLock(rawDeviceList);
             const messageStore = withMessageLock(rawMessages);
+            const messageSecretStore = withMessageSecretLock(rawMessageSecret);
             const threadStore = withThreadLock(rawThreads);
             const contactStore = withContactLock(rawContacts);
             const privacyTokenStore = withPrivacyTokenLock(rawPrivacyToken);
@@ -132,12 +157,14 @@ export function createStore(options) {
                 await Promise.all([
                     retryStore.clear(),
                     participantsStore.clear(),
-                    deviceListStore.clear()
+                    deviceListStore.clear(),
+                    messageSecretStore.clear()
                 ]);
                 await Promise.all([
                     destroyIfSupported(retryStore),
                     destroyIfSupported(participantsStore),
-                    destroyIfSupported(deviceListStore)
+                    destroyIfSupported(deviceListStore),
+                    destroyIfSupported(messageSecretStore)
                 ]);
             };
             const destroy = async () => {
@@ -148,6 +175,9 @@ export function createStore(options) {
                 await Promise.all([
                     destroyIfSupported(authStore),
                     destroyIfSupported(signalStore),
+                    destroyIfSupported(preKeyStore),
+                    destroyIfSupported(sessionStore),
+                    destroyIfSupported(identityStore),
                     destroyIfSupported(senderKeyStore),
                     destroyIfSupported(appStateStore),
                     destroyIfSupported(messageStore),
@@ -156,23 +186,27 @@ export function createStore(options) {
                     destroyIfSupported(privacyTokenStore)
                 ]);
             };
-            const session = {
+            const storeSession = {
                 auth: authStore,
                 signal: signalStore,
+                preKey: preKeyStore,
+                session: sessionStore,
+                identity: identityStore,
                 senderKey: senderKeyStore,
                 appState: appStateStore,
                 retry: retryStore,
                 participants: participantsStore,
                 deviceList: deviceListStore,
                 messages: messageStore,
+                messageSecret: messageSecretStore,
                 threads: threadStore,
                 contacts: contactStore,
                 privacyToken: privacyTokenStore,
                 destroyCaches,
                 destroy
             };
-            sessions.set(id, session);
-            return session;
+            sessions.set(id, storeSession);
+            return storeSession;
         },
         async destroyCaches() {
             const list = Array.from(sessions.values());
@@ -185,6 +219,8 @@ export function createStore(options) {
             const list = Array.from(sessions.values());
             sessions.clear();
             await Promise.all(list.map((s) => s.destroy()));
+            const uniqueBackends = new Set(Object.values(backends));
+            await Promise.all(Array.from(uniqueBackends, (backend) => destroyIfSupported(backend)));
         }
     };
 }

package/dist/esm/store/index.js

@@ -1,11 +1,15 @@
 export { createStore } from './createStore.js';
 export { WaAppStateMemoryStore } from './providers/memory/appstate.store.js';
 export { WaSignalMemoryStore } from './providers/memory/signal.store.js';
+export { WaPreKeyMemoryStore } from './providers/memory/pre-key.store.js';
+export { WaSessionMemoryStore } from './providers/memory/session.store.js';
+export { WaIdentityMemoryStore } from './providers/memory/identity.store.js';
 export { SenderKeyMemoryStore } from './providers/memory/sender-key.store.js';
 export { WaRetryMemoryStore } from './providers/memory/retry.store.js';
 export { WaParticipantsMemoryStore } from './providers/memory/participants.store.js';
 export { WaDeviceListMemoryStore } from './providers/memory/device-list.store.js';
 export { WaContactMemoryStore } from './providers/memory/contact.store.js';
+export { WaMessageSecretMemoryStore } from './providers/memory/message-secret.store.js';
 export { WaMessageMemoryStore } from './providers/memory/message.store.js';
 export { WaThreadMemoryStore } from './providers/memory/thread.store.js';
 export { WaPrivacyTokenMemoryStore } from './providers/memory/privacy-token.store.js';

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

@@ -0,0 +1,16 @@
+import { SharedExclusiveGate } from '../../infra/perf/SharedExclusiveGate.js';
+export function withIdentityLock(store) {
+    const gate = new SharedExclusiveGate();
+    const destroyStore = store;
+    return {
+        getRemoteIdentity: (address) => gate.runShared(() => store.getRemoteIdentity(address)),
+        getRemoteIdentities: (addresses) => gate.runShared(() => store.getRemoteIdentities(addresses)),
+        setRemoteIdentity: (address, identityKey) => gate.runShared(() => store.setRemoteIdentity(address, identityKey)),
+        setRemoteIdentities: (entries) => gate.runShared(() => store.setRemoteIdentities(entries)),
+        clear: () => gate.runExclusive(() => store.clear()),
+        destroy: async () => {
+            await gate.close();
+            await destroyStore.destroy?.();
+        }
+    };
+}

package/dist/esm/store/locks/message-secret.lock.js

@@ -0,0 +1,17 @@
+import { SharedExclusiveGate } from '../../infra/perf/SharedExclusiveGate.js';
+export function withMessageSecretLock(store) {
+    const gate = new SharedExclusiveGate();
+    const destroyStore = store;
+    return {
+        get: (messageId, nowMs) => gate.runShared(() => store.get(messageId, nowMs)),
+        getBatch: (messageIds, nowMs) => gate.runShared(() => store.getBatch(messageIds, nowMs)),
+        set: (messageId, entry) => gate.runShared(() => store.set(messageId, entry)),
+        setBatch: (entries) => gate.runShared(() => store.setBatch(entries)),
+        cleanupExpired: (nowMs) => gate.runExclusive(() => store.cleanupExpired(nowMs)),
+        clear: () => gate.runExclusive(() => store.clear()),
+        destroy: async () => {
+            await gate.close();
+            await destroyStore.destroy?.();
+        }
+    };
+}

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/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

@@ -2,8 +2,6 @@ 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_PREKEYS_KEY = 'signal:prekeys';
-const WA_SIGNAL_SERVER_HAS_PREKEYS_KEY = 'signal:serverHasPreKeys';
 const WA_SIGNAL_CLEAR_KEY = 'signal:clear';
 export function withSignalLock(store) {
     const lock = new StoreLock();
@@ -28,28 +26,6 @@ export function withSignalLock(store) {
         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()),
-        putPreKey: (record) => gate.runShared(() => lock.run(WA_SIGNAL_PREKEYS_KEY, () => store.putPreKey(record))),
-        getOrGenPreKeys: (count, generator) => gate.runShared(() => lock.run(WA_SIGNAL_PREKEYS_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_SIGNAL_PREKEYS_KEY, () => store.consumePreKeyById(keyId))),
-        getOrGenSinglePreKey: (generator) => gate.runShared(() => lock.run(WA_SIGNAL_PREKEYS_KEY, () => store.getOrGenSinglePreKey(generator))),
-        markKeyAsUploaded: (keyId) => gate.runShared(() => lock.run(WA_SIGNAL_PREKEYS_KEY, () => store.markKeyAsUploaded(keyId))),
-        setServerHasPreKeys: (value) => gate.runShared(() => lock.run(WA_SIGNAL_SERVER_HAS_PREKEYS_KEY, () => store.setServerHasPreKeys(value))),
-        getServerHasPreKeys: () => gate.runShared(() => store.getServerHasPreKeys()),
-        getSignalMeta: () => gate.runShared(() => store.getSignalMeta()),
-        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)),
-        // Session and identity read-modify-write semantics are serialized in SignalProtocol per address.
-        setSession: (address, session) => gate.runShared(() => store.setSession(address, session)),
-        setSessionsBatch: (entries) => gate.runShared(() => store.setSessionsBatch(entries)),
-        deleteSession: (address) => gate.runShared(() => store.deleteSession(address)),
-        getRemoteIdentity: (address) => gate.runShared(() => store.getRemoteIdentity(address)),
-        getRemoteIdentities: (addresses) => gate.runShared(() => store.getRemoteIdentities(addresses)),
-        setRemoteIdentity: (address, identityKey) => gate.runShared(() => store.setRemoteIdentity(address, identityKey)),
-        setRemoteIdentities: (entries) => gate.runShared(() => store.setRemoteIdentities(entries)),
         clear: () => gate.runExclusive(() => lock.run(WA_SIGNAL_CLEAR_KEY, async () => {
             await store.clear();
             cachedRegInfo = undefined;

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,

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');

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;
+    }
+}