zapo-js 0.1.0

package/dist/esm/signal/store/sqlite.js

@@ -0,0 +1,310 @@
+import { proto } from '../../proto.js';
+import { WA_DEFAULTS } from '../../protocol/constants.js';
+import { asBytes, asNumber, asOptionalBytes, asOptionalNumber, asString, toBoolOrUndef } from '../../util/coercion.js';
+export function toSignalAddressParts(address) {
+    return {
+        user: address.user,
+        server: address.server ?? WA_DEFAULTS.HOST_DOMAIN,
+        device: address.device
+    };
+}
+export function decodeSignalAddressFromRow(row) {
+    return {
+        user: asString(row.sender_user, 'signal.sender_user'),
+        server: asString(row.sender_server, 'signal.sender_server'),
+        device: asNumber(row.sender_device, 'signal.sender_device')
+    };
+}
+export function decodeSignalRegistrationRow(row) {
+    return {
+        registrationId: asNumber(row.registration_id, 'signal_registration.registration_id'),
+        identityKeyPair: {
+            pubKey: asBytes(row.identity_pub_key, 'signal_registration.identity_pub_key'),
+            privKey: asBytes(row.identity_priv_key, 'signal_registration.identity_priv_key')
+        }
+    };
+}
+export function decodeSignalPreKeyRow(row) {
+    return {
+        keyId: asNumber(row.key_id, 'signal_prekey.key_id'),
+        keyPair: {
+            pubKey: asBytes(row.pub_key, 'signal_prekey.pub_key'),
+            privKey: asBytes(row.priv_key, 'signal_prekey.priv_key')
+        },
+        uploaded: toBoolOrUndef(row.uploaded)
+    };
+}
+export function decodeSignalSignedPreKeyRow(row) {
+    return {
+        keyId: asNumber(row.key_id, 'signal_signed_prekey.key_id'),
+        keyPair: {
+            pubKey: asBytes(row.pub_key, 'signal_signed_prekey.pub_key'),
+            privKey: asBytes(row.priv_key, 'signal_signed_prekey.priv_key')
+        },
+        signature: asBytes(row.signature, 'signal_signed_prekey.signature'),
+        uploaded: toBoolOrUndef(row.uploaded)
+    };
+}
+function encodeSignalSessionSnapshot(session) {
+    return {
+        sessionVersion: 3,
+        localRegistrationId: session.local.regId,
+        localIdentityPublic: session.local.pubKey,
+        remoteRegistrationId: session.remote.regId,
+        remoteIdentityPublic: session.remote.pubKey,
+        rootKey: session.rootKey,
+        previousCounter: session.prevSendChainHighestIndex,
+        senderChain: encodeSignalSendChain(session.sendChain),
+        receiverChains: session.recvChains.map((chain) => encodeSignalRecvChain(chain)),
+        pendingPreKey: session.initialExchangeInfo
+            ? {
+                preKeyId: session.initialExchangeInfo.remoteOneTimeId ?? undefined,
+                signedPreKeyId: session.initialExchangeInfo.remoteSignedId,
+                baseKey: session.initialExchangeInfo.localOneTimePubKey
+            }
+            : undefined,
+        aliceBaseKey: session.aliceBaseKey ?? undefined
+    };
+}
+function encodeSignalSendChain(chain) {
+    return {
+        senderRatchetKey: chain.ratchetKey.pubKey,
+        senderRatchetKeyPrivate: chain.ratchetKey.privKey,
+        chainKey: {
+            index: chain.nextMsgIndex,
+            key: chain.chainKey
+        },
+        messageKeys: []
+    };
+}
+function encodeSignalRecvChain(chain) {
+    return {
+        senderRatchetKey: chain.ratchetPubKey,
+        chainKey: {
+            index: chain.nextMsgIndex,
+            key: chain.chainKey
+        },
+        messageKeys: (chain.unusedMsgKeys ?? []).map((messageKey) => ({
+            index: messageKey.index,
+            cipherKey: messageKey.cipherKey,
+            macKey: messageKey.macKey,
+            iv: messageKey.iv
+        }))
+    };
+}
+function decodeSignalMessageKey(messageKey, field) {
+    const cipherKey = asBytes(messageKey.cipherKey, `${field}.cipherKey`);
+    if (cipherKey.byteLength !== 32) {
+        throw new Error(`invalid ${field}.cipherKey length ${cipherKey.byteLength}`);
+    }
+    const macKey = asBytes(messageKey.macKey, `${field}.macKey`);
+    if (macKey.byteLength !== 32) {
+        throw new Error(`invalid ${field}.macKey length ${macKey.byteLength}`);
+    }
+    const iv = asBytes(messageKey.iv, `${field}.iv`);
+    if (iv.byteLength !== 16) {
+        throw new Error(`invalid ${field}.iv length ${iv.byteLength}`);
+    }
+    return {
+        index: asNumber(messageKey.index, `${field}.index`),
+        cipherKey,
+        macKey,
+        iv
+    };
+}
+function decodeSignalRecvChain(chain, field) {
+    const chainKey = chain.chainKey;
+    if (!chainKey) {
+        throw new Error(`missing ${field}.chainKey`);
+    }
+    const ratchetPubKey = asBytes(chain.senderRatchetKey, `${field}.senderRatchetKey`);
+    if (ratchetPubKey.byteLength !== 33) {
+        throw new Error(`invalid ${field}.senderRatchetKey length ${ratchetPubKey.byteLength}`);
+    }
+    const chainKeyBytes = asBytes(chainKey.key, `${field}.chainKey.key`);
+    if (chainKeyBytes.byteLength !== 32) {
+        throw new Error(`invalid ${field}.chainKey.key length ${chainKeyBytes.byteLength}`);
+    }
+    return {
+        ratchetPubKey,
+        nextMsgIndex: asNumber(chainKey.index, `${field}.chainKey.index`),
+        chainKey: chainKeyBytes,
+        unusedMsgKeys: (chain.messageKeys ?? []).map((messageKey, index) => decodeSignalMessageKey(messageKey, `${field}.messageKeys[${index}]`))
+    };
+}
+function decodeSignalSendChain(chain, field) {
+    const chainKey = chain.chainKey;
+    if (!chainKey) {
+        throw new Error(`missing ${field}.chainKey`);
+    }
+    const privateKey = asOptionalBytes(chain.senderRatchetKeyPrivate, `${field}.senderRatchetKeyPrivate`);
+    if (!privateKey) {
+        throw new Error(`missing ${field}.senderRatchetKeyPrivate`);
+    }
+    if (privateKey.byteLength !== 32) {
+        throw new Error(`invalid ${field}.senderRatchetKeyPrivate length ${privateKey.byteLength}`);
+    }
+    const ratchetPubKey = asBytes(chain.senderRatchetKey, `${field}.senderRatchetKey`);
+    if (ratchetPubKey.byteLength !== 33) {
+        throw new Error(`invalid ${field}.senderRatchetKey length ${ratchetPubKey.byteLength}`);
+    }
+    const chainKeyBytes = asBytes(chainKey.key, `${field}.chainKey.key`);
+    if (chainKeyBytes.byteLength !== 32) {
+        throw new Error(`invalid ${field}.chainKey.key length ${chainKeyBytes.byteLength}`);
+    }
+    return {
+        ratchetKey: {
+            pubKey: ratchetPubKey,
+            privKey: privateKey
+        },
+        nextMsgIndex: asNumber(chainKey.index, `${field}.chainKey.index`),
+        chainKey: chainKeyBytes
+    };
+}
+function decodeSignalSessionSnapshot(session, field) {
+    const senderChain = session.senderChain;
+    if (!senderChain) {
+        throw new Error(`missing ${field}.senderChain`);
+    }
+    const pendingPreKey = session.pendingPreKey;
+    const localPubKey = asBytes(session.localIdentityPublic, `${field}.localIdentityPublic`);
+    if (localPubKey.byteLength !== 33) {
+        throw new Error(`invalid ${field}.localIdentityPublic length ${localPubKey.byteLength}`);
+    }
+    const remotePubKey = asBytes(session.remoteIdentityPublic, `${field}.remoteIdentityPublic`);
+    if (remotePubKey.byteLength !== 33) {
+        throw new Error(`invalid ${field}.remoteIdentityPublic length ${remotePubKey.byteLength}`);
+    }
+    const rootKey = asBytes(session.rootKey, `${field}.rootKey`);
+    if (rootKey.byteLength !== 32) {
+        throw new Error(`invalid ${field}.rootKey length ${rootKey.byteLength}`);
+    }
+    const localOneTimePubKey = pendingPreKey
+        ? asBytes(pendingPreKey.baseKey, `${field}.pendingPreKey.baseKey`)
+        : null;
+    if (localOneTimePubKey && localOneTimePubKey.byteLength !== 33) {
+        throw new Error(`invalid ${field}.pendingPreKey.baseKey length ${localOneTimePubKey.byteLength}`);
+    }
+    const aliceBaseKey = asOptionalBytes(session.aliceBaseKey, `${field}.aliceBaseKey`) ?? null;
+    if (aliceBaseKey && aliceBaseKey.byteLength !== 33) {
+        throw new Error(`invalid ${field}.aliceBaseKey length ${aliceBaseKey.byteLength}`);
+    }
+    return {
+        local: {
+            regId: asNumber(session.localRegistrationId, `${field}.localRegistrationId`),
+            pubKey: localPubKey
+        },
+        remote: {
+            regId: asNumber(session.remoteRegistrationId, `${field}.remoteRegistrationId`),
+            pubKey: remotePubKey
+        },
+        rootKey,
+        sendChain: decodeSignalSendChain(senderChain, `${field}.senderChain`),
+        recvChains: (session.receiverChains ?? []).map((chain, index) => decodeSignalRecvChain(chain, `${field}.receiverChains[${index}]`)),
+        initialExchangeInfo: pendingPreKey
+            ? {
+                remoteOneTimeId: asOptionalNumber(pendingPreKey.preKeyId, `${field}.pendingPreKey.preKeyId`) ??
+                    null,
+                remoteSignedId: asNumber(pendingPreKey.signedPreKeyId, `${field}.pendingPreKey.signedPreKeyId`),
+                localOneTimePubKey: localOneTimePubKey
+            }
+            : null,
+        prevSendChainHighestIndex: asOptionalNumber(session.previousCounter, `${field}.previousCounter`) ?? 0,
+        aliceBaseKey
+    };
+}
+export function encodeSignalSessionRecord(record) {
+    return proto.RecordStructure.encode({
+        currentSession: encodeSignalSessionSnapshot(record),
+        previousSessions: record.prevSessions.map((session) => encodeSignalSessionSnapshot(session))
+    }).finish();
+}
+export function decodeSignalSessionRecord(raw) {
+    const decoded = proto.RecordStructure.decode(asBytes(raw, 'signal_sessions.record'));
+    if (!decoded.currentSession) {
+        throw new Error('missing signal_sessions.record.currentSession');
+    }
+    const current = decodeSignalSessionSnapshot(decoded.currentSession, 'signal_sessions.currentSession');
+    return {
+        ...current,
+        prevSessions: (decoded.previousSessions ?? []).map((session, index) => decodeSignalSessionSnapshot(session, `signal_sessions.previousSessions[${index}]`))
+    };
+}
+export function encodeSenderKeyRecord(record) {
+    return proto.SenderKeyRecordStructure.encode({
+        senderKeyStates: [
+            {
+                senderKeyId: record.keyId,
+                senderChainKey: {
+                    iteration: record.iteration,
+                    seed: record.chainKey
+                },
+                senderSigningKey: {
+                    public: record.signingPublicKey,
+                    private: record.signingPrivateKey
+                },
+                senderMessageKeys: (record.unusedMessageKeys ?? []).map((messageKey) => ({
+                    iteration: messageKey.iteration,
+                    seed: messageKey.seed
+                }))
+            }
+        ]
+    }).finish();
+}
+function decodeSenderKeyState(state, field) {
+    if (!state.senderChainKey) {
+        throw new Error(`missing ${field}.senderChainKey`);
+    }
+    if (!state.senderSigningKey) {
+        throw new Error(`missing ${field}.senderSigningKey`);
+    }
+    return {
+        keyId: asNumber(state.senderKeyId, `${field}.senderKeyId`),
+        iteration: asNumber(state.senderChainKey.iteration, `${field}.senderChainKey.iteration`),
+        chainKey: asBytes(state.senderChainKey.seed, `${field}.senderChainKey.seed`),
+        signingPublicKey: asBytes(state.senderSigningKey.public, `${field}.senderSigningKey.public`),
+        signingPrivateKey: state.senderSigningKey.private !== null && state.senderSigningKey.private !== undefined
+            ? asBytes(state.senderSigningKey.private, `${field}.senderSigningKey.private`)
+            : undefined,
+        unusedMessageKeys: (state.senderMessageKeys ?? []).map((messageKey, index) => ({
+            iteration: asNumber(messageKey.iteration, `${field}.senderMessageKeys[${index}].iteration`),
+            seed: asBytes(messageKey.seed, `${field}.senderMessageKeys[${index}].seed`)
+        }))
+    };
+}
+export function decodeSenderKeyRecord(raw, groupId, sender) {
+    const decoded = proto.SenderKeyRecordStructure.decode(asBytes(raw, 'sender_keys.record'));
+    const state = decoded.senderKeyStates?.[0];
+    if (!state) {
+        throw new Error('missing sender_keys.record.senderKeyStates[0]');
+    }
+    const parsed = decodeSenderKeyState(state, 'sender_keys.record.senderKeyStates[0]');
+    return {
+        groupId,
+        sender,
+        keyId: parsed.keyId,
+        iteration: parsed.iteration,
+        chainKey: parsed.chainKey,
+        signingPublicKey: parsed.signingPublicKey,
+        signingPrivateKey: parsed.signingPrivateKey,
+        unusedMessageKeys: parsed.unusedMessageKeys
+    };
+}
+export function decodeSenderKeyDistributionRow(row) {
+    return {
+        groupId: asString(row.group_id, 'sender_key_distribution.group_id'),
+        sender: {
+            user: asString(row.sender_user, 'sender_key_distribution.sender_user'),
+            server: asString(row.sender_server, 'sender_key_distribution.sender_server'),
+            device: asNumber(row.sender_device, 'sender_key_distribution.sender_device')
+        },
+        keyId: asNumber(row.key_id, 'sender_key_distribution.key_id'),
+        timestampMs: asNumber(row.timestamp_ms, 'sender_key_distribution.timestamp_ms')
+    };
+}
+export function decodeSqliteCount(row, field) {
+    return row ? asNumber(row.count, field) : 0;
+}
+export function decodeSignalRemoteIdentity(raw) {
+    return asBytes(raw, 'signal_identity.identity_key');
+}

