zapo-js 0.2.0 → 1.0.0

package/dist/esm/store/createStore.js

@@ -1,31 +1,58 @@
+import { withIdentityCache } from './cache/identity.cache.js';
+import { withPrivacyTokenCache } from './cache/privacy-token.cache.js';
+import { withSenderKeyCache } from './cache/sender-key.cache.js';
+import { withSessionCache } from './cache/session.cache.js';
 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 { withGroupMetadataLock } from './locks/group-metadata.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 { 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 { WaMessageMemoryStore } from './providers/memory/message.store.js';
-import { WaParticipantsMemoryStore } from './providers/memory/participants.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 { WaSignalMemoryStore } from './providers/memory/signal.store.js';
-import { WaThreadMemoryStore } from './providers/memory/thread.store.js';
+import { WaAppStateMemoryStore } from './memory/appstate.store.js';
+import { WaAuthMemoryStore } from './memory/auth.store.js';
+import { WaContactMemoryStore } from './memory/contact.store.js';
+import { WaDeviceListMemoryStore } from './memory/device-list.store.js';
+import { WaGroupMetadataMemoryStore } from './memory/group-metadata.store.js';
+import { WaIdentityMemoryStore } from './memory/identity.store.js';
+import { WaMessageSecretMemoryStore } from './memory/message-secret.store.js';
+import { WaMessageMemoryStore } from './memory/message.store.js';
+import { WaPreKeyMemoryStore } from './memory/pre-key.store.js';
+import { WaPrivacyTokenMemoryStore } from './memory/privacy-token.store.js';
+import { WaRetryMemoryStore } from './memory/retry.store.js';
+import { SenderKeyMemoryStore } from './memory/sender-key.store.js';
+import { WaSessionMemoryStore } from './memory/session.store.js';
+import { WaSignalMemoryStore } from './memory/signal.store.js';
+import { WaThreadMemoryStore } from './memory/thread.store.js';
+import { NOOP_CONTACT_STORE, NOOP_DEVICE_LIST_STORE, NOOP_GROUP_METADATA_STORE, NOOP_MESSAGE_SECRET_STORE, NOOP_MESSAGE_STORE, NOOP_RETRY_STORE, NOOP_THREAD_STORE } from './noop.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
+    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' &&
@@ -37,6 +64,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();
@@ -52,13 +82,31 @@ function resolveStore(sessionId, backends, provider, domain, kind, fallback) {
     return factory(sessionId);
 }
 export 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: 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')
