zapo-js 0.1.1 → 0.2.0

package/dist/esm/signal/session/SignalSession.js

@@ -20,16 +20,21 @@ export function findMatchingSession(session, sessionBaseKey) {
     if (session.aliceBaseKey && uint8Equal(session.aliceBaseKey, serializedBaseKey)) {
         return session;
     }
-    const previousSessionIndex = session.prevSessions.findIndex((prev) => !!prev.aliceBaseKey && uint8Equal(prev.aliceBaseKey, serializedBaseKey));
-    if (previousSessionIndex !== -1) {
-        const promoted = snapshotToRecord(session.prevSessions[previousSessionIndex]);
+    for (let index = 0; index < session.prevSessions.length; index += 1) {
+        const previousSession = session.prevSessions[index];
+        if (!previousSession.aliceBaseKey ||
+            !uint8Equal(previousSession.aliceBaseKey, serializedBaseKey)) {
+            continue;
+        }
+        const prevSessions = [detachSession(session)];
+        for (let i = 0; i < session.prevSessions.length; i += 1) {
+            if (i !== index) {
+                prevSessions.push(session.prevSessions[i]);
+            }
+        }
         return {
-            ...promoted,
-            prevSessions: [
-                detachSession(session),
-                ...session.prevSessions.slice(0, previousSessionIndex),
-                ...session.prevSessions.slice(previousSessionIndex + 1)
-            ]
+            ...previousSession,
+            prevSessions
         };
     }
     return null;

package/dist/esm/signal/session/resolver.js

@@ -0,0 +1,221 @@
+import { toSerializedPubKey } from '../../crypto/core/keys.js';
+import { PromiseDedup } from '../../infra/perf/PromiseDedup.js';
+import { normalizeDeviceJid, parseSignalAddressFromJid, signalAddressKey } from '../../protocol/jid.js';
+import { bytesToHex, uint8Equal } from '../../util/bytes.js';
+import { toError } from '../../util/primitives.js';
+export function createSignalSessionResolver(options) {
+    const { signalProtocol, signalStore, signalIdentitySync, signalSessionSync, logger } = options;
+    const dedup = new PromiseDedup();
+    const ensureSessionInternal = async (address, jid, expectedIdentity, reasonIdentity = false, prefetchedBundle) => {
+        const expectedSerializedIdentity = expectedIdentity
+            ? toSerializedPubKey(expectedIdentity)
+            : null;
+        if (reasonIdentity) {
+            await signalIdentitySync.syncIdentityKeys([jid]);
+        }
+        if (await signalStore.hasSession(address)) {
+            if (expectedSerializedIdentity) {
+                const storedIdentity = await signalStore.getRemoteIdentity(address);
+                if (!storedIdentity || !uint8Equal(storedIdentity, expectedSerializedIdentity)) {
+                    throw new Error('identity mismatch');
+                }
+            }
+            return null;
+        }
+        let fetched;
+        if (prefetchedBundle) {
+            fetched = {
+                jid,
+                bundle: prefetchedBundle
+            };
+        }
+        else {
+            logger.info('signal session missing, fetching remote key bundle', { jid });
+            fetched = await signalSessionSync.fetchKeyBundle({
+                jid,
+                reasonIdentity
+            });
+        }
+        const remoteIdentity = toSerializedPubKey(fetched.bundle.identity);
+        if (reasonIdentity) {
+            const storedIdentity = await signalStore.getRemoteIdentity(address);
+            if (storedIdentity && !uint8Equal(remoteIdentity, storedIdentity)) {
+                throw new Error('identity mismatch');
+            }
+        }
+        if (expectedSerializedIdentity && !uint8Equal(remoteIdentity, expectedSerializedIdentity)) {
+            throw new Error('identity mismatch');
+        }
+        const session = await signalProtocol.establishOutgoingSession(address, fetched.bundle, {
+            reuseExisting: true
+        });
+        logger.info('signal session synchronized', {
+            jid,
+            regId: fetched.bundle.regId,
+            hasOneTimeKey: fetched.bundle.oneTimeKey !== undefined
+        });
+        return session;
+    };
+    const ensureSessionWithDedup = (address, jid, expectedIdentity, reasonIdentity = false, prefetchedBundle) => {
+        const expectedIdentityKey = expectedIdentity ? bytesToHex(expectedIdentity) : 'none';
+        const dedupKey = `signalSession:${signalAddressKey(address)}:${reasonIdentity ? '1' : '0'}:${expectedIdentityKey}`;
+        return dedup.run(dedupKey, () => ensureSessionInternal(address, jid, expectedIdentity, reasonIdentity, prefetchedBundle));
+    };
+    const ensureSession = (address, jid, expectedIdentity, reasonIdentity = false) => ensureSessionWithDedup(address, jid, expectedIdentity, reasonIdentity).then(() => { });
+    const ensureSessionsBatch = async (targetJids, expectedIdentityByJid) => {
+        const seenTargetJids = new Set();
+        const normalizedTargetJids = new Array(targetJids.length);
+        const normalizedTargetAddresses = new Array(targetJids.length);
+        let normalizedTargetCount = 0;
+        for (let index = 0; index < targetJids.length; index += 1) {
+            const jid = normalizeDeviceJid(targetJids[index]);
+            if (seenTargetJids.has(jid)) {
+                continue;
+            }
+            seenTargetJids.add(jid);
+            normalizedTargetJids[normalizedTargetCount] = jid;
+            normalizedTargetAddresses[normalizedTargetCount] = parseSignalAddressFromJid(jid);
+            normalizedTargetCount += 1;
+        }
+        if (normalizedTargetCount === 0) {
+            return [];
+        }
+        normalizedTargetJids.length = normalizedTargetCount;
+        normalizedTargetAddresses.length = normalizedTargetCount;
+        const normalizedExpectedIdentityByJid = expectedIdentityByJid && expectedIdentityByJid.size > 0
+            ? new Map()
+            : undefined;
+        if (normalizedExpectedIdentityByJid && expectedIdentityByJid) {
+            for (const [jid, identity] of expectedIdentityByJid.entries()) {
+                try {
+                    toSerializedPubKey(identity);
+                    normalizedExpectedIdentityByJid.set(normalizeDeviceJid(jid), identity);
+                }
+                catch (error) {
+                    logger.trace('ignoring malformed expected identity jid during batch normalization', { jid, message: toError(error).message });
+                }
+            }
+        }
+        const resolvedByIndex = (await signalStore.getSessionsBatch(normalizedTargetAddresses));
+        const collectResolvedTargets = () => {
+            const resolvedTargets = new Array(normalizedTargetJids.length);
+            let resolvedTargetCount = 0;
+            for (let index = 0; index < normalizedTargetJids.length; index += 1) {
+                const session = resolvedByIndex[index];
+                if (!session) {
+                    continue;
+                }
+                resolvedTargets[resolvedTargetCount] = {
+                    jid: normalizedTargetJids[index],
+                    address: normalizedTargetAddresses[index],
+                    session
+                };
+                resolvedTargetCount += 1;
+            }
+            resolvedTargets.length = resolvedTargetCount;
+            return resolvedTargets;
+        };
+        const missingIndices = [];
+        for (let index = 0; index < normalizedTargetJids.length; index += 1) {
+            const session = resolvedByIndex[index];
+            const expectedIdentity = normalizedExpectedIdentityByJid?.get(normalizedTargetJids[index]);
+            if (session && expectedIdentity) {
+                if (!uint8Equal(session.remote.pubKey, toSerializedPubKey(expectedIdentity))) {
+                    throw new Error('identity mismatch');
+                }
+            }
+            if (!session) {
+                missingIndices.push(index);
+            }
+        }
+        if (missingIndices.length === 0) {
+            return collectResolvedTargets();
+        }
+        const batchRequest = new Array(missingIndices.length);
+        for (let index = 0; index < missingIndices.length; index += 1) {
+            batchRequest[index] = { jid: normalizedTargetJids[missingIndices[index]] };
+        }
+        let batchResults;
+        try {
+            batchResults = await signalSessionSync.fetchKeyBundles(batchRequest);
+        }
+        catch (error) {
+            logger.warn('signal batch key fetch failed', {
+                requested: missingIndices.length,
+                message: toError(error).message
+            });
+            return collectResolvedTargets();
+        }
+        const ensuredTargetIndices = new Array(missingIndices.length);
+        const ensurePromises = new Array(missingIndices.length);
+        let ensureCount = 0;
+        for (let index = 0; index < missingIndices.length; index += 1) {
+            const targetIndex = missingIndices[index];
+            const targetJid = normalizedTargetJids[targetIndex];
+            const batchResult = batchResults[index];
+            if (!batchResult?.bundle) {
+                logger.warn('signal batch key fetch returned target without bundle', {
+                    jid: targetJid,
+                    message: batchResult?.errorText ?? 'missing key bundle user in response'
+                });
+                continue;
+            }
+            const expectedIdentity = normalizedExpectedIdentityByJid?.get(targetJid);
+            ensuredTargetIndices[ensureCount] = targetIndex;
+            ensurePromises[ensureCount] = ensureSessionWithDedup(normalizedTargetAddresses[targetIndex], targetJid, expectedIdentity, false, batchResult.bundle);
+            ensureCount += 1;
+        }
+        if (ensureCount === 0) {
+            return collectResolvedTargets();
+        }
+        ensuredTargetIndices.length = ensureCount;
+        ensurePromises.length = ensureCount;
+        const ensureResults = await Promise.allSettled(ensurePromises);
+        const fallbackIndices = [];
+        for (let index = 0; index < ensuredTargetIndices.length; index += 1) {
+            const targetIndex = ensuredTargetIndices[index];
+            const ensureResult = ensureResults[index];
+            if (ensureResult.status === 'rejected') {
+                const normalized = toError(ensureResult.reason);
+                if (normalized.message === 'identity mismatch') {
+                    throw normalized;
+                }
+                logger.warn('signal session ensure failed during batch resolution', {
+                    jid: normalizedTargetJids[targetIndex],
+                    message: normalized.message
+                });
+                continue;
+            }
+            const session = ensureResult.value;
+            if (session) {
+                resolvedByIndex[targetIndex] = session;
+            }
+            else {
+                fallbackIndices.push(targetIndex);
+            }
+        }
+        if (fallbackIndices.length > 0) {
+            const fallbackAddresses = new Array(fallbackIndices.length);
+            for (let i = 0; i < fallbackIndices.length; i++) {
+                fallbackAddresses[i] = normalizedTargetAddresses[fallbackIndices[i]];
+            }
+            const fallbackSessions = await signalStore.getSessionsBatch(fallbackAddresses);
+            for (let i = 0; i < fallbackIndices.length; i++) {
+                const session = fallbackSessions[i];
+                if (session) {
+                    resolvedByIndex[fallbackIndices[i]] = session;
+                }
+                else {
+                    logger.warn('signal session ensure completed without persisted session', {
+                        jid: normalizedTargetJids[fallbackIndices[i]]
+                    });
+                }
+            }
+        }
+        return collectResolvedTargets();
+    };
+    return {
+        ensureSession,
+        ensureSessionsBatch
+    };
+}

package/dist/esm/store/contracts/privacy-token.store.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/store/createStore.js

@@ -1,59 +1,31 @@
+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 { withMessageLock } from './locks/message.lock.js';
+import { withParticipantsLock } from './locks/participants.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 { 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 { 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;
-}
+});
 function hasDestroy(value) {
     return (!!value &&
         typeof value === 'object' &&
@@ -61,30 +33,32 @@ 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')
     });
     const sessions = new Map();
     let storeDestroyed = false;