package/dist/esm/signal/types.js

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

package/dist/esm/store/contracts/appstate.store.js

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

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

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

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

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

package/dist/esm/store/contracts/device-list.store.js

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

package/dist/esm/store/contracts/message.store.js

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

package/dist/esm/store/contracts/participants.store.js

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

package/dist/esm/store/contracts/retry.store.js

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

package/dist/esm/store/contracts/sender-key.store.js

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

package/dist/esm/store/contracts/signal.store.js

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

package/dist/esm/store/contracts/thread.store.js

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

package/dist/esm/store/createStore.js

@@ -0,0 +1,278 @@
+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 { 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,
+    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' &&
+        'destroy' in value &&
+        typeof value.destroy === 'function');
+}
+async function destroyIfSupported(value) {
+    if (!hasDestroy(value)) {
+        return;
+    }
+    await value.destroy();
+}
+export function createStore(options) {
+    const providers = {
+        ...DEFAULT_PROVIDERS,
+        ...(options.providers ?? {})
+    };
+    const cacheProviders = {
+        ...DEFAULT_CACHE_PROVIDERS,
+        ...(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')
+    });
+    const sessions = new Map();
+    let storeDestroyed = false;
+    return {
+        session(sessionId) {
+            if (storeDestroyed) {
+                throw new Error('store has been destroyed');
+            }
+            const normalizedSessionId = sessionId.trim();
+            if (normalizedSessionId.length === 0) {
+                throw new Error('sessionId must be a non-empty string');
+            }
+            const cached = sessions.get(normalizedSessionId);
+            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);
+            let cachesDestroyed = false;
+            let sessionDestroyed = false;
+            const destroyCaches = async () => {
+                if (cachesDestroyed) {
+                    return;
+                }
+                cachesDestroyed = true;
+                await Promise.all([
+                    retryStore.clear(),
+                    participantsStore.clear(),
+                    deviceListStore.clear()
+                ]);
+                await Promise.all([
+                    destroyIfSupported(retryStore),
+                    destroyIfSupported(participantsStore),
+                    destroyIfSupported(deviceListStore)
+                ]);
+            };
+            const destroy = async () => {
+                if (sessionDestroyed) {
+                    return;
+                }
+                sessionDestroyed = true;
+                await destroyCaches();
+                await Promise.all([
+                    destroyIfSupported(authStore),
+                    destroyIfSupported(signalStore),
+                    destroyIfSupported(senderKeyStore),
+                    destroyIfSupported(appStateStore),
+                    destroyIfSupported(messageStore),
+                    destroyIfSupported(threadStore),
+                    destroyIfSupported(contactStore)
+                ]);
+            };
+            const session = {
+                auth: authStore,
+                signal: signalStore,
+                senderKey: senderKeyStore,
+                appState: appStateStore,
+                retry: retryStore,
+                participants: participantsStore,
+                deviceList: deviceListStore,
+                messages: messageStore,
+                threads: threadStore,
+                contacts: contactStore,
+                destroyCaches,
+                destroy
+            };
+            sessions.set(normalizedSessionId, session);
+            return session;
+        },
+        async destroyCaches() {
+            const activeSessions = [...sessions.values()];
+            for (const session of activeSessions) {
+                await session.destroyCaches();
+            }
+        },
+        async destroy() {
+            if (storeDestroyed) {
+                return;
+            }
+            storeDestroyed = true;
+            const activeSessions = [...sessions.values()];
+            sessions.clear();
+            for (const session of activeSessions) {
+                await session.destroy();
+            }
+        }
+    };
+}

package/dist/esm/store/index.js

@@ -0,0 +1,20 @@
+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';
+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 { WaContactSqliteStore } from './providers/sqlite/contact.store.js';
+export { WaMessageSqliteStore } from './providers/sqlite/message.store.js';
+export { WaThreadSqliteStore } from './providers/sqlite/thread.store.js';