zapo-js 0.3.0 → 1.0.1

package/dist/store/createStore.js

@@ -1,14 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createStore = createStore;
+const identity_cache_1 = require("./cache/identity.cache");
+const privacy_token_cache_1 = require("./cache/privacy-token.cache");
+const sender_key_cache_1 = require("./cache/sender-key.cache");
+const session_cache_1 = require("./cache/session.cache");
 const appstate_lock_1 = require("./locks/appstate.lock");
 const auth_lock_1 = require("./locks/auth.lock");
 const contact_lock_1 = require("./locks/contact.lock");
 const device_list_lock_1 = require("./locks/device-list.lock");
+const group_metadata_lock_1 = require("./locks/group-metadata.lock");
 const identity_lock_1 = require("./locks/identity.lock");
 const message_secret_lock_1 = require("./locks/message-secret.lock");
 const message_lock_1 = require("./locks/message.lock");
-const participants_lock_1 = require("./locks/participants.lock");
 const pre_key_lock_1 = require("./locks/pre-key.lock");
 const privacy_token_lock_1 = require("./locks/privacy-token.lock");
 const retry_lock_1 = require("./locks/retry.lock");
@@ -16,28 +20,42 @@ const sender_key_lock_1 = require("./locks/sender-key.lock");
 const session_lock_1 = require("./locks/session.lock");
 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 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");
+const identity_store_1 = require("./memory/identity.store");
+const message_secret_store_1 = require("./memory/message-secret.store");
+const message_store_1 = require("./memory/message.store");
+const pre_key_store_1 = require("./memory/pre-key.store");
+const privacy_token_store_1 = require("./memory/privacy-token.store");
+const retry_store_1 = require("./memory/retry.store");
+const sender_key_store_1 = require("./memory/sender-key.store");
+const session_store_1 = require("./memory/session.store");
+const signal_store_1 = require("./memory/signal.store");
+const thread_store_1 = require("./memory/thread.store");
 const noop_store_1 = require("./noop.store");
-const appstate_store_1 = require("./providers/memory/appstate.store");
-const contact_store_1 = require("./providers/memory/contact.store");
-const device_list_store_1 = require("./providers/memory/device-list.store");
-const identity_store_1 = require("./providers/memory/identity.store");
-const message_secret_store_1 = require("./providers/memory/message-secret.store");
-const message_store_1 = require("./providers/memory/message.store");
-const participants_store_1 = require("./providers/memory/participants.store");
-const pre_key_store_1 = require("./providers/memory/pre-key.store");
-const privacy_token_store_1 = require("./providers/memory/privacy-token.store");
-const retry_store_1 = require("./providers/memory/retry.store");
-const sender_key_store_1 = require("./providers/memory/sender-key.store");
-const session_store_1 = require("./providers/memory/session.store");
-const signal_store_1 = require("./providers/memory/signal.store");
-const thread_store_1 = require("./providers/memory/thread.store");
 const coercion_1 = require("../util/coercion");
 const DEFAULT_CACHE_TTLS_MS = Object.freeze({
     retryMs: 60 * 1000,
-    participantsMs: 5 * 60 * 1000,
+    groupMetadataMs: 5 * 60 * 1000,
     deviceListMs: 5 * 60 * 1000,
     messageSecretMs: 30 * 60 * 1000
 });
