zapo-js 0.1.2 → 0.3.0

package/dist/esm/store/createStore.js

@@ -1,59 +1,40 @@
-import { NOOP_CONTACT_STORE, NOOP_DEVICE_LIST_STORE, NOOP_MESSAGE_STORE, NOOP_PARTICIPANTS_STORE, NOOP_THREAD_STORE } from './noop.store.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 { 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_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 { WaAppStateSqliteStore } from './providers/sqlite/appstate.store.js';
-import { WaAuthSqliteStore } from './providers/sqlite/auth.store.js';
-import { WaContactSqliteStore } from './providers/sqlite/contact.store.js';
-import { WaDeviceListSqliteStore } from './providers/sqlite/device-list.store.js';
-import { WaMessageSqliteStore } from './providers/sqlite/message.store.js';
-import { WaParticipantsSqliteStore } from './providers/sqlite/participants.store.js';
-import { WaRetrySqliteStore } from './providers/sqlite/retry.store.js';
-import { SenderKeySqliteStore } from './providers/sqlite/sender-key.store.js';
-import { WaSignalSqliteStore } from './providers/sqlite/signal.store.js';
-import { WaThreadSqliteStore } from './providers/sqlite/thread.store.js';
 import { resolvePositive } from '../util/coercion.js';
-const DEFAULT_PROVIDERS = {
-    auth: 'sqlite',
-    signal: 'sqlite',
-    senderKey: 'sqlite',
-    appState: 'sqlite',
-    messages: 'none',
-    threads: 'none',
-    contacts: 'none'
-};
-const DEFAULT_CACHE_PROVIDERS = {
-    retry: 'memory',
-    participants: 'memory',
-    deviceList: 'memory'
-};
-const DEFAULT_CACHE_TTLS_MS = {
-    retryMs: 7 * 24 * 60 * 60 * 1000,
+const DEFAULT_CACHE_TTLS_MS = Object.freeze({
+    retryMs: 60 * 1000,
     participantsMs: 5 * 60 * 1000,
-    deviceListMs: 5 * 60 * 1000
-};
-const DEFAULT_SQLITE_BATCH_SIZES = {
-    deviceList: 500,
-    senderKeyDistribution: 250,
-    signalPreKey: 500,
-    signalHasSession: 250
-};
-function resolveStoreValue(sessionId, value, domainPath) {
-    if (!value) {
-        return null;
-    }
-    const resolved = typeof value === 'function' ? value(sessionId) : value;
-    if (!resolved) {
-        throw new Error(`${domainPath} must resolve to a store instance`);
-    }
-    return resolved;
-}
+    deviceListMs: 5 * 60 * 1000,
+    messageSecretMs: 30 * 60 * 1000
+});
 function hasDestroy(value) {
     return (!!value &&
         typeof value === 'object' &&
@@ -61,30 +42,33 @@ function hasDestroy(value) {
         typeof value.destroy === 'function');
 }
 async function destroyIfSupported(value) {
-    if (!hasDestroy(value)) {
+    if (!hasDestroy(value))
         return;
-    }
     await value.destroy();
 }
+function resolveStore(sessionId, backends, provider, domain, kind, fallback) {
+    if (!provider || provider === 'memory' || provider === 'none') {
+        return fallback();
+    }
+    const backend = backends[provider];
+    if (!backend) {
+        throw new Error(`unknown backend '${provider}' for ${domain}`);
+    }
+    const factory = backend[kind][domain];
+    if (!factory) {
+        throw new Error(`backend '${provider}' does not provide ${kind}.${domain}`);
+    }
+    return factory(sessionId);
+}
 export function createStore(options) {
-    const providers = {
-        ...DEFAULT_PROVIDERS,
-        ...(options.providers ?? {})
-    };
-    const cacheProviders = {
-        ...DEFAULT_CACHE_PROVIDERS,
-        ...(options.cacheProviders ?? {})
-    };
+    const backends = (options.backends ?? {});
+    const providers = options.providers ?? {};
+    const cacheProviders = options.cacheProviders ?? {};
     const cacheTtlsMs = Object.freeze({
-        retry: resolvePositive(options.cacheTtlMs?.retryMs, DEFAULT_CACHE_TTLS_MS.retryMs, 'cacheTtlMs.retryMs'),
-        participants: resolvePositive(options.cacheTtlMs?.participantsMs, DEFAULT_CACHE_TTLS_MS.participantsMs, 'cacheTtlMs.participantsMs'),
-        deviceList: resolvePositive(options.cacheTtlMs?.deviceListMs, DEFAULT_CACHE_TTLS_MS.deviceListMs, 'cacheTtlMs.deviceListMs')
-    });
-    const sqliteBatchSizes = Object.freeze({
-        deviceList: resolvePositive(options.sqlite?.batchSizes?.deviceList, DEFAULT_SQLITE_BATCH_SIZES.deviceList, 'sqlite.batchSizes.deviceList'),
-        senderKeyDistribution: resolvePositive(options.sqlite?.batchSizes?.senderKeyDistribution, DEFAULT_SQLITE_BATCH_SIZES.senderKeyDistribution, 'sqlite.batchSizes.senderKeyDistribution'),
-        signalPreKey: resolvePositive(options.sqlite?.batchSizes?.signalPreKey, DEFAULT_SQLITE_BATCH_SIZES.signalPreKey, 'sqlite.batchSizes.signalPreKey'),
-        signalHasSession: resolvePositive(options.sqlite?.batchSizes?.signalHasSession, DEFAULT_SQLITE_BATCH_SIZES.signalHasSession, 'sqlite.batchSizes.signalHasSession')
+        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'),
+        messageSecret: resolvePositive(options.memory?.cacheTtlMs?.messageSecretMs, DEFAULT_CACHE_TTLS_MS.messageSecretMs, 'memory.cacheTtlMs.messageSecretMs')
     });
     const sessions = new Map();
     let storeDestroyed = false;
@@ -93,184 +77,150 @@ export function createStore(options) {
             if (storeDestroyed) {
                 throw new Error('store has been destroyed');
             }
-            const normalizedSessionId = sessionId.trim();
-            if (normalizedSessionId.length === 0) {
+            const id = sessionId.trim();
+            if (id.length === 0) {
                 throw new Error('sessionId must be a non-empty string');
             }
-            const cached = sessions.get(normalizedSessionId);
-            if (cached) {
+            const cached = sessions.get(id);
+            if (cached)
                 return cached;
-            }
-            const resolveCustom = (value, domainPath) => resolveStoreValue(normalizedSessionId, value, domainPath);
-            const customAuth = resolveCustom(options.custom?.auth, 'custom.auth');
-            const customSignal = resolveCustom(options.custom?.signal, 'custom.signal');
-            const customSenderKey = resolveCustom(options.custom?.senderKey, 'custom.senderKey');
-            const customAppState = resolveCustom(options.custom?.appState, 'custom.appState');
-            const customRetry = resolveCustom(options.customCache?.retry, 'customCache.retry');
-            const customParticipants = resolveCustom(options.customCache?.participants, 'customCache.participants');
-            const customDeviceList = resolveCustom(options.customCache?.deviceList, 'customCache.deviceList');
-            const customMessages = resolveCustom(options.custom?.messages, 'custom.messages');
-            const customThreads = resolveCustom(options.custom?.threads, 'custom.threads');
-            const customContacts = resolveCustom(options.custom?.contacts, 'custom.contacts');
-            const memoryLimits = options.memory?.limits ?? {};
-            const requiresSqlite = !customAuth ||
-                (!customSignal && providers.signal === 'sqlite') ||
-                (!customSenderKey && providers.senderKey === 'sqlite') ||
-                (!customAppState && providers.appState === 'sqlite') ||
-                (!customRetry && cacheProviders.retry === 'sqlite') ||
-                (!customParticipants && cacheProviders.participants === 'sqlite') ||
-                (!customDeviceList && cacheProviders.deviceList === 'sqlite') ||
-                (!customMessages && providers.messages === 'sqlite') ||
-                (!customThreads && providers.threads === 'sqlite') ||
-                (!customContacts && providers.contacts === 'sqlite');
-            const sqlite = options.sqlite;
-            if (requiresSqlite && (!sqlite?.path || sqlite.path.trim().length === 0)) {
-                throw new Error('sqlite.path must be configured for unresolved sqlite domains.');
-            }
-            const sqliteOptions = sqlite && sqlite.path.trim().length > 0
-                ? {
-                    path: sqlite.path,
-                    sessionId: normalizedSessionId,
-                    driver: sqlite.driver ?? 'auto',
-                    pragmas: sqlite.pragmas,
-                    tableNames: sqlite.tableNames
-                }
-                : null;
-            const authStore = customAuth ?? new WaAuthSqliteStore(sqliteOptions);
-            const signalStore = customSignal ??
-                (providers.signal === 'memory'
-                    ? new WaSignalMemoryStore({
-                        maxPreKeys: memoryLimits.signalPreKeys,
-                        maxSessions: memoryLimits.signalSessions,
-                        maxRemoteIdentities: memoryLimits.signalRemoteIdentities
-                    })
-                    : new WaSignalSqliteStore(sqliteOptions, {
-                        preKeyBatchSize: sqliteBatchSizes.signalPreKey,
-                        hasSessionBatchSize: sqliteBatchSizes.signalHasSession
-                    }));
-            const senderKeyStore = customSenderKey ??
-                (providers.senderKey === 'memory'
-                    ? new SenderKeyMemoryStore({
-                        maxSenderKeys: memoryLimits.senderKeys,
-                        maxSenderDistributions: memoryLimits.senderDistributions
-                    })
-                    : new SenderKeySqliteStore(sqliteOptions, sqliteBatchSizes.senderKeyDistribution));
-            const appStateStore = customAppState ??
-                (providers.appState === 'memory'
-                    ? new WaAppStateMemoryStore(undefined, {
-                        maxSyncKeys: memoryLimits.appStateSyncKeys,
-                        maxCollectionEntries: memoryLimits.appStateCollectionEntries
-                    })
-                    : new WaAppStateSqliteStore(sqliteOptions));
-            const retryStore = customRetry ??
-                (cacheProviders.retry === 'memory'
-                    ? new WaRetryMemoryStore(cacheTtlsMs.retry)
-                    : new WaRetrySqliteStore(sqliteOptions, cacheTtlsMs.retry));
-            const participantsStore = customParticipants ??
-                (cacheProviders.participants === 'sqlite'
-                    ? new WaParticipantsSqliteStore(sqliteOptions, cacheTtlsMs.participants)
-                    : cacheProviders.participants === 'memory'
-                        ? new WaParticipantsMemoryStore(cacheTtlsMs.participants, {
-                            maxGroups: memoryLimits.participantsGroups
-                        })
-                        : NOOP_PARTICIPANTS_STORE);
-            const deviceListStore = customDeviceList ??
-                (cacheProviders.deviceList === 'sqlite'
-                    ? new WaDeviceListSqliteStore(sqliteOptions, cacheTtlsMs.deviceList, sqliteBatchSizes.deviceList)
-                    : cacheProviders.deviceList === 'memory'
-                        ? new WaDeviceListMemoryStore(cacheTtlsMs.deviceList, {
-                            maxUsers: memoryLimits.deviceListUsers
-                        })
-                        : NOOP_DEVICE_LIST_STORE);
-            const messageStore = customMessages ??
-                (providers.messages === 'sqlite'
-                    ? new WaMessageSqliteStore(sqliteOptions)
-                    : providers.messages === 'memory'
-                        ? new WaMessageMemoryStore({
-                            maxMessages: memoryLimits.messages
-                        })
-                        : NOOP_MESSAGE_STORE);
-            const threadStore = customThreads ??
-                (providers.threads === 'sqlite'
-                    ? new WaThreadSqliteStore(sqliteOptions)
-                    : providers.threads === 'memory'
-                        ? new WaThreadMemoryStore({
-                            maxThreads: memoryLimits.threads
-                        })
-                        : NOOP_THREAD_STORE);
-            const contactStore = customContacts ??
-                (providers.contacts === 'sqlite'
-                    ? new WaContactSqliteStore(sqliteOptions)
-                    : providers.contacts === 'memory'
-                        ? new WaContactMemoryStore({
-                            maxContacts: memoryLimits.contacts
-                        })
-                        : NOOP_CONTACT_STORE);
+            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());
+            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({
+                maxSenderKeys: ml.senderKeys,
+                maxSenderDistributions: ml.senderDistributions
+            }));
+            const rawAppState = resolveStore(id, backends, providers.appState ?? 'memory', 'appState', 'stores', () => new WaAppStateMemoryStore(undefined, {
+                maxSyncKeys: ml.appStateSyncKeys,
+                maxCollectionEntries: ml.appStateCollectionEntries
+            }));
+            const rawMessages = resolveStore(id, backends, providers.messages ?? 'none', 'messages', 'stores', () => providers.messages === 'memory'
+                ? new WaMessageMemoryStore({ maxMessages: ml.messages })
+                : NOOP_MESSAGE_STORE);
+            const rawThreads = resolveStore(id, backends, providers.threads ?? 'none', 'threads', 'stores', () => providers.threads === 'memory'
+                ? new WaThreadMemoryStore({ maxThreads: ml.threads })
+                : NOOP_THREAD_STORE);
+            const rawContacts = resolveStore(id, backends, providers.contacts ?? 'none', 'contacts', 'stores', () => providers.contacts === 'memory'
+                ? 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', () => 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
+                })
+                : NOOP_PARTICIPANTS_STORE);
+            const rawDeviceList = resolveStore(id, backends, cacheProviders.deviceList ?? 'memory', 'deviceList', 'caches', () => cacheProviders.deviceList === 'memory'
+                ? new WaDeviceListMemoryStore(cacheTtlsMs.deviceList, {
+                    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);
             let cachesDestroyed = false;
             let sessionDestroyed = false;
             const destroyCaches = async () => {
-                if (cachesDestroyed) {
+                if (cachesDestroyed)
                     return;
-                }
                 cachesDestroyed = true;
                 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 () => {
-                if (sessionDestroyed) {
+                if (sessionDestroyed)
                     return;
-                }
                 sessionDestroyed = true;
                 await destroyCaches();
                 await Promise.all([
                     destroyIfSupported(authStore),
                     destroyIfSupported(signalStore),
+                    destroyIfSupported(preKeyStore),
+                    destroyIfSupported(sessionStore),
+                    destroyIfSupported(identityStore),
                     destroyIfSupported(senderKeyStore),
                     destroyIfSupported(appStateStore),
                     destroyIfSupported(messageStore),
                     destroyIfSupported(threadStore),
-                    destroyIfSupported(contactStore)
+                    destroyIfSupported(contactStore),
+                    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(normalizedSessionId, session);
-            return session;
+            sessions.set(id, storeSession);
+            return storeSession;
         },
         async destroyCaches() {
-            for (const session of sessions.values()) {
-                await session.destroyCaches();
-            }
+            const list = Array.from(sessions.values());
+            await Promise.all(list.map((s) => s.destroyCaches()));
         },
         async destroy() {
-            if (storeDestroyed) {
+            if (storeDestroyed)
                 return;
-            }
             storeDestroyed = true;
-            for (const [sessionId, session] of sessions) {
-                sessions.delete(sessionId);
-                await session.destroy();
-            }
+            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,20 +1,15 @@
-export { WaAuthSqliteStore } from './providers/sqlite/auth.store.js';
-export { WaAppStateSqliteStore } from './providers/sqlite/appstate.store.js';
 export { createStore } from './createStore.js';
-export { WaSignalSqliteStore } from './providers/sqlite/signal.store.js';
-export { SenderKeySqliteStore } from './providers/sqlite/sender-key.store.js';
-export { WaRetrySqliteStore } from './providers/sqlite/retry.store.js';
-export { WaParticipantsSqliteStore } from './providers/sqlite/participants.store.js';
-export { WaDeviceListSqliteStore } from './providers/sqlite/device-list.store.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 { WaContactSqliteStore } from './providers/sqlite/contact.store.js';
-export { WaMessageSqliteStore } from './providers/sqlite/message.store.js';
-export { WaThreadSqliteStore } from './providers/sqlite/thread.store.js';
+export { WaPrivacyTokenMemoryStore } from './providers/memory/privacy-token.store.js';

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

@@ -0,0 +1,26 @@
+import { SharedExclusiveGate } from '../../infra/perf/SharedExclusiveGate.js';
+import { StoreLock } from '../../infra/perf/StoreLock.js';
+import { bytesToHex } from '../../util/bytes.js';
+const WA_APPSTATE_CLEAR_KEY = 'appstate:clear';
+export function withAppStateLock(store) {
+    const lock = new StoreLock();
+    const gate = new SharedExclusiveGate();
+    const destroyStore = store;
+    return {
+        exportData: () => gate.runShared(() => store.exportData()),
+        upsertSyncKeys: (keys) => gate.runShared(() => lock.runMany(keys.map((key) => `appstate:syncKey:${bytesToHex(key.keyId)}`), () => store.upsertSyncKeys(keys))),
+        getSyncKeysBatch: (keyIds) => gate.runShared(() => store.getSyncKeysBatch(keyIds)),
+        getSyncKeyData: (keyId) => gate.runShared(() => store.getSyncKeyData(keyId)),
+        getSyncKeyDataBatch: (keyIds) => gate.runShared(() => store.getSyncKeyDataBatch(keyIds)),
+        getActiveSyncKey: () => gate.runShared(() => store.getActiveSyncKey()),
+        getCollectionState: (collection) => gate.runShared(() => store.getCollectionState(collection)),
+        getCollectionStates: (collections) => gate.runShared(() => store.getCollectionStates(collections)),
+        setCollectionStates: (updates) => gate.runShared(() => lock.runMany(updates.map((update) => `appstate:collection:${update.collection}`), () => store.setCollectionStates(updates))),
+        clear: () => gate.runExclusive(() => lock.run(WA_APPSTATE_CLEAR_KEY, () => store.clear())),
+        destroy: async () => {
+            await gate.close();
+            await lock.shutdown();
+            await destroyStore.destroy?.();
+        }
+    };
+}

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

@@ -0,0 +1,15 @@
+import { StoreLock } from '../../infra/perf/StoreLock.js';
+const WA_AUTH_KEY = 'credentials';
+export function withAuthLock(store) {
+    const lock = new StoreLock();
+    const destroyStore = store;
+    return {
+        load: () => lock.run(WA_AUTH_KEY, () => store.load()),
+        save: (credentials) => lock.run(WA_AUTH_KEY, () => store.save(credentials)),
+        clear: () => lock.run(WA_AUTH_KEY, () => store.clear()),
+        destroy: async () => {
+            await lock.shutdown();
+            await destroyStore.destroy?.();
+        }
+    };
+}

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

@@ -0,0 +1,20 @@
+import { SharedExclusiveGate } from '../../infra/perf/SharedExclusiveGate.js';
+import { StoreLock } from '../../infra/perf/StoreLock.js';
+const WA_CONTACT_CLEAR_KEY = 'contact:clear';
+export function withContactLock(store) {
+    const lock = new StoreLock();
+    const gate = new SharedExclusiveGate();
+    const destroyStore = store;
+    return {
+        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)),
+        deleteByJid: (jid) => gate.runShared(() => lock.run(`contact:${jid}`, () => store.deleteByJid(jid))),
+        clear: () => gate.runExclusive(() => lock.run(WA_CONTACT_CLEAR_KEY, () => store.clear())),
+        destroy: async () => {
+            await gate.close();
+            await lock.shutdown();
+            await destroyStore.destroy?.();
+        }
+    };
+}

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

@@ -0,0 +1,20 @@
+import { SharedExclusiveGate } from '../../infra/perf/SharedExclusiveGate.js';
+import { StoreLock } from '../../infra/perf/StoreLock.js';
+const WA_DEVICE_LIST_CLEAR_KEY = 'deviceList:clear';
+const WA_DEVICE_LIST_CLEANUP_KEY = 'deviceList:cleanup';
+export function withDeviceListLock(store) {
+    const lock = new StoreLock();
+    const gate = new SharedExclusiveGate();
+    return {
+        destroy: async () => {
+            await gate.close();
+            await lock.shutdown();
+            await store.destroy?.();
+        },
+        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)),
+        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/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/message.lock.js

@@ -0,0 +1,21 @@
+import { SharedExclusiveGate } from '../../infra/perf/SharedExclusiveGate.js';
+import { StoreLock } from '../../infra/perf/StoreLock.js';
+const WA_MESSAGE_CLEAR_KEY = 'message:clear';
+export function withMessageLock(store) {
+    const lock = new StoreLock();
+    const gate = new SharedExclusiveGate();
+    const destroyStore = store;
+    return {
+        upsert: (record) => gate.runShared(() => lock.run(`message:${record.id}`, () => store.upsert(record))),
+        upsertBatch: (records) => gate.runShared(() => lock.runMany(records.map((record) => `message:${record.id}`), () => store.upsertBatch(records))),
+        getById: (id) => gate.runShared(() => store.getById(id)),
+        listByThread: (threadJid, limit, beforeTimestampMs) => gate.runShared(() => store.listByThread(threadJid, limit, beforeTimestampMs)),
+        deleteById: (id) => gate.runShared(() => lock.run(`message:${id}`, () => store.deleteById(id))),
+        clear: () => gate.runExclusive(() => lock.run(WA_MESSAGE_CLEAR_KEY, () => store.clear())),
+        destroy: async () => {
+            await gate.close();
+            await lock.shutdown();
+            await destroyStore.destroy?.();
+        }
+    };
+}

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

@@ -0,0 +1,20 @@
+import { SharedExclusiveGate } from '../../infra/perf/SharedExclusiveGate.js';
+import { StoreLock } from '../../infra/perf/StoreLock.js';
+const WA_PARTICIPANTS_CLEAR_KEY = 'participants:clear';
+const WA_PARTICIPANTS_CLEANUP_KEY = 'participants:cleanup';
+export function withParticipantsLock(store) {
+    const lock = new StoreLock();
+    const gate = new SharedExclusiveGate();
+    return {
+        destroy: async () => {
+            await gate.close();
+            await lock.shutdown();
+            await store.destroy?.();
+        },
+        upsertGroupParticipants: (snapshot) => gate.runShared(() => lock.run(`participants:group:${snapshot.groupJid}`, () => store.upsertGroupParticipants(snapshot))),
+        getGroupParticipants: (groupJid, nowMs) => gate.runShared(() => store.getGroupParticipants(groupJid, nowMs)),
+        deleteGroupParticipants: (groupJid) => gate.runShared(() => lock.run(`participants:group:${groupJid}`, () => store.deleteGroupParticipants(groupJid))),
+        cleanupExpired: (nowMs) => gate.runExclusive(() => lock.run(WA_PARTICIPANTS_CLEANUP_KEY, () => store.cleanupExpired(nowMs))),
+        clear: () => gate.runExclusive(() => lock.run(WA_PARTICIPANTS_CLEAR_KEY, () => store.clear()))
+    };
+}