+        groupMetadata: resolvePositive(options.memory?.cacheTtlMs?.groupMetadataMs, DEFAULT_CACHE_TTLS_MS.groupMetadataMs, 'memory.cacheTtlMs.groupMetadataMs'),
+        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;
@@ -75,12 +123,11 @@ export 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 rawSignal = resolveStore(id, backends, providers.signal ?? 'memory', 'signal', 'stores', () => new WaSignalMemoryStore({
-                maxPreKeys: ml.signalPreKeys,
-                maxSessions: ml.signalSessions,
+            const rawAuth = resolveStore(id, backends, providers.auth ?? 'memory', 'auth', 'stores', () => new WaAuthMemoryStore());
+            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,28 +148,60 @@ 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 rawParticipants = resolveStore(id, backends, cacheProviders.participants ?? 'memory', 'participants', 'caches', () => cacheProviders.participants === 'memory'
-                ? new WaParticipantsMemoryStore(cacheTtlsMs.participants, {
-                    maxGroups: ml.participantsGroups
+            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,
+                    logger: memoryLogger?.child({ domain: 'retry', sessionId: id })
                 })
-                : NOOP_PARTICIPANTS_STORE);
+                : NOOP_RETRY_STORE);
+            const rawGroupMetadata = resolveStore(id, backends, cacheProviders.groupMetadata ?? 'memory', 'groupMetadata', 'caches', () => cacheProviders.groupMetadata === 'memory' || !cacheProviders.groupMetadata
+                ? new WaGroupMetadataMemoryStore(cacheTtlsMs.groupMetadata, {
+                    maxGroups: ml.groupMetadataGroups,
+                    logger: memoryLogger?.child({
+                        domain: 'groupMetadata',
+                        sessionId: id
+                    })
+                })
+                : NOOP_GROUP_METADATA_STORE);
             const rawDeviceList = resolveStore(id, backends, cacheProviders.deviceList ?? 'memory', 'deviceList', 'caches', () => cacheProviders.deviceList === 'memory'
                 ? new WaDeviceListMemoryStore(cacheTtlsMs.deviceList, {
-                    maxUsers: ml.deviceListUsers
+                    maxUsers: ml.deviceListUsers,
+                    logger: memoryLogger?.child({ domain: 'deviceList', sessionId: id })
                 })
                 : NOOP_DEVICE_LIST_STORE);
+            const rawMessageSecret = resolveStore(id, backends, cacheProviders.messageSecret ?? 'memory', 'messageSecret', 'caches', () => cacheProviders.messageSecret === 'memory' || !cacheProviders.messageSecret
+                ? new WaMessageSecretMemoryStore(cacheTtlsMs.messageSecret, {
+                    maxSecrets: ml.messageSecrets,
+                    logger: memoryLogger?.child({
+                        domain: 'messageSecret',
+                        sessionId: id
+                    })
+                })
+                : NOOP_MESSAGE_SECRET_STORE);
             const authStore = withAuthLock(rawAuth);
             const signalStore = withSignalLock(rawSignal);
-            const senderKeyStore = withSenderKeyLock(rawSenderKey);
+            const preKeyStore = withPreKeyLock(rawPreKey);
+            const sessionStore = withSessionLock(cacheLayer.session && usesBackend(providers.session)
+                ? withSessionCache(rawSession, cacheLayer.limits?.session)
+                : rawSession);
+            const identityStore = withIdentityLock(cacheLayer.identity && usesBackend(providers.identity)
+                ? withIdentityCache(rawIdentity, cacheLayer.limits?.identity)
+                : rawIdentity);
+            const senderKeyStore = withSenderKeyLock(cacheLayer.senderKey && usesBackend(providers.senderKey)
+                ? withSenderKeyCache(rawSenderKey, cacheLayer.limits?.senderKey)
+                : rawSenderKey);
             const appStateStore = withAppStateLock(rawAppState);
             const retryStore = withRetryLock(rawRetry);
-            const participantsStore = withParticipantsLock(rawParticipants);
+            const groupMetadataStore = withGroupMetadataLock(rawGroupMetadata);
             const deviceListStore = withDeviceListLock(rawDeviceList);
             const messageStore = withMessageLock(rawMessages);
+            const messageSecretStore = withMessageSecretLock(rawMessageSecret);
             const threadStore = withThreadLock(rawThreads);
             const contactStore = withContactLock(rawContacts);
-            const privacyTokenStore = withPrivacyTokenLock(rawPrivacyToken);
+            const privacyTokenStore = withPrivacyTokenLock(cacheLayer.privacyToken && usesBackend(providers.privacyToken)
+                ? withPrivacyTokenCache(rawPrivacyToken, cacheLayer.limits?.privacyToken)
+                : rawPrivacyToken);
             let cachesDestroyed = false;
             let sessionDestroyed = false;
             const destroyCaches = async () => {
@@ -131,13 +210,15 @@ export function createStore(options) {
                 cachesDestroyed = true;
                 await Promise.all([
                     retryStore.clear(),
-                    participantsStore.clear(),
-                    deviceListStore.clear()
+                    groupMetadataStore.clear(),
+                    deviceListStore.clear(),
+                    messageSecretStore.clear()
                 ]);
                 await Promise.all([
                     destroyIfSupported(retryStore),
-                    destroyIfSupported(participantsStore),
-                    destroyIfSupported(deviceListStore)
+                    destroyIfSupported(groupMetadataStore),
+                    destroyIfSupported(deviceListStore),
+                    destroyIfSupported(messageSecretStore)
                 ]);
             };
             const destroy = async () => {
@@ -148,6 +229,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 +240,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,
+                groupMetadata: groupMetadataStore,
                 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 +273,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,16 @@
 export { createStore } from './createStore.js';
-export { WaAppStateMemoryStore } from './providers/memory/appstate.store.js';
-export { WaSignalMemoryStore } from './providers/memory/signal.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 { WaMessageMemoryStore } from './providers/memory/message.store.js';
-export { WaThreadMemoryStore } from './providers/memory/thread.store.js';
-export { WaPrivacyTokenMemoryStore } from './providers/memory/privacy-token.store.js';
+export { WaAppStateMemoryStore } from './memory/appstate.store.js';
+export { WaAuthMemoryStore } from './memory/auth.store.js';
+export { WaSignalMemoryStore } from './memory/signal.store.js';
+export { WaPreKeyMemoryStore } from './memory/pre-key.store.js';
+export { WaSessionMemoryStore } from './memory/session.store.js';
+export { WaIdentityMemoryStore } from './memory/identity.store.js';
+export { SenderKeyMemoryStore } from './memory/sender-key.store.js';
+export { WaRetryMemoryStore } from './memory/retry.store.js';
+export { WaGroupMetadataMemoryStore } from './memory/group-metadata.store.js';
+export { WaDeviceListMemoryStore } from './memory/device-list.store.js';
+export { WaContactMemoryStore } from './memory/contact.store.js';
+export { WaMessageSecretMemoryStore } from './memory/message-secret.store.js';
+export { WaMessageMemoryStore } from './memory/message.store.js';
+export { WaThreadMemoryStore } from './memory/thread.store.js';
+export { WaPrivacyTokenMemoryStore } from './memory/privacy-token.store.js';

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

@@ -9,6 +9,7 @@ export 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/esm/store/locks/device-list.lock.js

@@ -13,6 +13,7 @@ export 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/esm/store/locks/group-metadata.lock.js

@@ -0,0 +1,20 @@
+import { SharedExclusiveGate } from '../../infra/perf/SharedExclusiveGate.js';
+import { StoreLock } from '../../infra/perf/StoreLock.js';
+const WA_GROUP_METADATA_CLEAR_KEY = 'group-metadata:clear';
+const WA_GROUP_METADATA_CLEANUP_KEY = 'group-metadata:cleanup';
+export function withGroupMetadataLock(store) {
+    const lock = new StoreLock();
+    const gate = new 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/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/{providers/memory → memory}/appstate.store.js

@@ -1,8 +1,8 @@
-import { APP_STATE_EMPTY_LT_HASH } from '../../../appstate/constants.js';
-import { pickActiveSyncKey } from '../../../appstate/utils.js';
-import { bytesToHex, uint8Equal } from '../../../util/bytes.js';
-import { resolvePositive } from '../../../util/coercion.js';
-import { setBoundedMapEntry } from '../../../util/collections.js';
+import { APP_STATE_EMPTY_LT_HASH } from '../../appstate/constants.js';
+import { pickActiveSyncKey } from '../../appstate/utils.js';
+import { bytesToHex, uint8Equal } from '../../util/bytes.js';
+import { resolvePositive } from '../../util/coercion.js';
+import { setBoundedMapEntry } from '../../util/collections.js';
 const DEFAULT_APPSTATE_MEMORY_STORE_LIMITS = Object.freeze({
     syncKeys: 4096,
     collectionEntries: 50000

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

@@ -0,0 +1,24 @@
+/**
+ * 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.
+ */
+export class WaAuthMemoryStore {
+    constructor() {
+        this.credentials = null;
+    }
+    async load() {
+        return this.credentials;
+    }
+    async save(credentials) {
+        this.credentials = credentials;
+    }
+    async clear() {
+        this.credentials = null;
+    }
+}

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

@@ -0,0 +1,79 @@
+import { isUserJid } from '../../protocol/jid.js';
+import { resolvePositive } from '../../util/coercion.js';
+import { setBoundedMapEntry } from '../../util/collections.js';
+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)
+    };
+}
+export class WaContactMemoryStore {
+    constructor(options = {}) {
+        this.contacts = new Map();
+        /** Secondary index: phone_number -> primary jid (typically the LID form). */
+        this.phoneIndex = new Map();
+        this.maxContacts = 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);
+        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 (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();
+    }
+}