+const REQUIRED_PROVIDER_DOMAINS = [
+    'auth',
+    'signal',
+    'preKey',
+    'session',
+    'identity',
+    'senderKey',
+    'appState',
+    'messages',
+    'threads',
+    'contacts',
+    'privacyToken'
+];
 function hasDestroy(value) {
     return (!!value &&
         typeof value === 'object' &&
@@ -49,6 +67,9 @@ async function destroyIfSupported(value) {
         return;
     await value.destroy();
 }
+function usesBackend(provider) {
+    return !!provider && provider !== 'memory' && provider !== 'none';
+}
 function resolveStore(sessionId, backends, provider, domain, kind, fallback) {
     if (!provider || provider === 'memory' || provider === 'none') {
         return fallback();
@@ -64,12 +85,29 @@ function resolveStore(sessionId, backends, provider, domain, kind, fallback) {
     return factory(sessionId);
 }
 function createStore(options) {
+    options = options ?? {};
     const backends = (options.backends ?? {});
     const providers = options.providers ?? {};
     const cacheProviders = options.cacheProviders ?? {};
+    const cacheLayer = options.cacheLayer ?? {};
+    const storeLogger = options.logger?.child({ scope: 'store' });
+    const memoryLogger = storeLogger?.child({ provider: 'memory' });
+    if (Object.keys(backends).length > 0) {
+        const missingProviders = REQUIRED_PROVIDER_DOMAINS.filter((domain) => providers[domain] === undefined);
+        if (missingProviders.length > 0) {
+            throw new Error(`createStore: when backends is set, every persistence domain must be assigned ` +
+                `explicitly via providers. Missing: ${missingProviders
+                    .map((d) => `providers.${d}`)
+                    .join(', ')}. Pass a backend name (e.g. 'sqlite') to persist, or ` +
+                `'memory' to use the in-tree memory provider. For the mailbox domains ` +
+                `(messages/threads/contacts) 'none' skips the domain entirely; for the ` +
+                `other domains 'none' falls back to memory. Cache providers ` +
+                `(retry/groupMetadata/deviceList/messageSecret) stay opt-in and default to memory.`);
+        }
+    }
     const cacheTtlsMs = Object.freeze({
         retry: (0, coercion_1.resolvePositive)(options.memory?.cacheTtlMs?.retryMs, DEFAULT_CACHE_TTLS_MS.retryMs, 'memory.cacheTtlMs.retryMs'),
-        participants: (0, coercion_1.resolvePositive)(options.memory?.cacheTtlMs?.participantsMs, DEFAULT_CACHE_TTLS_MS.participantsMs, 'memory.cacheTtlMs.participantsMs'),
+        groupMetadata: (0, coercion_1.resolvePositive)(options.memory?.cacheTtlMs?.groupMetadataMs, DEFAULT_CACHE_TTLS_MS.groupMetadataMs, 'memory.cacheTtlMs.groupMetadataMs'),
         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')
     });
@@ -88,9 +126,7 @@ function createStore(options) {
             if (cached)
                 return cached;
             const ml = options.memory?.limits ?? {};
-            const rawAuth = resolveStore(id, backends, providers.auth, 'auth', 'stores', () => {
-                throw new Error('providers.auth is required — register a backend or set providers.auth');
-            });
+            const rawAuth = resolveStore(id, backends, providers.auth ?? 'memory', 'auth', 'stores', () => new auth_store_1.WaAuthMemoryStore());
             const rawSignal = resolveStore(id, backends, providers.signal ?? 'memory', 'signal', 'stores', () => new signal_store_1.WaSignalMemoryStore());
             const rawPreKey = resolveStore(id, backends, providers.preKey ?? 'memory', 'preKey', 'stores', () => new pre_key_store_1.WaPreKeyMemoryStore({ maxPreKeys: ml.signalPreKeys }));
             const rawSession = resolveStore(id, backends, providers.session ?? 'memory', 'session', 'stores', () => new session_store_1.WaSessionMemoryStore({ maxSessions: ml.signalSessions }));
@@ -118,39 +154,57 @@ function createStore(options) {
             const rawRetry = resolveStore(id, backends, cacheProviders.retry ?? 'memory', 'retry', 'caches', () => cacheProviders.retry === 'memory' || !cacheProviders.retry
                 ? new retry_store_1.WaRetryMemoryStore(cacheTtlsMs.retry, {
                     maxOutboundMessages: ml.retryOutboundMessages,
-                    maxInboundCounters: ml.retryInboundCounters
+                    maxInboundCounters: ml.retryInboundCounters,
+                    logger: memoryLogger?.child({ domain: 'retry', sessionId: id })
                 })
                 : noop_store_1.NOOP_RETRY_STORE);
-            const rawParticipants = resolveStore(id, backends, cacheProviders.participants ?? 'memory', 'participants', 'caches', () => cacheProviders.participants === 'memory'
-                ? new participants_store_1.WaParticipantsMemoryStore(cacheTtlsMs.participants, {
-                    maxGroups: ml.participantsGroups
+            const rawGroupMetadata = resolveStore(id, backends, cacheProviders.groupMetadata ?? 'memory', 'groupMetadata', 'caches', () => cacheProviders.groupMetadata === 'memory' || !cacheProviders.groupMetadata
+                ? new group_metadata_store_1.WaGroupMetadataMemoryStore(cacheTtlsMs.groupMetadata, {
+                    maxGroups: ml.groupMetadataGroups,
+                    logger: memoryLogger?.child({
+                        domain: 'groupMetadata',
+                        sessionId: id
+                    })
                 })
-                : noop_store_1.NOOP_PARTICIPANTS_STORE);
+                : noop_store_1.NOOP_GROUP_METADATA_STORE);
             const rawDeviceList = resolveStore(id, backends, cacheProviders.deviceList ?? 'memory', 'deviceList', 'caches', () => cacheProviders.deviceList === 'memory'
                 ? new device_list_store_1.WaDeviceListMemoryStore(cacheTtlsMs.deviceList, {
-                    maxUsers: ml.deviceListUsers
+                    maxUsers: ml.deviceListUsers,
+                    logger: memoryLogger?.child({ domain: 'deviceList', sessionId: id })
                 })
                 : noop_store_1.NOOP_DEVICE_LIST_STORE);
-            const rawMessageSecret = resolveStore(id, backends, cacheProviders.messageSecret ?? 'none', 'messageSecret', 'caches', () => cacheProviders.messageSecret === 'memory'
+            const rawMessageSecret = resolveStore(id, backends, cacheProviders.messageSecret ?? 'memory', 'messageSecret', 'caches', () => cacheProviders.messageSecret === 'memory' || !cacheProviders.messageSecret
                 ? new message_secret_store_1.WaMessageSecretMemoryStore(cacheTtlsMs.messageSecret, {
-                    maxSecrets: ml.messageSecrets
+                    maxSecrets: ml.messageSecrets,
+                    logger: memoryLogger?.child({
+                        domain: 'messageSecret',
+                        sessionId: id
+                    })
                 })
                 : noop_store_1.NOOP_MESSAGE_SECRET_STORE);
             const authStore = (0, auth_lock_1.withAuthLock)(rawAuth);
             const signalStore = (0, signal_lock_1.withSignalLock)(rawSignal);
             const preKeyStore = (0, pre_key_lock_1.withPreKeyLock)(rawPreKey);
-            const sessionStore = (0, session_lock_1.withSessionLock)(rawSession);
-            const identityStore = (0, identity_lock_1.withIdentityLock)(rawIdentity);
-            const senderKeyStore = (0, sender_key_lock_1.withSenderKeyLock)(rawSenderKey);
+            const sessionStore = (0, session_lock_1.withSessionLock)(cacheLayer.session && usesBackend(providers.session)
+                ? (0, session_cache_1.withSessionCache)(rawSession, cacheLayer.limits?.session)
+                : rawSession);
+            const identityStore = (0, identity_lock_1.withIdentityLock)(cacheLayer.identity && usesBackend(providers.identity)
+                ? (0, identity_cache_1.withIdentityCache)(rawIdentity, cacheLayer.limits?.identity)
+                : rawIdentity);
+            const senderKeyStore = (0, sender_key_lock_1.withSenderKeyLock)(cacheLayer.senderKey && usesBackend(providers.senderKey)
+                ? (0, sender_key_cache_1.withSenderKeyCache)(rawSenderKey, cacheLayer.limits?.senderKey)
+                : rawSenderKey);
             const appStateStore = (0, appstate_lock_1.withAppStateLock)(rawAppState);
             const retryStore = (0, retry_lock_1.withRetryLock)(rawRetry);
-            const participantsStore = (0, participants_lock_1.withParticipantsLock)(rawParticipants);
+            const groupMetadataStore = (0, group_metadata_lock_1.withGroupMetadataLock)(rawGroupMetadata);
             const deviceListStore = (0, device_list_lock_1.withDeviceListLock)(rawDeviceList);
             const messageStore = (0, message_lock_1.withMessageLock)(rawMessages);
             const messageSecretStore = (0, message_secret_lock_1.withMessageSecretLock)(rawMessageSecret);
             const threadStore = (0, thread_lock_1.withThreadLock)(rawThreads);
             const contactStore = (0, contact_lock_1.withContactLock)(rawContacts);
-            const privacyTokenStore = (0, privacy_token_lock_1.withPrivacyTokenLock)(rawPrivacyToken);
+            const privacyTokenStore = (0, privacy_token_lock_1.withPrivacyTokenLock)(cacheLayer.privacyToken && usesBackend(providers.privacyToken)
+                ? (0, privacy_token_cache_1.withPrivacyTokenCache)(rawPrivacyToken, cacheLayer.limits?.privacyToken)
+                : rawPrivacyToken);
             let cachesDestroyed = false;
             let sessionDestroyed = false;
             const destroyCaches = async () => {
@@ -159,13 +213,13 @@ function createStore(options) {
                 cachesDestroyed = true;
                 await Promise.all([
                     retryStore.clear(),
-                    participantsStore.clear(),
+                    groupMetadataStore.clear(),
                     deviceListStore.clear(),
                     messageSecretStore.clear()
                 ]);
                 await Promise.all([
                     destroyIfSupported(retryStore),
-                    destroyIfSupported(participantsStore),
+                    destroyIfSupported(groupMetadataStore),
                     destroyIfSupported(deviceListStore),
                     destroyIfSupported(messageSecretStore)
                 ]);
@@ -198,7 +252,7 @@ function createStore(options) {
                 senderKey: senderKeyStore,
                 appState: appStateStore,
                 retry: retryStore,
-                participants: participantsStore,
+                groupMetadata: groupMetadataStore,
                 deviceList: deviceListStore,
                 messages: messageStore,
                 messageSecret: messageSecretStore,

package/dist/store/index.js

@@ -1,33 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WaPrivacyTokenMemoryStore = exports.WaThreadMemoryStore = exports.WaMessageMemoryStore = exports.WaMessageSecretMemoryStore = exports.WaContactMemoryStore = exports.WaDeviceListMemoryStore = exports.WaParticipantsMemoryStore = exports.WaRetryMemoryStore = exports.SenderKeyMemoryStore = exports.WaIdentityMemoryStore = exports.WaSessionMemoryStore = exports.WaPreKeyMemoryStore = exports.WaSignalMemoryStore = exports.WaAppStateMemoryStore = exports.createStore = void 0;
+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;
 var createStore_1 = require("./createStore");
 Object.defineProperty(exports, "createStore", { enumerable: true, get: function () { return createStore_1.createStore; } });
-var appstate_store_1 = require("./providers/memory/appstate.store");
+var appstate_store_1 = require("./memory/appstate.store");
 Object.defineProperty(exports, "WaAppStateMemoryStore", { enumerable: true, get: function () { return appstate_store_1.WaAppStateMemoryStore; } });
-var signal_store_1 = require("./providers/memory/signal.store");
+var auth_store_1 = require("./memory/auth.store");
+Object.defineProperty(exports, "WaAuthMemoryStore", { enumerable: true, get: function () { return auth_store_1.WaAuthMemoryStore; } });
+var signal_store_1 = require("./memory/signal.store");
 Object.defineProperty(exports, "WaSignalMemoryStore", { enumerable: true, get: function () { return signal_store_1.WaSignalMemoryStore; } });
-var pre_key_store_1 = require("./providers/memory/pre-key.store");
+var pre_key_store_1 = require("./memory/pre-key.store");
 Object.defineProperty(exports, "WaPreKeyMemoryStore", { enumerable: true, get: function () { return pre_key_store_1.WaPreKeyMemoryStore; } });
-var session_store_1 = require("./providers/memory/session.store");
+var session_store_1 = require("./memory/session.store");
 Object.defineProperty(exports, "WaSessionMemoryStore", { enumerable: true, get: function () { return session_store_1.WaSessionMemoryStore; } });
-var identity_store_1 = require("./providers/memory/identity.store");
+var identity_store_1 = require("./memory/identity.store");
 Object.defineProperty(exports, "WaIdentityMemoryStore", { enumerable: true, get: function () { return identity_store_1.WaIdentityMemoryStore; } });
-var sender_key_store_1 = require("./providers/memory/sender-key.store");
+var sender_key_store_1 = require("./memory/sender-key.store");
 Object.defineProperty(exports, "SenderKeyMemoryStore", { enumerable: true, get: function () { return sender_key_store_1.SenderKeyMemoryStore; } });
-var retry_store_1 = require("./providers/memory/retry.store");
+var retry_store_1 = require("./memory/retry.store");
 Object.defineProperty(exports, "WaRetryMemoryStore", { enumerable: true, get: function () { return retry_store_1.WaRetryMemoryStore; } });
-var participants_store_1 = require("./providers/memory/participants.store");
-Object.defineProperty(exports, "WaParticipantsMemoryStore", { enumerable: true, get: function () { return participants_store_1.WaParticipantsMemoryStore; } });
-var device_list_store_1 = require("./providers/memory/device-list.store");
+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 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("./providers/memory/contact.store");
+var contact_store_1 = require("./memory/contact.store");
 Object.defineProperty(exports, "WaContactMemoryStore", { enumerable: true, get: function () { return contact_store_1.WaContactMemoryStore; } });
-var message_secret_store_1 = require("./providers/memory/message-secret.store");
+var message_secret_store_1 = require("./memory/message-secret.store");
 Object.defineProperty(exports, "WaMessageSecretMemoryStore", { enumerable: true, get: function () { return message_secret_store_1.WaMessageSecretMemoryStore; } });
-var message_store_1 = require("./providers/memory/message.store");
+var message_store_1 = require("./memory/message.store");
 Object.defineProperty(exports, "WaMessageMemoryStore", { enumerable: true, get: function () { return message_store_1.WaMessageMemoryStore; } });
-var thread_store_1 = require("./providers/memory/thread.store");
+var thread_store_1 = require("./memory/thread.store");
 Object.defineProperty(exports, "WaThreadMemoryStore", { enumerable: true, get: function () { return thread_store_1.WaThreadMemoryStore; } });
-var privacy_token_store_1 = require("./providers/memory/privacy-token.store");
+var privacy_token_store_1 = require("./memory/privacy-token.store");
 Object.defineProperty(exports, "WaPrivacyTokenMemoryStore", { enumerable: true, get: function () { return privacy_token_store_1.WaPrivacyTokenMemoryStore; } });

package/dist/store/locks/contact.lock.js

@@ -12,6 +12,7 @@ function withContactLock(store) {
         upsert: (record) => gate.runShared(() => lock.run(`contact:${record.jid}`, () => store.upsert(record))),
         upsertBatch: (records) => gate.runShared(() => lock.runMany(records.map((record) => `contact:${record.jid}`), () => store.upsertBatch(records))),
         getByJid: (jid) => gate.runShared(() => store.getByJid(jid)),
+        getByPhoneNumber: (pn) => gate.runShared(() => store.getByPhoneNumber(pn)),
         deleteByJid: (jid) => gate.runShared(() => lock.run(`contact:${jid}`, () => store.deleteByJid(jid))),
         clear: () => gate.runExclusive(() => lock.run(WA_CONTACT_CLEAR_KEY, () => store.clear())),
         destroy: async () => {

package/dist/store/locks/device-list.lock.js

@@ -16,6 +16,7 @@ function withDeviceListLock(store) {
         },
         upsertUserDevicesBatch: (snapshots) => gate.runShared(() => lock.runMany(snapshots.map((snapshot) => `deviceList:user:${snapshot.userJid}`), () => store.upsertUserDevicesBatch(snapshots))),
         getUserDevicesBatch: (userJids, nowMs) => gate.runShared(() => store.getUserDevicesBatch(userJids, nowMs)),
+        findByAnyUserJid: (jid, nowMs) => gate.runShared(() => store.findByAnyUserJid(jid, nowMs)),
         deleteUserDevices: (userJid) => gate.runShared(() => lock.run(`deviceList:user:${userJid}`, () => store.deleteUserDevices(userJid))),
         cleanupExpired: (nowMs) => gate.runExclusive(() => lock.run(WA_DEVICE_LIST_CLEANUP_KEY, () => store.cleanupExpired(nowMs))),
         clear: () => gate.runExclusive(() => lock.run(WA_DEVICE_LIST_CLEAR_KEY, () => store.clear()))

package/dist/store/locks/group-metadata.lock.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withGroupMetadataLock = withGroupMetadataLock;
+const SharedExclusiveGate_1 = require("../../infra/perf/SharedExclusiveGate");
+const StoreLock_1 = require("../../infra/perf/StoreLock");
+const WA_GROUP_METADATA_CLEAR_KEY = 'group-metadata:clear';
+const WA_GROUP_METADATA_CLEANUP_KEY = 'group-metadata:cleanup';
+function withGroupMetadataLock(store) {
+    const lock = new StoreLock_1.StoreLock();
+    const gate = new SharedExclusiveGate_1.SharedExclusiveGate();
+    return {
+        destroy: async () => {
+            await gate.close();
+            await lock.shutdown();
+            await store.destroy?.();
+        },
+        upsertGroupMetadata: (snapshot) => gate.runShared(() => lock.run(`group-metadata:group:${snapshot.groupJid}`, () => store.upsertGroupMetadata(snapshot))),
+        getGroupMetadata: (groupJid, nowMs) => gate.runShared(() => store.getGroupMetadata(groupJid, nowMs)),
+        deleteGroupMetadata: (groupJid) => gate.runShared(() => lock.run(`group-metadata:group:${groupJid}`, () => store.deleteGroupMetadata(groupJid))),
+        cleanupExpired: (nowMs) => gate.runExclusive(() => lock.run(WA_GROUP_METADATA_CLEANUP_KEY, () => store.cleanupExpired(nowMs))),
+        clear: () => gate.runExclusive(() => lock.run(WA_GROUP_METADATA_CLEAR_KEY, () => store.clear()))
+    };
+}

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

@@ -6,6 +6,9 @@ const StoreLock_1 = require("../../infra/perf/StoreLock");
 const WA_PREKEY_KEY = 'prekey:prekeys';
 const WA_PREKEY_SERVER_KEY = 'prekey:serverHasPreKeys';
 const WA_PREKEY_CLEAR_KEY = 'prekey:clear';
+// consume is independent of the counter/generation and atomic in the store, so it
+// uses a per-id key instead of WA_PREKEY_KEY: no queueing behind generation/upload.
+const WA_PREKEY_CONSUME_PREFIX = 'prekey:consume:';
 function withPreKeyLock(store) {
     const lock = new StoreLock_1.StoreLock();
     const gate = new SharedExclusiveGate_1.SharedExclusiveGate();
@@ -15,7 +18,7 @@ function withPreKeyLock(store) {
         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))),
+        consumePreKeyById: (keyId) => gate.runShared(() => lock.run(`${WA_PREKEY_CONSUME_PREFIX}${keyId}`, () => 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))),

package/dist/store/{providers/memory → memory}/appstate.store.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WaAppStateMemoryStore = void 0;
-const constants_1 = require("../../../appstate/constants");
-const utils_1 = require("../../../appstate/utils");
-const bytes_1 = require("../../../util/bytes");
-const coercion_1 = require("../../../util/coercion");
-const collections_1 = require("../../../util/collections");
+const constants_1 = require("../../appstate/constants");
+const utils_1 = require("../../appstate/utils");
+const bytes_1 = require("../../util/bytes");
+const coercion_1 = require("../../util/coercion");
+const collections_1 = require("../../util/collections");
 const DEFAULT_APPSTATE_MEMORY_STORE_LIMITS = Object.freeze({
     syncKeys: 4096,
     collectionEntries: 50000

package/dist/store/memory/auth.store.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaAuthMemoryStore = void 0;
+/**
+ * In-memory {@link WaAuthStore} implementation. Holds a single
+ * {@link WaAuthCredentials} per instance in a field – nothing is persisted.
+ *
+ * @sensitive Holds private key material from {@link WaAuthCredentials} in
+ * RAM. Never log instances, never `JSON.stringify`. Pairing credentials are
+ * lost when the process exits, so the next connect will re-pair from scratch
+ * (QR/link-code). Prefer a persistent backend (e.g. `@zapo-js/store-sqlite`)
+ * for production.
+ */
+class WaAuthMemoryStore {
+    constructor() {
+        this.credentials = null;
+    }
+    async load() {
+        return this.credentials;
+    }
+    async save(credentials) {
+        this.credentials = credentials;
+    }
+    async clear() {
+        this.credentials = null;
+    }
+}
+exports.WaAuthMemoryStore = WaAuthMemoryStore;

package/dist/store/memory/contact.store.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaContactMemoryStore = void 0;
+const jid_1 = require("../../protocol/jid");
+const coercion_1 = require("../../util/coercion");
+const collections_1 = require("../../util/collections");
+const DEFAULT_CONTACT_MEMORY_STORE_LIMITS = Object.freeze({
+    contacts: 20000
+});
+function mergeContactRecords(previous, incoming) {
+    if (!previous)
+        return incoming;
+    return {
+        jid: incoming.jid,
+        displayName: incoming.displayName ?? previous.displayName,
+        pushName: incoming.pushName ?? previous.pushName,
+        lid: incoming.lid ?? previous.lid,
+        phoneNumber: incoming.phoneNumber ?? previous.phoneNumber,
+        lastUpdatedMs: Math.max(previous.lastUpdatedMs, incoming.lastUpdatedMs)
+    };
+}
+class WaContactMemoryStore {
+    constructor(options = {}) {
+        this.contacts = new Map();
+        /** Secondary index: phone_number -> primary jid (typically the LID form). */
+        this.phoneIndex = new Map();
+        this.maxContacts = (0, coercion_1.resolvePositive)(options.maxContacts, DEFAULT_CONTACT_MEMORY_STORE_LIMITS.contacts, 'WaContactMemoryStoreOptions.maxContacts');
+    }
+    writeRecord(record) {
+        const previous = this.contacts.get(record.jid);
+        const merged = mergeContactRecords(previous, record);
+        (0, collections_1.setBoundedMapEntry)(this.contacts, merged.jid, merged, this.maxContacts);
+        if (previous?.phoneNumber &&
+            previous.phoneNumber !== merged.phoneNumber &&
+            this.phoneIndex.get(previous.phoneNumber) === merged.jid) {
+            this.phoneIndex.delete(previous.phoneNumber);
+        }
+        if (merged.phoneNumber) {
+            this.phoneIndex.set(merged.phoneNumber, merged.jid);
+        }
+    }
+    async upsert(record) {
+        this.writeRecord(record);
+    }
+    async upsertBatch(records) {
+        for (const record of records) {
+            this.writeRecord(record);
+        }
+    }
+    async getByJid(jid) {
+        const direct = this.contacts.get(jid);
+        if (direct)
+            return direct;
+        if ((0, jid_1.isUserJid)(jid)) {
+            return this.getByPhoneNumberSync(jid);
+        }
+        return null;
+    }
+    async getByPhoneNumber(pn) {
+        return this.getByPhoneNumberSync(pn);
+    }
+    getByPhoneNumberSync(pn) {
+        const jid = this.phoneIndex.get(pn);
+        if (!jid)
+            return null;
+        return this.contacts.get(jid) ?? null;
+    }
+    async deleteByJid(jid) {
+        const existing = this.contacts.get(jid);
+        if (!existing)
+            return 0;
+        this.contacts.delete(jid);
+        if (existing.phoneNumber && this.phoneIndex.get(existing.phoneNumber) === jid) {
+            this.phoneIndex.delete(existing.phoneNumber);
+        }
+        return 1;
+    }
+    async clear() {
+        this.contacts.clear();
+        this.phoneIndex.clear();
+    }
+}
+exports.WaContactMemoryStore = WaContactMemoryStore;

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

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaDeviceListMemoryStore = void 0;
+const coercion_1 = require("../../util/coercion");
+const collections_1 = require("../../util/collections");
+const DEFAULTS = Object.freeze({
+    ttlMs: 5 * 60 * 1000,
+    maxUsers: 16384
+});
+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.altIndex = new Map();
+        this.ttlMs = ttlMs;
+        this.maxUsers = (0, coercion_1.resolvePositive)(options.maxUsers, DEFAULTS.maxUsers, 'WaDeviceListMemoryStoreOptions.maxUsers');
+        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('device list store at capacity, evicting oldest', {
+            max: this.maxUsers
+        });
+    }
+    async upsertUserDevicesBatch(snapshots) {
+        for (let index = 0; index < snapshots.length; index += 1) {
+            const snapshot = snapshots[index];
+            const previous = this.records.get(snapshot.userJid);
+            if (previous?.altUserJid && previous.altUserJid !== snapshot.altUserJid) {
+                this.altIndex.delete(previous.altUserJid);
+            }
+            (0, collections_1.setBoundedMapEntry)(this.records, snapshot.userJid, {
+                ...snapshot,
+                expiresAtMs: snapshot.updatedAtMs + this.ttlMs
+            }, this.maxUsers, () => this.warnCapacity());
+            if (snapshot.altUserJid) {
+                this.altIndex.set(snapshot.altUserJid, snapshot.userJid);
+            }
+        }
+    }
+    async getUserDevicesBatch(userJids, nowMs = Date.now()) {
+        const snapshots = new Array(userJids.length);
+        for (let index = 0; index < userJids.length; index += 1) {
+            snapshots[index] = this.readLive(userJids[index], nowMs);
+        }
+        return snapshots;
+    }
+    async findByAnyUserJid(jid, nowMs = Date.now()) {
+        const direct = this.readLive(jid, nowMs);
+        if (direct)
+            return direct;
+        const primary = this.altIndex.get(jid);
+        if (!primary)
+            return null;
+        return this.readLive(primary, nowMs);
+    }
+    async deleteUserDevices(userJid) {
+        const record = this.records.get(userJid);
+        if (!record)
+            return 0;
+        if (record.altUserJid)
+            this.altIndex.delete(record.altUserJid);
+        this.records.delete(userJid);
+        return 1;
+    }
+    async cleanupExpired(nowMs) {
+        let removed = 0;
+        for (const [userJid, record] of this.records) {
+            if (record.expiresAtMs > nowMs)
+                continue;
+            if (record.altUserJid)
+                this.altIndex.delete(record.altUserJid);
+            this.records.delete(userJid);
+            removed += 1;
+        }
+        return removed;
+    }
+    async clear() {
+        this.records.clear();
+        this.altIndex.clear();
+    }
+    async destroy() {
+        this.cleanup.destroy();
+        await this.clear();
+    }
+    readLive(userJid, nowMs) {
+        const record = this.records.get(userJid);
+        if (!record)
+            return null;
+        if (record.expiresAtMs <= nowMs) {
+            if (record.altUserJid)
+                this.altIndex.delete(record.altUserJid);
+            this.records.delete(userJid);
+            return null;
+        }
+        return record;
+    }
+}
+exports.WaDeviceListMemoryStore = WaDeviceListMemoryStore;