zapo-js 1.8.2 → 1.10.0

package/dist/esm/util/collections.js

@@ -24,6 +24,100 @@ export function normalizeQueryLimit(limit, defaultLimit) {
     }
     return limit;
 }
+/**
+ * Sweep period shared by a set of idle TTLs: the smallest `ttlMs / 2`,
+ * clamped to [1 s, 60 s].
+ */
+export function resolveIdleSweepPeriodMs(ttlsMs) {
+    let periodMs = 60000;
+    for (let i = 0; i < ttlsMs.length; i += 1) {
+        periodMs = Math.min(periodMs, Math.max(1000, Math.floor(ttlsMs[i] / 2)));
+    }
+    return periodMs;
+}
+/**
+ * Coarse clock for idle expiry: one `unref`'d interval bumps `tick` and runs
+ * every registered sweep, and only while a sweep is registered. Wall-clock
+ * steps never move `tick`.
+ */
+export class IdleSweepClock {
+    constructor(periodMs) {
+        this.advance = () => {
+            this.currentTick += 1;
+            for (const sweep of this.sweeps)
+                sweep(this.currentTick);
+        };
+        this.periodMs = periodMs;
+        this.currentTick = 0;
+        this.sweeps = new Set();
+        this.timer = null;
+    }
+    get tick() {
+        return this.currentTick;
+    }
+    /** Runs `sweep` on every tick until the returned function is called. */
+    register(sweep) {
+        this.sweeps.add(sweep);
+        if (this.timer === null) {
+            this.timer = setInterval(this.advance, this.periodMs);
+            this.timer.unref?.();
+        }
+        return () => {
+            this.sweeps.delete(sweep);
+            if (this.sweeps.size > 0 || this.timer === null)
+                return;
+            clearInterval(this.timer);
+            this.timer = null;
+        };
+    }
+}
+/**
+ * Idle expiry and LRU order for the entries of `data`. A touch moves the key
+ * to the young end of the index and of `data`, at most once per tick, so the
+ * sweep stops at the first live key and `data` iterates least recently used
+ * first. A key expires after `ceil(ttlMs / periodMs) + 1` untouched ticks:
+ * idle for at least `ttlMs` and, timer lateness aside, under `ttlMs + 2 * periodMs`.
+ */
+export class IdleExpiryIndex {
+    constructor(data, expiry) {
+        this.sweep = (tick) => {
+            const cutoff = tick - this.idleTicks;
+            for (const [key, touchedAt] of this.touchedAt) {
+                if (touchedAt > cutoff)
+                    return;
+                this.touchedAt.delete(key);
+                this.data.delete(key);
+            }
+        };
+        this.data = data;
+        this.clock = expiry.clock;
+        this.idleTicks = Math.ceil(expiry.ttlMs / expiry.clock.periodMs) + 1;
+        this.touchedAt = new Map();
+        this.unregister = expiry.clock.register(this.sweep);
+    }
+    touch(key) {
+        const tick = this.clock.tick;
+        if (this.touchedAt.get(key) === tick)
+            return;
+        this.touchedAt.delete(key);
+        this.touchedAt.set(key, tick);
+        const value = this.data.get(key);
+        if (value === undefined)
+            return;
+        this.data.delete(key);
+        this.data.set(key, value);
+    }
+    delete(key) {
+        this.touchedAt.delete(key);
+    }
+    clear() {
+        this.touchedAt.clear();
+    }
+    /** Stops sweeping; the entries stay until the owner clears them. */
+    detach() {
+        this.unregister();
+    }
+}
 export function setBoundedMapEntry(map, key, value, maxEntries, onEvict) {
     map.delete(key);
     map.set(key, value);

package/dist/esm/util/index.js

@@ -1,6 +1,6 @@
 export { delay } from './async.js';
 export { base64ToBytes, bytesToBase64, bytesToBase64UrlSafe, bytesToHex, concatBytes, decodeBase64Url, EMPTY_BYTES, hexToBytes, TEXT_DECODER, TEXT_ENCODER, toBytesView, uint8Equal, uint8TimingSafeEqual } from './bytes.js';
-export { asBytes, asNumber, asOptionalBytes, asOptionalNumber, asOptionalString, asString, resolveOptionalPositive, resolvePositive, toBoolOrUndef } from './coercion.js';
-export { normalizeQueryLimit } from './collections.js';
+export { asBytes, asNumber, asOptionalBytes, asOptionalNumber, asOptionalString, asString, resolveOptionalPositive, resolvePositive, toBoolOrUndef, tryAsNumber } from './coercion.js';
+export { normalizeQueryLimit, setBoundedMapEntry } from './collections.js';
 export { toError, toSafeNumber } from './primitives.js';
 export { isBunRuntime } from './runtime.js';

package/dist/message/encode/content.js

@@ -180,7 +180,8 @@ function unwrapMessage(message) {
             msg.viewOnceMessageV2?.message ??
             msg.documentWithCaptionMessage?.message ??
             msg.groupStatusMessage?.message ??
-            msg.groupStatusMessageV2?.message;
+            msg.groupStatusMessageV2?.message ??
+            msg.botForwardedMessage?.message;
         if (!inner)
             return msg;
         msg = inner;
@@ -228,6 +229,8 @@ function resolveMessageTypeAttrFrom(msg) {
         msg.pollResultSnapshotMessageV3 ||
         msg.templateButtonReplyMessage ||
         msg.messageHistoryNotice ||
+        msg.richResponseMessage ||
+        msg.botForwardedMessage ||
         msg.secretEncryptedMessage?.secretEncType ===
             _proto_1.proto.Message.SecretEncryptedMessage.SecretEncType.MESSAGE_EDIT ||
         msg.secretEncryptedMessage?.secretEncType ===

package/dist/message/primitives/media-retry.d.ts

@@ -2,6 +2,17 @@ import type { WaAuthCredentials } from '../../auth/types';
 import type { Logger } from '../../infra/log/types';
 import type { BinaryNode } from '../../transport/types';
 export type WaMediaRetryResultType = 'success' | 'not_found' | 'decryption_error' | 'general_error';
+/**
+ * Answer to a media reupload request.
+ *
+ * On `result: 'success'` the fresh `directPath` usually points at the same
+ * ciphertext the original message described, so its media key, hashes and
+ * length stay valid. Some primaries re-encrypt the file on every re-upload
+ * instead: the answer is still `success`, but the re-served blob no longer
+ * matches `fileEncSha256` and decryption fails with a MAC mismatch. Nothing in
+ * the round-trip carries key material for the new ciphertext, so treat that
+ * message as unrecoverable rather than retrying.
+ */
 export interface WaMediaRetryResult {
     readonly messageId: string;
     readonly result: WaMediaRetryResultType;

package/dist/store/cache/identity.cache.d.ts

@@ -1,15 +1,17 @@
 import type { WaIdentityStore } from '../contracts/identity.store';
 import type { WithDestroyLifecycle } from '../types';
+import { type IdleExpiry } from '../../util/collections';
 /**
  * Read-through / write-through in-process cache for a persistent remote
- * identity backend. Reuses {@link WaIdentityMemoryStore} as the bounded-LRU
- * L1. Remote identities are read alongside sessions on the send path (the
+ * identity backend. Reuses {@link WaIdentityMemoryStore} as the bounded L1.
+ * Remote identities are read alongside sessions on the send path (the
  * identity-mismatch guard), so caching them complements
- * {@link withSessionCache}.
+ * {@link withSessionCache}, which also describes the eviction with and
+ * without `expiry`.
  *
  * The identity store has no per-key delete: identities are overwritten on
  * re-establishment, so a peer's key change propagates through the
  * write-through `setRemoteIdentity`. See {@link withSessionCache} for the
  * shared coherence model and the single-writer-per-session assumption.
  */
-export declare function withIdentityCache(backend: WaIdentityStore, maxEntries?: number): WithDestroyLifecycle<WaIdentityStore>;
+export declare function withIdentityCache(backend: WaIdentityStore, maxEntries?: number, expiry?: IdleExpiry): WithDestroyLifecycle<WaIdentityStore>;

package/dist/store/cache/identity.cache.js

@@ -2,20 +2,43 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.withIdentityCache = withIdentityCache;
 const identity_store_1 = require("../memory/identity.store");
+const collections_1 = require("../../util/collections");
+/** L1 with idle expiry; hits keep it in access order, so the cap evicts the LRU entry. */
+class IdleIdentityMemoryStore extends identity_store_1.WaIdentityMemoryStore {
+    constructor(maxRemoteIdentities, expiry) {
+        super({ maxRemoteIdentities });
+        this.idle = new collections_1.IdleExpiryIndex(this.remoteIdentities, expiry);
+    }
+    detach() {
+        this.idle.detach();
+    }
+    onEntryAccess(key) {
+        this.idle.touch(key);
+    }
+    onEntryRemove(key) {
+        this.idle.delete(key);
+    }
+    onEntriesClear() {
+        this.idle.clear();
+    }
+}
 /**
  * Read-through / write-through in-process cache for a persistent remote
- * identity backend. Reuses {@link WaIdentityMemoryStore} as the bounded-LRU
- * L1. Remote identities are read alongside sessions on the send path (the
+ * identity backend. Reuses {@link WaIdentityMemoryStore} as the bounded L1.
+ * Remote identities are read alongside sessions on the send path (the
  * identity-mismatch guard), so caching them complements
- * {@link withSessionCache}.
+ * {@link withSessionCache}, which also describes the eviction with and
+ * without `expiry`.
  *
  * The identity store has no per-key delete: identities are overwritten on
  * re-establishment, so a peer's key change propagates through the
  * write-through `setRemoteIdentity`. See {@link withSessionCache} for the
  * shared coherence model and the single-writer-per-session assumption.
  */
-function withIdentityCache(backend, maxEntries) {
-    const l1 = new identity_store_1.WaIdentityMemoryStore({ maxRemoteIdentities: maxEntries });
+function withIdentityCache(backend, maxEntries, expiry) {
+    const l1 = expiry
+        ? new IdleIdentityMemoryStore(maxEntries, expiry)
+        : new identity_store_1.WaIdentityMemoryStore({ maxRemoteIdentities: maxEntries });
     let generation = 0;
     return {
         getRemoteIdentity: async (address) => {
@@ -71,6 +94,8 @@ function withIdentityCache(backend, maxEntries) {
             await l1.clear();
         },
         destroy: async () => {
+            if (l1 instanceof IdleIdentityMemoryStore)
+                l1.detach();
             await l1.clear();
             await backend.destroy?.();
         }

package/dist/store/cache/privacy-token.cache.d.ts

@@ -1,15 +1,17 @@
 import type { WaPrivacyTokenStore } from '../contracts/privacy-token.store';
 import type { WithDestroyLifecycle } from '../types';
+import { type IdleExpiry } from '../../util/collections';
 /**
  * Read-through cache for a persistent privacy-token backend. Reuses
- * {@link WaPrivacyTokenMemoryStore} as the bounded-LRU L1.
+ * {@link WaPrivacyTokenMemoryStore} as the bounded L1.
  *
  * Unlike the signal caches this is **invalidate-on-write, not
  * write-through**: `upsert` merges partial fields into the existing row on
  * the backend, so caching the partial incoming record would diverge from the
  * backend's merged result. Instead each upsert drops the L1 entry and the
  * next read re-populates from the merged backend truth. See
- * {@link withSessionCache} for the shared coherence model and the
- * single-writer-per-session assumption.
+ * {@link withSessionCache} for the shared coherence model, the
+ * single-writer-per-session assumption and the eviction with and without
+ * `expiry`.
  */
-export declare function withPrivacyTokenCache(backend: WaPrivacyTokenStore, maxEntries?: number): WithDestroyLifecycle<WaPrivacyTokenStore>;
+export declare function withPrivacyTokenCache(backend: WaPrivacyTokenStore, maxEntries?: number, expiry?: IdleExpiry): WithDestroyLifecycle<WaPrivacyTokenStore>;

package/dist/store/cache/privacy-token.cache.js

@@ -2,20 +2,43 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.withPrivacyTokenCache = withPrivacyTokenCache;
 const privacy_token_store_1 = require("../memory/privacy-token.store");
+const collections_1 = require("../../util/collections");
+/** L1 with idle expiry; hits keep it in access order, so the cap evicts the LRU entry. */
+class IdlePrivacyTokenMemoryStore extends privacy_token_store_1.WaPrivacyTokenMemoryStore {
+    constructor(maxEntries, expiry) {
+        super(maxEntries);
+        this.idle = new collections_1.IdleExpiryIndex(this.records, expiry);
+    }
+    detach() {
+        this.idle.detach();
+    }
+    onEntryAccess(jid) {
+        this.idle.touch(jid);
+    }
+    onEntryRemove(jid) {
+        this.idle.delete(jid);
+    }
+    onEntriesClear() {
+        this.idle.clear();
+    }
+}
 /**
  * Read-through cache for a persistent privacy-token backend. Reuses
- * {@link WaPrivacyTokenMemoryStore} as the bounded-LRU L1.
+ * {@link WaPrivacyTokenMemoryStore} as the bounded L1.
  *
  * Unlike the signal caches this is **invalidate-on-write, not
  * write-through**: `upsert` merges partial fields into the existing row on
  * the backend, so caching the partial incoming record would diverge from the
  * backend's merged result. Instead each upsert drops the L1 entry and the
  * next read re-populates from the merged backend truth. See
- * {@link withSessionCache} for the shared coherence model and the
- * single-writer-per-session assumption.
+ * {@link withSessionCache} for the shared coherence model, the
+ * single-writer-per-session assumption and the eviction with and without
+ * `expiry`.
  */
-function withPrivacyTokenCache(backend, maxEntries) {
-    const l1 = new privacy_token_store_1.WaPrivacyTokenMemoryStore(maxEntries);
+function withPrivacyTokenCache(backend, maxEntries, expiry) {
+    const l1 = expiry
+        ? new IdlePrivacyTokenMemoryStore(maxEntries, expiry)
+        : new privacy_token_store_1.WaPrivacyTokenMemoryStore(maxEntries);
     let generation = 0;
     return {
         upsert: async (record) => {
@@ -53,6 +76,8 @@ function withPrivacyTokenCache(backend, maxEntries) {
             await l1.clear();
         },
         destroy: async () => {
+            if (l1 instanceof IdlePrivacyTokenMemoryStore)
+                l1.detach();
             await l1.clear();
             await backend.destroy?.();
         }

package/dist/store/cache/sender-key.cache.d.ts

@@ -1,8 +1,9 @@
 import type { WaSenderKeyStore } from '../contracts/sender-key.store';
 import type { WithDestroyLifecycle } from '../types';
+import { type IdleExpiry } from '../../util/collections';
 /**
  * Read-through / write-through in-process cache for a persistent sender-key
- * backend. Reuses {@link SenderKeyMemoryStore} as the bounded-LRU L1 so the
+ * backend. Reuses {@link SenderKeyMemoryStore} as the bounded L1 so the
  * per-(group, sender) lookups repeated across a group fan-out skip the
  * backend round-trip.
  *
@@ -13,6 +14,7 @@ import type { WithDestroyLifecycle } from '../types';
  * (`deleteDeviceSenderKey`/`markForgetSenderKey`) run on the backend for the
  * authoritative count and then invalidate the matching L1 entries via the
  * memory store's own sweep. See {@link withSessionCache} for the shared
- * coherence model and the single-writer-per-session assumption.
+ * coherence model, the single-writer-per-session assumption and the eviction
+ * with and without `expiry`.
  */
-export declare function withSenderKeyCache(backend: WaSenderKeyStore, maxEntries?: number): WithDestroyLifecycle<WaSenderKeyStore>;
+export declare function withSenderKeyCache(backend: WaSenderKeyStore, maxEntries?: number, expiry?: IdleExpiry): WithDestroyLifecycle<WaSenderKeyStore>;

package/dist/store/cache/sender-key.cache.js

@@ -2,9 +2,35 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.withSenderKeyCache = withSenderKeyCache;
 const sender_key_store_1 = require("../memory/sender-key.store");
+const collections_1 = require("../../util/collections");
+/** L1 with idle expiry; hits keep both maps in access order, so the caps evict LRU entries. */
+class IdleSenderKeyMemoryStore extends sender_key_store_1.SenderKeyMemoryStore {
+    constructor(maxEntries, expiry) {
+        super({ maxSenderKeys: maxEntries, maxSenderDistributions: maxEntries });
+        this.idleSenderKeys = new collections_1.IdleExpiryIndex(this.senderKeys, expiry);
+        this.idleDistributions = new collections_1.IdleExpiryIndex(this.senderDistributions, expiry);
+    }
+    detach() {
+        this.idleSenderKeys.detach();
+        this.idleDistributions.detach();
+    }
+    onEntryAccess(entries, key) {
+        this.indexFor(entries).touch(key);
+    }
+    onEntryRemove(entries, key) {
+        this.indexFor(entries).delete(key);
+    }
+    onEntriesClear() {
+        this.idleSenderKeys.clear();
+        this.idleDistributions.clear();
+    }
+    indexFor(entries) {
+        return entries === this.senderKeys ? this.idleSenderKeys : this.idleDistributions;
+    }
+}
 /**
  * Read-through / write-through in-process cache for a persistent sender-key
- * backend. Reuses {@link SenderKeyMemoryStore} as the bounded-LRU L1 so the
+ * backend. Reuses {@link SenderKeyMemoryStore} as the bounded L1 so the
  * per-(group, sender) lookups repeated across a group fan-out skip the
  * backend round-trip.
  *
@@ -15,13 +41,16 @@ const sender_key_store_1 = require("../memory/sender-key.store");
  * (`deleteDeviceSenderKey`/`markForgetSenderKey`) run on the backend for the
  * authoritative count and then invalidate the matching L1 entries via the
  * memory store's own sweep. See {@link withSessionCache} for the shared
- * coherence model and the single-writer-per-session assumption.
+ * coherence model, the single-writer-per-session assumption and the eviction
+ * with and without `expiry`.
  */
-function withSenderKeyCache(backend, maxEntries) {
-    const l1 = new sender_key_store_1.SenderKeyMemoryStore({
-        maxSenderKeys: maxEntries,
-        maxSenderDistributions: maxEntries
-    });
+function withSenderKeyCache(backend, maxEntries, expiry) {
+    const l1 = expiry
+        ? new IdleSenderKeyMemoryStore(maxEntries, expiry)
+        : new sender_key_store_1.SenderKeyMemoryStore({
+            maxSenderKeys: maxEntries,
+            maxSenderDistributions: maxEntries
+        });
     let generation = 0;
     return {
         upsertSenderKey: async (record) => {
@@ -97,6 +126,8 @@ function withSenderKeyCache(backend, maxEntries) {
             await l1.clear();
         },
         destroy: async () => {
+            if (l1 instanceof IdleSenderKeyMemoryStore)
+                l1.detach();
             await l1.clear();
             await backend.destroy?.();
         }

package/dist/store/cache/session.cache.d.ts

@@ -1,10 +1,13 @@
 import type { WaSessionStore } from '../contracts/session.store';
 import type { WithDestroyLifecycle } from '../types';
+import { type IdleExpiry } from '../../util/collections';
 /**
  * Read-through / write-through in-process cache for a persistent session
- * backend. Reuses {@link WaSessionMemoryStore} as the bounded-LRU L1 so that
+ * backend. Reuses {@link WaSessionMemoryStore} as the bounded L1 so that
  * repeated reads of the same peer on the send/recv path skip the backend
- * round-trip.
+ * round-trip. Without `expiry` the cap evicts the least recently written
+ * entry; with it, the least recently used, and entries idle past the TTL
+ * leave the L1 (never the backend) and are re-read on next use.
  *
  * Coherence model (single process):
  * - every mutation (set/delete/clear) writes the backend then the L1 in
@@ -20,4 +23,4 @@ import type { WithDestroyLifecycle } from '../types';
  * session with the cache enabled - there is no cross-process invalidation
  * channel, so another process's writes would leave this L1 stale.
  */
-export declare function withSessionCache(backend: WaSessionStore, maxEntries?: number): WithDestroyLifecycle<WaSessionStore>;
+export declare function withSessionCache(backend: WaSessionStore, maxEntries?: number, expiry?: IdleExpiry): WithDestroyLifecycle<WaSessionStore>;

package/dist/store/cache/session.cache.js

@@ -2,11 +2,33 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.withSessionCache = withSessionCache;
 const session_store_1 = require("../memory/session.store");
+const collections_1 = require("../../util/collections");
+/** L1 with idle expiry; hits keep it in access order, so the cap evicts the LRU entry. */
+class IdleSessionMemoryStore extends session_store_1.WaSessionMemoryStore {
+    constructor(maxSessions, expiry) {
+        super({ maxSessions });
+        this.idle = new collections_1.IdleExpiryIndex(this.signalSessions, expiry);
+    }
+    detach() {
+        this.idle.detach();
+    }
+    onEntryAccess(key) {
+        this.idle.touch(key);
+    }
+    onEntryRemove(key) {
+        this.idle.delete(key);
+    }
+    onEntriesClear() {
+        this.idle.clear();
+    }
+}
 /**
  * Read-through / write-through in-process cache for a persistent session
- * backend. Reuses {@link WaSessionMemoryStore} as the bounded-LRU L1 so that
+ * backend. Reuses {@link WaSessionMemoryStore} as the bounded L1 so that
  * repeated reads of the same peer on the send/recv path skip the backend
- * round-trip.
+ * round-trip. Without `expiry` the cap evicts the least recently written
+ * entry; with it, the least recently used, and entries idle past the TTL
+ * leave the L1 (never the backend) and are re-read on next use.
  *
  * Coherence model (single process):
  * - every mutation (set/delete/clear) writes the backend then the L1 in
@@ -22,8 +44,10 @@ const session_store_1 = require("../memory/session.store");
  * session with the cache enabled - there is no cross-process invalidation
  * channel, so another process's writes would leave this L1 stale.
  */
-function withSessionCache(backend, maxEntries) {
-    const l1 = new session_store_1.WaSessionMemoryStore({ maxSessions: maxEntries });
+function withSessionCache(backend, maxEntries, expiry) {
+    const l1 = expiry
+        ? new IdleSessionMemoryStore(maxEntries, expiry)
+        : new session_store_1.WaSessionMemoryStore({ maxSessions: maxEntries });
     let generation = 0;
     return {
         hasSession: async (address) => {
@@ -88,6 +112,8 @@ function withSessionCache(backend, maxEntries) {
             await l1.clear();
         },
         destroy: async () => {
+            if (l1 instanceof IdleSessionMemoryStore)
+                l1.detach();
             await l1.clear();
             await backend.destroy?.();
         }

package/dist/store/createStore.js

@@ -38,6 +38,7 @@ const signal_store_1 = require("./memory/signal.store");
 const thread_store_1 = require("./memory/thread.store");
 const noop_store_1 = require("./noop.store");
 const coercion_1 = require("../util/coercion");
+const collections_1 = require("../util/collections");
 const primitives_1 = require("../util/primitives");
 const DEFAULT_CACHE_TTLS_MS = Object.freeze({
     retryMs: 60 * 1000,
@@ -59,6 +60,8 @@ const REQUIRED_PROVIDER_DOMAINS = [
     'contacts',
     'privacyToken'
 ];
+const CACHE_LAYER_DOMAINS = ['session', 'identity', 'senderKey', 'privacyToken'];
+const MIN_CACHE_LAYER_TTL_MS = 1000;
 function hasDestroy(value) {
     return (!!value &&
         typeof value === 'object' &&
@@ -73,6 +76,37 @@ async function destroyIfSupported(value) {
 function usesBackend(provider) {
     return !!provider && provider !== 'memory' && provider !== 'none';
 }
+/**
+ * Validates `cacheLayer.ttlMs` and hands each domain that gets an L1 its idle
+ * expiry, all on one clock. A TTL on a domain without an L1 is warned and dropped.
+ */
+function resolveCacheLayerExpiry(cacheLayer, providers, logger) {
+    const ttls = [];
+    for (const domain of CACHE_LAYER_DOMAINS) {
+        const ttlMs = cacheLayer.ttlMs?.[`${domain}Ms`];
+        if (ttlMs === undefined)
+            continue;
+        if (!Number.isSafeInteger(ttlMs) || ttlMs < MIN_CACHE_LAYER_TTL_MS) {
+            throw new Error(`cacheLayer.ttlMs.${domain}Ms must be a safe integer >= ${MIN_CACHE_LAYER_TTL_MS}`);
+        }
+        if (cacheLayer[domain] && usesBackend(providers[domain])) {
+            ttls.push({ domain, ttlMs });
+            continue;
+        }
+        logger?.warn('cacheLayer ttl ignored: domain has no L1', {
+            domain,
+            cached: cacheLayer[domain] === true,
+            provider: providers[domain] ?? 'memory'
+        });
+    }
+    const expiry = {};
+    if (ttls.length === 0)
+        return expiry;
+    const clock = new collections_1.IdleSweepClock((0, collections_1.resolveIdleSweepPeriodMs)(ttls.map((entry) => entry.ttlMs)));
+    for (const { domain, ttlMs } of ttls)
+        expiry[domain] = { clock, ttlMs };
+    return expiry;
+}
 function resolveStore(sessionId, backends, provider, domain, kind, fallback) {
     if (!provider || provider === 'memory' || provider === 'none') {
         return fallback();
@@ -115,6 +149,7 @@ function createStore(options) {
         deviceList: (0, coercion_1.resolvePositive)(options.memory?.cacheTtlMs?.deviceListMs, DEFAULT_CACHE_TTLS_MS.deviceListMs, 'memory.cacheTtlMs.deviceListMs'),
         messageSecret: (0, coercion_1.resolvePositive)(options.memory?.cacheTtlMs?.messageSecretMs, DEFAULT_CACHE_TTLS_MS.messageSecretMs, 'memory.cacheTtlMs.messageSecretMs')
     });
+    const cacheLayerExpiry = resolveCacheLayerExpiry(cacheLayer, providers, storeLogger);
     const sessions = new Map();
     const pendingSessionDestroys = new Set();
     let storeDestroyed = false;
@@ -211,20 +246,20 @@ function createStore(options) {
             const signalStore = (0, signal_lock_1.withSignalLock)(rawSignal);
             const preKeyStore = (0, pre_key_lock_1.withPreKeyLock)(rawPreKey);
             const sessionStore = (0, session_lock_1.withSessionLock)(cacheLayer.session && usesBackend(providers.session)
-                ? (0, session_cache_1.withSessionCache)(rawSession, cacheLayer.limits?.session)
+                ? (0, session_cache_1.withSessionCache)(rawSession, cacheLayer.limits?.session, cacheLayerExpiry.session)
                 : rawSession);
             const identityStore = (0, identity_lock_1.withIdentityLock)(cacheLayer.identity && usesBackend(providers.identity)
-                ? (0, identity_cache_1.withIdentityCache)(rawIdentity, cacheLayer.limits?.identity)
+                ? (0, identity_cache_1.withIdentityCache)(rawIdentity, cacheLayer.limits?.identity, cacheLayerExpiry.identity)
                 : rawIdentity);
             const senderKeyStore = (0, sender_key_lock_1.withSenderKeyLock)(cacheLayer.senderKey && usesBackend(providers.senderKey)
-                ? (0, sender_key_cache_1.withSenderKeyCache)(rawSenderKey, cacheLayer.limits?.senderKey)
+                ? (0, sender_key_cache_1.withSenderKeyCache)(rawSenderKey, cacheLayer.limits?.senderKey, cacheLayerExpiry.senderKey)
                 : rawSenderKey);
             const appStateStore = (0, appstate_lock_1.withAppStateLock)(rawAppState);
             const messageStore = (0, message_lock_1.withMessageLock)(rawMessages);
             const threadStore = (0, thread_lock_1.withThreadLock)(rawThreads);
             const contactStore = (0, contact_lock_1.withContactLock)(rawContacts);
             const privacyTokenStore = (0, privacy_token_lock_1.withPrivacyTokenLock)(cacheLayer.privacyToken && usesBackend(providers.privacyToken)
-                ? (0, privacy_token_cache_1.withPrivacyTokenCache)(rawPrivacyToken, cacheLayer.limits?.privacyToken)
+                ? (0, privacy_token_cache_1.withPrivacyTokenCache)(rawPrivacyToken, cacheLayer.limits?.privacyToken, cacheLayerExpiry.privacyToken)
                 : rawPrivacyToken);
             let sessionDestroyed = false;
             let destroyPromise = null;

package/dist/store/memory/identity.store.d.ts

@@ -4,7 +4,7 @@ export interface WaIdentityMemoryStoreOptions {
     readonly maxRemoteIdentities?: number;
 }
 export declare class WaIdentityMemoryStore implements WaIdentityStoreContract {
-    private readonly remoteIdentities;
+    protected readonly remoteIdentities: Map<string, Uint8Array>;
     private readonly maxRemoteIdentities;
     constructor(options?: WaIdentityMemoryStoreOptions);
     getRemoteIdentity(address: SignalAddress): Promise<Uint8Array | null>;
@@ -15,4 +15,10 @@ export declare class WaIdentityMemoryStore implements WaIdentityStoreContract {
         readonly identityKey: Uint8Array;
     }[]): Promise<void>;
     clear(): Promise<void>;
+    /** Runs with the key of every read hit and write. No-op unless a subclass tracks access. */
+    protected onEntryAccess(key: string): void;
+    /** Runs with the key of every cap-evicted entry. */
+    protected onEntryRemove(key: string): void;
+    protected onEntriesClear(): void;
+    private readonly onEvict;
 }

package/dist/store/memory/identity.store.js

@@ -7,29 +7,53 @@ const collections_1 = require("../../util/collections");
 const DEFAULT_MAX_REMOTE_IDENTITIES = 8192;
 class WaIdentityMemoryStore {
     constructor(options = {}) {
+        this.onEvict = (key) => this.onEntryRemove(key);
         this.remoteIdentities = new Map();
         this.maxRemoteIdentities = (0, coercion_1.resolvePositive)(options.maxRemoteIdentities, DEFAULT_MAX_REMOTE_IDENTITIES, 'WaIdentityMemoryStoreOptions.maxRemoteIdentities');
     }
     async getRemoteIdentity(address) {
-        return this.remoteIdentities.get((0, jid_1.signalAddressKey)(address)) ?? null;
+        const key = (0, jid_1.signalAddressKey)(address);
+        const identityKey = this.remoteIdentities.get(key);
+        if (identityKey === undefined)
+            return null;
+        this.onEntryAccess(key);
+        return identityKey;
     }
     async getRemoteIdentities(addresses) {
         const result = new Array(addresses.length);
         for (let i = 0; i < addresses.length; i += 1) {
-            result[i] = this.remoteIdentities.get((0, jid_1.signalAddressKey)(addresses[i])) ?? null;
+            const key = (0, jid_1.signalAddressKey)(addresses[i]);
+            const identityKey = this.remoteIdentities.get(key);
+            if (identityKey === undefined) {
+                result[i] = null;
+            }
+            else {
+                this.onEntryAccess(key);
+                result[i] = identityKey;
+            }
         }
         return result;
     }
     async setRemoteIdentity(address, identityKey) {
-        (0, collections_1.setBoundedMapEntry)(this.remoteIdentities, (0, jid_1.signalAddressKey)(address), identityKey, this.maxRemoteIdentities);
+        const key = (0, jid_1.signalAddressKey)(address);
+        (0, collections_1.setBoundedMapEntry)(this.remoteIdentities, key, identityKey, this.maxRemoteIdentities, this.onEvict);
+        this.onEntryAccess(key);
     }
     async setRemoteIdentities(entries) {
         for (const entry of entries) {
-            (0, collections_1.setBoundedMapEntry)(this.remoteIdentities, (0, jid_1.signalAddressKey)(entry.address), entry.identityKey, this.maxRemoteIdentities);
+            const key = (0, jid_1.signalAddressKey)(entry.address);
+            (0, collections_1.setBoundedMapEntry)(this.remoteIdentities, key, entry.identityKey, this.maxRemoteIdentities, this.onEvict);
+            this.onEntryAccess(key);
         }
     }
     async clear() {
         this.remoteIdentities.clear();
+        this.onEntriesClear();
     }
+    /** Runs with the key of every read hit and write. No-op unless a subclass tracks access. */
+    onEntryAccess(key) { }
+    /** Runs with the key of every cap-evicted entry. */
+    onEntryRemove(key) { }
+    onEntriesClear() { }
 }
 exports.WaIdentityMemoryStore = WaIdentityMemoryStore;