zapo-js 1.6.0 → 1.6.2

package/dist/client/WaClientFactory.js

@@ -375,7 +375,8 @@ function buildWaClientDependencies(input) {
         logger
     });
     const privacyCoordinator = (0, WaPrivacyCoordinator_1.createPrivacyCoordinator)({
-        queryWithContext: runtime.queryWithContext
+        queryWithContext: runtime.queryWithContext,
+        resolveUserJidPair: (userJid) => signalDeviceSync.resolveUserJidPair(userJid)
     });
     const businessCoordinator = (0, WaBusinessCoordinator_1.createBusinessCoordinator)({
         queryWithContext: runtime.queryWithContext,

package/dist/client/coordinators/WaMessageDispatchCoordinator.d.ts

@@ -80,8 +80,8 @@ export declare class WaMessageDispatchCoordinator {
     sendMessage(to: string, content: WaSendMessageContent, options?: WaSendMessageOptions): Promise<WaMessagePublishResult>;
     /**
      * For a 1:1 recipient passed in PN form, returns the LID-addressed user JID
-     * (cache-first; falls back to a one-shot `queryLidsByPhoneJids`). Switching
-     * to LID before fanout ensures the envelope, eligible-requester list, and
+     * (via {@link SignalDeviceSyncApi.resolveUserJidPair}). Switching to LID
+     * before fanout ensures the envelope, eligible-requester list, and
      * retry-receipt addressing all agree, which keeps the retry tracker from
      * rejecting receipts that arrive in LID form. Returns the original PN if
      * no LID is known/resolvable. Inputs already in LID form pass through.

package/dist/client/coordinators/WaMessageDispatchCoordinator.js

@@ -300,8 +300,8 @@ class WaMessageDispatchCoordinator {
     }
     /**
      * For a 1:1 recipient passed in PN form, returns the LID-addressed user JID
-     * (cache-first; falls back to a one-shot `queryLidsByPhoneJids`). Switching
-     * to LID before fanout ensures the envelope, eligible-requester list, and
+     * (via {@link SignalDeviceSyncApi.resolveUserJidPair}). Switching to LID
+     * before fanout ensures the envelope, eligible-requester list, and
      * retry-receipt addressing all agree, which keeps the retry tracker from
      * rejecting receipts that arrive in LID form. Returns the original PN if
      * no LID is known/resolvable. Inputs already in LID form pass through.
@@ -309,26 +309,8 @@ class WaMessageDispatchCoordinator {
     async resolveDirectRecipientLid(pnUserJid) {
         if ((0, jid_1.isLidJid)(pnUserJid))
             return pnUserJid;
-        const cached = await this.deps.deviceListStore.findByAnyUserJid(pnUserJid);
-        if (cached) {
-            if ((0, jid_1.isLidJid)(cached.userJid))
-                return cached.userJid;
-            if (cached.altUserJid && (0, jid_1.isLidJid)(cached.altUserJid))
-                return cached.altUserJid;
-        }
-        try {
-            const results = await this.deps.signalDeviceSync.queryLidsByPhoneJids([pnUserJid]);
-            const match = results.find((entry) => entry.queriedJid === pnUserJid);
-            if (match?.lidJid)
-                return match.lidJid;
-        }
-        catch (error) {
-            this.deps.logger.debug('lid resolution failed for direct recipient', {
-                pnUserJid,
-                message: (0, primitives_2.toError)(error).message
-            });
-        }
-        return pnUserJid;
+        const pair = await this.deps.signalDeviceSync.resolveUserJidPair(pnUserJid);
+        return pair.lidJid ?? pnUserJid;
     }
     /**
      * Resolves the `peer_recipient_pn` cross-reference for a 1:1 send, or
@@ -344,20 +326,8 @@ class WaMessageDispatchCoordinator {
             return undefined;
         if ((0, jid_1.isUserJid)(recipientUserJid))
             return recipientUserJid;
-        try {
-            const snapshot = await this.deps.deviceListStore.findByAnyUserJid(directRecipientJid);
-            if (snapshot?.userJid && (0, jid_1.isUserJid)(snapshot.userJid))
-                return snapshot.userJid;
-            if (snapshot?.altUserJid && (0, jid_1.isUserJid)(snapshot.altUserJid))
-                return snapshot.altUserJid;
-        }
-        catch (error) {
-            this.deps.logger.trace('peer_recipient_pn store lookup failed', {
-                lid: directRecipientJid,
-                message: (0, primitives_2.toError)(error).message
-            });
-        }
-        return undefined;
+        const pair = await this.deps.signalDeviceSync.resolveUserJidPair(directRecipientJid);
+        return pair.pnJid ?? undefined;
     }
     async syncSignalSession(jid, reasonIdentity = false) {
         const address = (0, jid_1.parseSignalAddressFromJid)(jid);

package/dist/client/coordinators/WaPrivacyCoordinator.d.ts

@@ -1,4 +1,5 @@
 import { type WaPrivacyDisallowedListSettingName, type WaPrivacySettingName, type WaPrivacySettingValueMap } from '../../protocol/privacy';
+import type { SignalUserJidPair } from '../../signal/api/SignalDeviceSyncApi';
 import type { BinaryNode } from '../../transport/types';
 export type WaPrivacySettings = {
     readonly [K in WaPrivacySettingName]?: WaPrivacySettingValueMap[K];
@@ -36,17 +37,29 @@ export interface WaPrivacyCoordinator {
     /** Returns the current account-wide blocklist. */
     readonly getBlocklist: () => Promise<WaBlocklistResult>;
     /**
-     * Blocks `jid` (account-wide blocklist). After this, the peer can no
-     * longer message/call you and cannot see your last seen/online/photo/
-     * status. The block is symmetric only from the peer's read perspective -
-     * they don't get an explicit "you were blocked" notification.
+     * Blocks a user (account-wide blocklist). Accepts a phone-number jid, a
+     * LID jid, or a bare phone number (digits only). After this, the peer can
+     * no longer
+     * message/call you and cannot see your last seen/online/photo/status. The
+     * block is symmetric only from the peer's read perspective - they don't
+     * get an explicit "you were blocked" notification.
+     *
+     * The server keys blocklist entries by LID for migrated accounts, so a
+     * phone-number input is resolved to its LID first (device-list cache,
+     * then a usync query). Non-migrated accounts fall back to the plain
+     * phone-jid form.
      */
     readonly blockUser: (jid: string) => Promise<void>;
-    /** Removes `jid` from the blocklist. */
+    /**
+     * Removes a user from the blocklist. Accepts the same inputs as
+     * {@link blockUser} and performs the same LID resolution - unblocking a
+     * migrated entry by phone jid is rejected by the server.
+     */
     readonly unblockUser: (jid: string) => Promise<void>;
 }
 interface WaPrivacyCoordinatorOptions {
     readonly queryWithContext: (context: string, node: BinaryNode, timeoutMs?: number, contextData?: Readonly<Record<string, unknown>>) => Promise<BinaryNode>;
+    readonly resolveUserJidPair: (userJid: string) => Promise<SignalUserJidPair>;
 }
 /** Builds a {@link WaPrivacyCoordinator} backed by the given IQ query function. */
 export declare function createPrivacyCoordinator(options: WaPrivacyCoordinatorOptions): WaPrivacyCoordinator;

package/dist/client/coordinators/WaPrivacyCoordinator.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createPrivacyCoordinator = createPrivacyCoordinator;
+const jid_1 = require("../../protocol/jid");
 const nodes_1 = require("../../protocol/nodes");
 const privacy_1 = require("../../protocol/privacy");
 const privacy_2 = require("../../transport/node/builders/privacy");
@@ -88,6 +89,23 @@ function parseBlocklist(result) {
     jids.length = jidsCount;
     return { jids, dhash };
 }
+/**
+ * Resolves a blocklist input into both addressing forms via
+ * `resolveUserJidPair` (device-list cache first, usync fallback for phone
+ * jids). Resolution failures degrade to the single known form instead of
+ * throwing - the server then decides whether that form is acceptable.
+ */
+async function resolveBlocklistTarget(options, jid) {
+    const normalized = (0, jid_1.normalizeRecipientJid)(jid);
+    if (!(0, jid_1.isLidJid)(normalized) && !(0, jid_1.isUserJid)(normalized)) {
+        throw new Error(`blocklist target must be a user jid: ${jid}`);
+    }
+    const pair = await options.resolveUserJidPair(normalized);
+    if (pair.lidJid !== null) {
+        return { lidJid: pair.lidJid, pnJid: pair.pnJid };
+    }
+    return { lidJid: null, pnJid: pair.pnJid ?? normalized };
+}
 /** Builds a {@link WaPrivacyCoordinator} backed by the given IQ query function. */
 function createPrivacyCoordinator(options) {
     const { queryWithContext } = options;
@@ -123,13 +141,20 @@ function createPrivacyCoordinator(options) {
             return parseBlocklist(result);
         },
         blockUser: async (jid) => {
-            const node = (0, privacy_2.buildBlocklistChangeIq)(jid, 'block');
-            const result = await queryWithContext('privacy.blockUser', node, undefined, { jid });
+            const target = await resolveBlocklistTarget(options, jid);
+            const node = (0, privacy_2.buildBlocklistBlockIq)(target);
+            const result = await queryWithContext('privacy.blockUser', node, undefined, {
+                jid: target.lidJid ?? target.pnJid
+            });
             (0, query_1.assertIqResult)(result, 'privacy.blockUser');
         },
         unblockUser: async (jid) => {
-            const node = (0, privacy_2.buildBlocklistChangeIq)(jid, 'unblock');
-            const result = await queryWithContext('privacy.unblockUser', node, undefined, { jid });
+            const target = await resolveBlocklistTarget(options, jid);
+            const unblockJid = target.lidJid ?? target.pnJid;
+            const node = (0, privacy_2.buildBlocklistUnblockIq)(unblockJid);
+            const result = await queryWithContext('privacy.unblockUser', node, undefined, {
+                jid: unblockJid
+            });
             (0, query_1.assertIqResult)(result, 'privacy.unblockUser');
         }
     };

package/dist/esm/client/WaClientFactory.js

@@ -371,7 +371,8 @@ export function buildWaClientDependencies(input) {
         logger
     });
     const privacyCoordinator = createPrivacyCoordinator({
-        queryWithContext: runtime.queryWithContext
+        queryWithContext: runtime.queryWithContext,
+        resolveUserJidPair: (userJid) => signalDeviceSync.resolveUserJidPair(userJid)
     });
     const businessCoordinator = createBusinessCoordinator({
         queryWithContext: runtime.queryWithContext,

package/dist/esm/client/coordinators/WaMessageDispatchCoordinator.js

@@ -297,8 +297,8 @@ export class WaMessageDispatchCoordinator {
     }
     /**
      * For a 1:1 recipient passed in PN form, returns the LID-addressed user JID
-     * (cache-first; falls back to a one-shot `queryLidsByPhoneJids`). Switching
-     * to LID before fanout ensures the envelope, eligible-requester list, and
+     * (via {@link SignalDeviceSyncApi.resolveUserJidPair}). Switching to LID
+     * before fanout ensures the envelope, eligible-requester list, and
      * retry-receipt addressing all agree, which keeps the retry tracker from
      * rejecting receipts that arrive in LID form. Returns the original PN if
      * no LID is known/resolvable. Inputs already in LID form pass through.
@@ -306,26 +306,8 @@ export class WaMessageDispatchCoordinator {
     async resolveDirectRecipientLid(pnUserJid) {
         if (isLidJid(pnUserJid))
             return pnUserJid;
-        const cached = await this.deps.deviceListStore.findByAnyUserJid(pnUserJid);
-        if (cached) {
-            if (isLidJid(cached.userJid))
-                return cached.userJid;
-            if (cached.altUserJid && isLidJid(cached.altUserJid))
-                return cached.altUserJid;
-        }
-        try {
-            const results = await this.deps.signalDeviceSync.queryLidsByPhoneJids([pnUserJid]);
-            const match = results.find((entry) => entry.queriedJid === pnUserJid);
-            if (match?.lidJid)
-                return match.lidJid;
-        }
-        catch (error) {
-            this.deps.logger.debug('lid resolution failed for direct recipient', {
-                pnUserJid,
-                message: toError(error).message
-            });
-        }
-        return pnUserJid;
+        const pair = await this.deps.signalDeviceSync.resolveUserJidPair(pnUserJid);
+        return pair.lidJid ?? pnUserJid;
     }
     /**
      * Resolves the `peer_recipient_pn` cross-reference for a 1:1 send, or
@@ -341,20 +323,8 @@ export class WaMessageDispatchCoordinator {
             return undefined;
         if (isUserJid(recipientUserJid))
             return recipientUserJid;
-        try {
-            const snapshot = await this.deps.deviceListStore.findByAnyUserJid(directRecipientJid);
-            if (snapshot?.userJid && isUserJid(snapshot.userJid))
-                return snapshot.userJid;
-            if (snapshot?.altUserJid && isUserJid(snapshot.altUserJid))
-                return snapshot.altUserJid;
-        }
-        catch (error) {
-            this.deps.logger.trace('peer_recipient_pn store lookup failed', {
-                lid: directRecipientJid,
-                message: toError(error).message
-            });
-        }
-        return undefined;
+        const pair = await this.deps.signalDeviceSync.resolveUserJidPair(directRecipientJid);
+        return pair.pnJid ?? undefined;
     }
     async syncSignalSession(jid, reasonIdentity = false) {
         const address = parseSignalAddressFromJid(jid);

package/dist/esm/client/coordinators/WaPrivacyCoordinator.js

@@ -1,6 +1,7 @@
+import { isLidJid, isUserJid, normalizeRecipientJid } from '../../protocol/jid.js';
 import { WA_NODE_TAGS } from '../../protocol/nodes.js';
 import { WA_PRIVACY_CATEGORY_TO_SETTING, WA_PRIVACY_SETTING_TO_CATEGORY, WA_PRIVACY_TAGS, WA_PRIVACY_VALUES } from '../../protocol/privacy.js';
-import { buildBlocklistChangeIq, buildGetBlocklistIq, buildGetPrivacyDisallowedListIq, buildGetPrivacySettingsIq, buildSetPrivacyCategoryIq } from '../../transport/node/builders/privacy.js';
+import { buildBlocklistBlockIq, buildBlocklistUnblockIq, buildGetBlocklistIq, buildGetPrivacyDisallowedListIq, buildGetPrivacySettingsIq, buildSetPrivacyCategoryIq } from '../../transport/node/builders/privacy.js';
 import { findNodeChild, getNodeChildren, getNodeChildrenByTag } from '../../transport/node/helpers.js';
 import { assertIqResult } from '../../transport/node/query.js';
 const IGNORED_SERVER_CATEGORIES = new Set([
@@ -85,6 +86,23 @@ function parseBlocklist(result) {
     jids.length = jidsCount;
     return { jids, dhash };
 }
+/**
+ * Resolves a blocklist input into both addressing forms via
+ * `resolveUserJidPair` (device-list cache first, usync fallback for phone
+ * jids). Resolution failures degrade to the single known form instead of
+ * throwing - the server then decides whether that form is acceptable.
+ */
+async function resolveBlocklistTarget(options, jid) {
+    const normalized = normalizeRecipientJid(jid);
+    if (!isLidJid(normalized) && !isUserJid(normalized)) {
+        throw new Error(`blocklist target must be a user jid: ${jid}`);
+    }
+    const pair = await options.resolveUserJidPair(normalized);
+    if (pair.lidJid !== null) {
+        return { lidJid: pair.lidJid, pnJid: pair.pnJid };
+    }
+    return { lidJid: null, pnJid: pair.pnJid ?? normalized };
+}
 /** Builds a {@link WaPrivacyCoordinator} backed by the given IQ query function. */
 export function createPrivacyCoordinator(options) {
     const { queryWithContext } = options;
@@ -120,13 +138,20 @@ export function createPrivacyCoordinator(options) {
             return parseBlocklist(result);
         },
         blockUser: async (jid) => {
-            const node = buildBlocklistChangeIq(jid, 'block');
-            const result = await queryWithContext('privacy.blockUser', node, undefined, { jid });
+            const target = await resolveBlocklistTarget(options, jid);
+            const node = buildBlocklistBlockIq(target);
+            const result = await queryWithContext('privacy.blockUser', node, undefined, {
+                jid: target.lidJid ?? target.pnJid
+            });
             assertIqResult(result, 'privacy.blockUser');
         },
         unblockUser: async (jid) => {
-            const node = buildBlocklistChangeIq(jid, 'unblock');
-            const result = await queryWithContext('privacy.unblockUser', node, undefined, { jid });
+            const target = await resolveBlocklistTarget(options, jid);
+            const unblockJid = target.lidJid ?? target.pnJid;
+            const node = buildBlocklistUnblockIq(unblockJid);
+            const result = await queryWithContext('privacy.unblockUser', node, undefined, {
+                jid: unblockJid
+            });
             assertIqResult(result, 'privacy.unblockUser');
         }
     };

package/dist/esm/signal/api/SignalDeviceSyncApi.js

@@ -1,10 +1,11 @@
 import { PromiseDedup } from '../../infra/perf/PromiseDedup.js';
 import { WA_DEFAULTS, WA_NODE_TAGS, WA_USYNC_CONTEXTS } from '../../protocol/constants.js';
-import { buildDeviceJid, isHostedDeviceId, parsePhoneJid, splitJid, toUserJid } from '../../protocol/jid.js';
+import { buildDeviceJid, isHostedDeviceId, isLidJid, isUserJid, parsePhoneJid, splitJid, toUserJid } from '../../protocol/jid.js';
 import { buildUsyncIq, iterateUsyncUsers, parseUsyncResultEnvelope } from '../../transport/node/builders/usync.js';
 import { findNodeChild, getNodeChildrenByTag, getNodeTextContent } from '../../transport/node/helpers.js';
 import { assertIqResult } from '../../transport/node/query.js';
 import { createUsyncSidGenerator, logUsyncProtocolErrors } from '../../transport/node/usync.js';
+import { toError } from '../../util/primitives.js';
 /**
  * Resolves the device list and LID mapping for a set of users via the `usync`
  * protocol. Concurrent calls for the same JIDs are deduplicated.
@@ -139,6 +140,66 @@ export class SignalDeviceSyncApi {
         await this.propagateAltUserJids(result);
         return result;
     }
+    /**
+     * Resolves both addressing forms for a 1:1 user jid (PN or LID input),
+     * cache-first via the device-list store (`userJid`/`altUserJid`) with a
+     * one-shot {@link queryLidsByPhoneJids} fallback for PN inputs. LID
+     * inputs have no reverse lookup - their PN side stays `null` on a cache
+     * miss. Store/usync failures are logged at debug and degrade to the
+     * forms already known. Inputs that are neither PN nor LID user jids
+     * resolve to `{ lidJid: null, pnJid: null }`.
+     */
+    async resolveUserJidPair(userJid, timeoutMs = this.defaultTimeoutMs) {
+        if (isLidJid(userJid)) {
+            return { lidJid: userJid, pnJid: await this.findCachedAltForm(userJid, isUserJid) };
+        }
+        if (!isUserJid(userJid)) {
+            return { lidJid: null, pnJid: null };
+        }
+        const cachedLid = await this.findCachedAltForm(userJid, isLidJid);
+        if (cachedLid) {
+            return { lidJid: cachedLid, pnJid: userJid };
+        }
+        try {
+            const results = await this.queryLidsByPhoneJids([userJid], timeoutMs);
+            const match = results.find((entry) => entry.queriedJid === userJid);
+            if (match?.lidJid) {
+                return { lidJid: match.lidJid, pnJid: match.phoneJid };
+            }
+        }
+        catch (error) {
+            this.logger.debug('lid usync resolution failed for jid pair', {
+                jid: userJid,
+                message: toError(error).message
+            });
+        }
+        return { lidJid: null, pnJid: userJid };
+    }
+    /**
+     * Returns the device-list snapshot form of `userJid` that satisfies
+     * `matches` (checked against `userJid` then `altUserJid`), or `null` when
+     * the store is absent, misses, or fails.
+     */
+    async findCachedAltForm(userJid, matches) {
+        if (!this.deviceListStore)
+            return null;
+        try {
+            const snapshot = await this.deviceListStore.findByAnyUserJid(userJid);
+            if (snapshot) {
+                if (matches(snapshot.userJid))
+                    return snapshot.userJid;
+                if (snapshot.altUserJid && matches(snapshot.altUserJid))
+                    return snapshot.altUserJid;
+            }
+        }
+        catch (error) {
+            this.logger.debug('device-list lookup failed for jid pair', {
+                jid: userJid,
+                message: toError(error).message
+            });
+        }
+        return null;
+    }
     /**
      * Enriches existing device-list snapshots with the resolved LID equivalents
      * so {@link WaDeviceListStore.findByAnyUserJid} can later match a retry

package/dist/esm/store/createStore.js

@@ -34,6 +34,7 @@ import { WaSignalMemoryStore } from './memory/signal.store.js';
 import { WaThreadMemoryStore } from './memory/thread.store.js';
 import { NOOP_CONTACT_STORE, NOOP_DEVICE_LIST_STORE, NOOP_GROUP_METADATA_STORE, NOOP_MESSAGE_SECRET_STORE, NOOP_MESSAGE_STORE, NOOP_RETRY_STORE, NOOP_THREAD_STORE } from './noop.store.js';
 import { resolvePositive } from '../util/coercion.js';
+import { toError } from '../util/primitives.js';
 const DEFAULT_CACHE_TTLS_MS = Object.freeze({
     retryMs: 60 * 1000,
     groupMetadataMs: 5 * 60 * 1000,
@@ -109,6 +110,7 @@ export function createStore(options) {
         messageSecret: resolvePositive(options.memory?.cacheTtlMs?.messageSecretMs, DEFAULT_CACHE_TTLS_MS.messageSecretMs, 'memory.cacheTtlMs.messageSecretMs')
     });
     const sessions = new Map();
+    const pendingSessionDestroys = new Set();
     let storeDestroyed = false;
     return {
         session(sessionId) {
@@ -148,37 +150,48 @@ export function createStore(options) {
                 ? new WaContactMemoryStore({ maxContacts: ml.contacts })
                 : NOOP_CONTACT_STORE);
             const rawPrivacyToken = resolveStore(id, backends, providers.privacyToken ?? 'memory', 'privacyToken', 'stores', () => new WaPrivacyTokenMemoryStore(ml.privacyTokens));
-            const rawRetry = resolveStore(id, backends, cacheProviders.retry ?? 'memory', 'retry', 'caches', () => cacheProviders.retry === 'memory' || !cacheProviders.retry
-                ? new WaRetryMemoryStore(cacheTtlsMs.retry, {
-                    maxOutboundMessages: ml.retryOutboundMessages,
-                    maxInboundCounters: ml.retryInboundCounters,
-                    logger: memoryLogger?.child({ domain: 'retry', sessionId: id })
-                })
-                : NOOP_RETRY_STORE);
-            const rawGroupMetadata = resolveStore(id, backends, cacheProviders.groupMetadata ?? 'memory', 'groupMetadata', 'caches', () => cacheProviders.groupMetadata === 'memory' || !cacheProviders.groupMetadata
-                ? new WaGroupMetadataMemoryStore(cacheTtlsMs.groupMetadata, {
-                    maxGroups: ml.groupMetadataGroups,
-                    logger: memoryLogger?.child({
-                        domain: 'groupMetadata',
-                        sessionId: id
+            const buildCaches = () => ({
+                retry: withRetryLock(resolveStore(id, backends, cacheProviders.retry ?? 'memory', 'retry', 'caches', () => cacheProviders.retry === 'memory' || !cacheProviders.retry
+                    ? new WaRetryMemoryStore(cacheTtlsMs.retry, {
+                        maxOutboundMessages: ml.retryOutboundMessages,
+                        maxInboundCounters: ml.retryInboundCounters,
+                        logger: memoryLogger?.child({
+                            domain: 'retry',
+                            sessionId: id
+                        })
                     })
-                })
-                : NOOP_GROUP_METADATA_STORE);
-            const rawDeviceList = resolveStore(id, backends, cacheProviders.deviceList ?? 'memory', 'deviceList', 'caches', () => cacheProviders.deviceList === 'memory'
-                ? new WaDeviceListMemoryStore(cacheTtlsMs.deviceList, {
-                    maxUsers: ml.deviceListUsers,
-                    logger: memoryLogger?.child({ domain: 'deviceList', sessionId: id })
-                })
-                : NOOP_DEVICE_LIST_STORE);
-            const rawMessageSecret = resolveStore(id, backends, cacheProviders.messageSecret ?? 'memory', 'messageSecret', 'caches', () => cacheProviders.messageSecret === 'memory' || !cacheProviders.messageSecret
-                ? new WaMessageSecretMemoryStore(cacheTtlsMs.messageSecret, {
-                    maxSecrets: ml.messageSecrets,
-                    logger: memoryLogger?.child({
-                        domain: 'messageSecret',
-                        sessionId: id
+                    : NOOP_RETRY_STORE)),
+                groupMetadata: withGroupMetadataLock(resolveStore(id, backends, cacheProviders.groupMetadata ?? 'memory', 'groupMetadata', 'caches', () => cacheProviders.groupMetadata === 'memory' ||
+                    !cacheProviders.groupMetadata
+                    ? new WaGroupMetadataMemoryStore(cacheTtlsMs.groupMetadata, {
+                        maxGroups: ml.groupMetadataGroups,
+                        logger: memoryLogger?.child({
+                            domain: 'groupMetadata',
+                            sessionId: id
+                        })
                     })
-                })
-                : NOOP_MESSAGE_SECRET_STORE);
+                    : NOOP_GROUP_METADATA_STORE)),
+                deviceList: withDeviceListLock(resolveStore(id, backends, cacheProviders.deviceList ?? 'memory', 'deviceList', 'caches', () => cacheProviders.deviceList === 'memory' || !cacheProviders.deviceList
+                    ? new WaDeviceListMemoryStore(cacheTtlsMs.deviceList, {
+                        maxUsers: ml.deviceListUsers,
+                        logger: memoryLogger?.child({
+                            domain: 'deviceList',
+                            sessionId: id
+                        })
+                    })
+                    : NOOP_DEVICE_LIST_STORE)),
+                messageSecret: withMessageSecretLock(resolveStore(id, backends, cacheProviders.messageSecret ?? 'memory', 'messageSecret', 'caches', () => cacheProviders.messageSecret === 'memory' ||
+                    !cacheProviders.messageSecret
+                    ? new WaMessageSecretMemoryStore(cacheTtlsMs.messageSecret, {
+                        maxSecrets: ml.messageSecrets,
+                        logger: memoryLogger?.child({
+                            domain: 'messageSecret',
+                            sessionId: id
+                        })
+                    })
+                    : NOOP_MESSAGE_SECRET_STORE))
+            });
+            let caches = buildCaches();
             const authStore = withAuthLock(rawAuth);
             const signalStore = withSignalLock(rawSignal);
             const preKeyStore = withPreKeyLock(rawPreKey);
@@ -192,41 +205,72 @@ export function createStore(options) {
                 ? withSenderKeyCache(rawSenderKey, cacheLayer.limits?.senderKey)
                 : rawSenderKey);
             const appStateStore = withAppStateLock(rawAppState);
-            const retryStore = withRetryLock(rawRetry);
-            const groupMetadataStore = withGroupMetadataLock(rawGroupMetadata);
-            const deviceListStore = withDeviceListLock(rawDeviceList);
             const messageStore = withMessageLock(rawMessages);
-            const messageSecretStore = withMessageSecretLock(rawMessageSecret);
             const threadStore = withThreadLock(rawThreads);
             const contactStore = withContactLock(rawContacts);
             const privacyTokenStore = withPrivacyTokenLock(cacheLayer.privacyToken && usesBackend(providers.privacyToken)
                 ? withPrivacyTokenCache(rawPrivacyToken, cacheLayer.limits?.privacyToken)
                 : rawPrivacyToken);
-            let cachesDestroyed = false;
             let sessionDestroyed = false;
-            const destroyCaches = async () => {
-                if (cachesDestroyed)
-                    return;
-                cachesDestroyed = true;
-                await Promise.all([
-                    retryStore.clear(),
-                    groupMetadataStore.clear(),
-                    deviceListStore.clear(),
-                    messageSecretStore.clear()
+            let destroyPromise = null;
+            let cacheLifecycle = Promise.resolve();
+            const teardownCaches = async (target) => {
+                const cleared = await Promise.allSettled([
+                    target.retry.clear(),
+                    target.groupMetadata.clear(),
+                    target.deviceList.clear(),
+                    target.messageSecret.clear()
                 ]);
-                await Promise.all([
-                    destroyIfSupported(retryStore),
-                    destroyIfSupported(groupMetadataStore),
-                    destroyIfSupported(deviceListStore),
-                    destroyIfSupported(messageSecretStore)
+                const destroyed = await Promise.allSettled([
+                    destroyIfSupported(target.retry),
+                    destroyIfSupported(target.groupMetadata),
+                    destroyIfSupported(target.deviceList),
+                    destroyIfSupported(target.messageSecret)
                 ]);
+                const failures = [...cleared, ...destroyed].filter((result) => result.status === 'rejected');
+                if (failures.length > 0) {
+                    storeLogger?.warn('cache teardown had failures', {
+                        sessionId: id,
+                        droppedCount: failures.length,
+                        totalExpected: cleared.length + destroyed.length,
+                        sample: toError(failures[0].reason).message
+                    });
+                }
+                return failures.length;
+            };
+            const destroyCaches = () => {
+                const run = cacheLifecycle.then(async () => {
+                    if (sessionDestroyed)
+                        return;
+                    const failureCount = await teardownCaches(caches);
+                    caches = buildCaches();
+                    if (failureCount > 0) {
+                        throw new Error(`cache reset finished with ${failureCount} teardown failure(s); ` +
+                            'fresh caches are in place but old persistent entries may remain');
+                    }
+                });
+                cacheLifecycle = run.then(() => undefined, () => undefined);
+                return run;
             };
-            const destroy = async () => {
-                if (sessionDestroyed)
-                    return;
+            const destroy = () => {
+                if (!destroyPromise) {
+                    const pending = destroyInternal().finally(() => pendingSessionDestroys.delete(pending));
+                    destroyPromise = pending;
+                    pendingSessionDestroys.add(pending);
+                }
+                return destroyPromise;
+            };
+            const destroyInternal = async () => {
                 sessionDestroyed = true;
-                await destroyCaches();
-                await Promise.all([
+                if (sessions.get(id) === storeSession) {
+                    sessions.delete(id);
+                }
+                await cacheLifecycle;
+                await teardownCaches(caches);
+                await destroyPersistentStores();
+            };
+            const destroyPersistentStores = async () => {
+                const results = await Promise.allSettled([
                     destroyIfSupported(authStore),
                     destroyIfSupported(signalStore),
                     destroyIfSupported(preKeyStore),
@@ -239,6 +283,15 @@ export function createStore(options) {
                     destroyIfSupported(contactStore),
                     destroyIfSupported(privacyTokenStore)
                 ]);
+                const failures = results.filter((result) => result.status === 'rejected');
+                if (failures.length > 0) {
+                    storeLogger?.warn('persistent store teardown had failures', {
+                        sessionId: id,
+                        droppedCount: failures.length,
+                        totalExpected: results.length,
+                        sample: toError(failures[0].reason).message
+                    });
+                }
             };
             const storeSession = {
                 auth: authStore,
@@ -248,11 +301,19 @@ export function createStore(options) {
                 identity: identityStore,
                 senderKey: senderKeyStore,
                 appState: appStateStore,
-                retry: retryStore,
-                groupMetadata: groupMetadataStore,
-                deviceList: deviceListStore,
+                get retry() {
+                    return caches.retry;
+                },
+                get groupMetadata() {
+                    return caches.groupMetadata;
+                },
+                get deviceList() {
+                    return caches.deviceList;
+                },
                 messages: messageStore,
-                messageSecret: messageSecretStore,
+                get messageSecret() {
+                    return caches.messageSecret;
+                },
                 threads: threadStore,
                 contacts: contactStore,
                 privacyToken: privacyTokenStore,
@@ -273,6 +334,7 @@ export function createStore(options) {
             const list = Array.from(sessions.values());
             sessions.clear();
             await Promise.all(list.map((s) => s.destroy()));
+            await Promise.all(Array.from(pendingSessionDestroys));
             const uniqueBackends = new Set(Object.values(backends));
             await Promise.all(Array.from(uniqueBackends, (backend) => destroyIfSupported(backend)));
         }