@@ -93,125 +67,67 @@ 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 custom = options.custom;
-            const customCache = options.customCache;
-            const customAuth = resolveStoreValue(normalizedSessionId, custom?.auth, 'custom.auth');
-            const customSignal = resolveStoreValue(normalizedSessionId, custom?.signal, 'custom.signal');
-            const customSenderKey = resolveStoreValue(normalizedSessionId, custom?.senderKey, 'custom.senderKey');
-            const customAppState = resolveStoreValue(normalizedSessionId, custom?.appState, 'custom.appState');
-            const customRetry = resolveStoreValue(normalizedSessionId, customCache?.retry, 'customCache.retry');
-            const customParticipants = resolveStoreValue(normalizedSessionId, customCache?.participants, 'customCache.participants');
-            const customDeviceList = resolveStoreValue(normalizedSessionId, customCache?.deviceList, 'customCache.deviceList');
-            const customMessages = resolveStoreValue(normalizedSessionId, custom?.messages, 'custom.messages');
-            const customThreads = resolveStoreValue(normalizedSessionId, custom?.threads, 'custom.threads');
-            const customContacts = resolveStoreValue(normalizedSessionId, 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
-                }
-                : 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({
+                maxPreKeys: ml.signalPreKeys,
+                maxSessions: ml.signalSessions,
+                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', () => new WaRetryMemoryStore(cacheTtlsMs.retry));
+            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 authStore = withAuthLock(rawAuth);
+            const signalStore = withSignalLock(rawSignal);
+            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 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(),
@@ -225,9 +141,8 @@ export function createStore(options) {
                 ]);
             };
             const destroy = async () => {
-                if (sessionDestroyed) {
+                if (sessionDestroyed)
                     return;
-                }
                 sessionDestroyed = true;
                 await destroyCaches();
                 await Promise.all([
@@ -237,7 +152,8 @@ export function createStore(options) {
                     destroyIfSupported(appStateStore),
                     destroyIfSupported(messageStore),
                     destroyIfSupported(threadStore),
-                    destroyIfSupported(contactStore)
+                    destroyIfSupported(contactStore),
+                    destroyIfSupported(privacyTokenStore)
                 ]);
             };
             const session = {
@@ -251,28 +167,24 @@ export function createStore(options) {
                 messages: messageStore,
                 threads: threadStore,
                 contacts: contactStore,
+                privacyToken: privacyTokenStore,
                 destroyCaches,
                 destroy
             };
-            sessions.set(normalizedSessionId, session);
+            sessions.set(id, session);
             return session;
         },
         async destroyCaches() {
-            const activeSessions = [...sessions.values()];
-            for (const session of activeSessions) {
-                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;
-            const activeSessions = [...sessions.values()];
+            const list = Array.from(sessions.values());
             sessions.clear();
-            for (const session of activeSessions) {
-                await session.destroy();
-            }
+            await Promise.all(list.map((s) => s.destroy()));
         }
     };
 }

package/dist/esm/store/index.js

@@ -1,11 +1,4 @@
-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 { SenderKeyMemoryStore } from './providers/memory/sender-key.store.js';
@@ -15,6 +8,4 @@ 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 { 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';