zapo-js 0.2.0 → 1.0.0

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

@@ -0,0 +1,103 @@
+import { resolvePositive } from '../../util/coercion.js';
+import { createPeriodicCleanup, setBoundedMapEntry } from '../../util/collections.js';
+const DEFAULTS = Object.freeze({
+    ttlMs: 5 * 60 * 1000,
+    maxUsers: 16384
+});
+export class WaDeviceListMemoryStore {
+    constructor(ttlMs = DEFAULTS.ttlMs, options = {}) {
+        if (!Number.isFinite(ttlMs) || ttlMs <= 0) {
+            throw new Error('device-list ttlMs must be a positive finite number');
+        }
+        this.records = new Map();
+        this.altIndex = new Map();
+        this.ttlMs = ttlMs;
+        this.maxUsers = resolvePositive(options.maxUsers, DEFAULTS.maxUsers, 'WaDeviceListMemoryStoreOptions.maxUsers');
+        this.logger = options.logger;
+        this.capacityWarned = false;
+        this.cleanup = createPeriodicCleanup(ttlMs, () => {
+            void this.cleanupExpired(Date.now());
+        });
+    }
+    warnCapacity() {
+        if (this.capacityWarned || !this.logger)
+            return;
+        this.capacityWarned = true;
+        this.logger.warn('device list store at capacity, evicting oldest', {
+            max: this.maxUsers
+        });
+    }
+    async upsertUserDevicesBatch(snapshots) {
+        for (let index = 0; index < snapshots.length; index += 1) {
+            const snapshot = snapshots[index];
+            const previous = this.records.get(snapshot.userJid);
+            if (previous?.altUserJid && previous.altUserJid !== snapshot.altUserJid) {
+                this.altIndex.delete(previous.altUserJid);
+            }
+            setBoundedMapEntry(this.records, snapshot.userJid, {
+                ...snapshot,
+                expiresAtMs: snapshot.updatedAtMs + this.ttlMs
+            }, this.maxUsers, () => this.warnCapacity());
+            if (snapshot.altUserJid) {
+                this.altIndex.set(snapshot.altUserJid, snapshot.userJid);
+            }
+        }
+    }
+    async getUserDevicesBatch(userJids, nowMs = Date.now()) {
+        const snapshots = new Array(userJids.length);
+        for (let index = 0; index < userJids.length; index += 1) {
+            snapshots[index] = this.readLive(userJids[index], nowMs);
+        }
+        return snapshots;
+    }
+    async findByAnyUserJid(jid, nowMs = Date.now()) {
+        const direct = this.readLive(jid, nowMs);
+        if (direct)
+            return direct;
+        const primary = this.altIndex.get(jid);
+        if (!primary)
+            return null;
+        return this.readLive(primary, nowMs);
+    }
+    async deleteUserDevices(userJid) {
+        const record = this.records.get(userJid);
+        if (!record)
+            return 0;
+        if (record.altUserJid)
+            this.altIndex.delete(record.altUserJid);
+        this.records.delete(userJid);
+        return 1;
+    }
+    async cleanupExpired(nowMs) {
+        let removed = 0;
+        for (const [userJid, record] of this.records) {
+            if (record.expiresAtMs > nowMs)
+                continue;
+            if (record.altUserJid)
+                this.altIndex.delete(record.altUserJid);
+            this.records.delete(userJid);
+            removed += 1;
+        }
+        return removed;
+    }
+    async clear() {
+        this.records.clear();
+        this.altIndex.clear();
+    }
+    async destroy() {
+        this.cleanup.destroy();
+        await this.clear();
+    }
+    readLive(userJid, nowMs) {
+        const record = this.records.get(userJid);
+        if (!record)
+            return null;
+        if (record.expiresAtMs <= nowMs) {
+            if (record.altUserJid)
+                this.altIndex.delete(record.altUserJid);
+            this.records.delete(userJid);
+            return null;
+        }
+        return record;
+    }
+}

package/dist/esm/store/{providers/memory/participants.store.js → memory/group-metadata.store.js}

@@ -1,26 +1,38 @@
-import { resolvePositive } from '../../../util/coercion.js';
-import { resolveCleanupIntervalMs, setBoundedMapEntry } from '../../../util/collections.js';
+import { resolvePositive } from '../../util/coercion.js';
+import { createPeriodicCleanup, setBoundedMapEntry } from '../../util/collections.js';
 const DEFAULTS = Object.freeze({
     ttlMs: 5 * 60 * 1000,
     maxGroups: 4096
 });
-export class WaParticipantsMemoryStore {
+export class WaGroupMetadataMemoryStore {
     constructor(ttlMs = DEFAULTS.ttlMs, options = {}) {
+        if (!Number.isFinite(ttlMs) || ttlMs <= 0) {
+            throw new Error('groupMetadata ttlMs must be a positive finite number');
+        }
         this.records = new Map();
         this.ttlMs = ttlMs;
-        this.maxGroups = resolvePositive(options.maxGroups, DEFAULTS.maxGroups, 'WaParticipantsMemoryStoreOptions.maxGroups');
-        this.cleanupTimer = setInterval(() => {
+        this.maxGroups = resolvePositive(options.maxGroups, DEFAULTS.maxGroups, 'WaGroupMetadataMemoryStoreOptions.maxGroups');
+        this.logger = options.logger;
+        this.capacityWarned = false;
+        this.cleanup = createPeriodicCleanup(ttlMs, () => {
             void this.cleanupExpired(Date.now());
-        }, resolveCleanupIntervalMs(ttlMs));
-        this.cleanupTimer.unref();
+        });
+    }
+    warnCapacity() {
+        if (this.capacityWarned || !this.logger)
+            return;
+        this.capacityWarned = true;
+        this.logger.warn('group metadata store at capacity, evicting oldest', {
+            max: this.maxGroups
+        });
     }
-    async upsertGroupParticipants(snapshot) {
+    async upsertGroupMetadata(snapshot) {
         setBoundedMapEntry(this.records, snapshot.groupJid, {
             ...snapshot,
             expiresAtMs: snapshot.updatedAtMs + this.ttlMs
-        }, this.maxGroups);
+        }, this.maxGroups, () => this.warnCapacity());
     }
-    async getGroupParticipants(groupJid, nowMs = Date.now()) {
+    async getGroupMetadata(groupJid, nowMs = Date.now()) {
         const record = this.records.get(groupJid);
         if (!record) {
             return null;
@@ -31,7 +43,7 @@ export class WaParticipantsMemoryStore {
         }
         return record;
     }
-    async deleteGroupParticipants(groupJid) {
+    async deleteGroupMetadata(groupJid) {
         return this.records.delete(groupJid) ? 1 : 0;
     }
     async cleanupExpired(nowMs) {
@@ -48,7 +60,7 @@ export class WaParticipantsMemoryStore {
         this.records.clear();
     }
     async destroy() {
-        clearInterval(this.cleanupTimer);
+        this.cleanup.destroy();
         await this.clear();
     }
 }

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

@@ -0,0 +1,31 @@
+import { signalAddressKey } from '../../protocol/jid.js';
+import { resolvePositive } from '../../util/coercion.js';
+import { setBoundedMapEntry } from '../../util/collections.js';
+const DEFAULT_MAX_REMOTE_IDENTITIES = 8192;
+export class WaIdentityMemoryStore {
+    constructor(options = {}) {
+        this.remoteIdentities = new Map();
+        this.maxRemoteIdentities = resolvePositive(options.maxRemoteIdentities, DEFAULT_MAX_REMOTE_IDENTITIES, 'WaIdentityMemoryStoreOptions.maxRemoteIdentities');
+    }
+    async getRemoteIdentity(address) {
+        return this.remoteIdentities.get(signalAddressKey(address)) ?? null;
+    }
+    async getRemoteIdentities(addresses) {
+        const result = new Array(addresses.length);
+        for (let i = 0; i < addresses.length; i += 1) {
+            result[i] = this.remoteIdentities.get(signalAddressKey(addresses[i])) ?? null;
+        }
+        return result;
+    }
+    async setRemoteIdentity(address, identityKey) {
+        setBoundedMapEntry(this.remoteIdentities, signalAddressKey(address), identityKey, this.maxRemoteIdentities);
+    }
+    async setRemoteIdentities(entries) {
+        for (const entry of entries) {
+            setBoundedMapEntry(this.remoteIdentities, signalAddressKey(entry.address), entry.identityKey, this.maxRemoteIdentities);
+        }
+    }
+    async clear() {
+        this.remoteIdentities.clear();
+    }
+}

package/dist/esm/store/memory/message-secret.store.js

@@ -0,0 +1,90 @@
+import { resolvePositive } from '../../util/coercion.js';
+import { createPeriodicCleanup, setBoundedMapEntry } from '../../util/collections.js';
+const DEFAULTS = Object.freeze({
+    ttlMs: 30 * 60 * 1000,
+    maxSecrets: 10000
+});
+export class WaMessageSecretMemoryStore {
+    constructor(ttlMs = DEFAULTS.ttlMs, options = {}) {
+        if (!Number.isFinite(ttlMs) || ttlMs <= 0) {
+            throw new Error('message-secret ttlMs must be a positive finite number');
+        }
+        this.secrets = new Map();
+        this.ttlMs = ttlMs;
+        this.maxSecrets = resolvePositive(options.maxSecrets, DEFAULTS.maxSecrets, 'WaMessageSecretMemoryStoreOptions.maxSecrets');
+        this.logger = options.logger;
+        this.capacityWarned = false;
+        this.cleanup = createPeriodicCleanup(ttlMs, () => {
+            void this.cleanupExpired(Date.now());
+        });
+    }
+    warnCapacity() {
+        if (this.capacityWarned || !this.logger)
+            return;
+        this.capacityWarned = true;
+        this.logger.warn('message secret store at capacity, evicting oldest', {
+            max: this.maxSecrets
+        });
+    }
+    async get(messageId, nowMs = Date.now()) {
+        const cached = this.secrets.get(messageId);
+        if (!cached)
+            return null;
+        if (cached.expiresAtMs <= nowMs) {
+            this.secrets.delete(messageId);
+            return null;
+        }
+        return { secret: cached.secret, senderJid: cached.senderJid };
+    }
+    async getBatch(messageIds, nowMs = Date.now()) {
+        const result = new Array(messageIds.length);
+        for (let i = 0; i < messageIds.length; i += 1) {
+            const cached = this.secrets.get(messageIds[i]);
+            if (!cached) {
+                result[i] = null;
+                continue;
+            }
+            if (cached.expiresAtMs <= nowMs) {
+                this.secrets.delete(messageIds[i]);
+                result[i] = null;
+                continue;
+            }
+            result[i] = { secret: cached.secret, senderJid: cached.senderJid };
+        }
+        return result;
+    }
+    async set(messageId, entry) {
+        setBoundedMapEntry(this.secrets, messageId, {
+            secret: entry.secret,
+            senderJid: entry.senderJid,
+            expiresAtMs: Date.now() + this.ttlMs
+        }, this.maxSecrets, () => this.warnCapacity());
+    }
+    async setBatch(entries) {
+        const nowMs = Date.now();
+        for (let i = 0; i < entries.length; i += 1) {
+            setBoundedMapEntry(this.secrets, entries[i].messageId, {
+                secret: entries[i].entry.secret,
+                senderJid: entries[i].entry.senderJid,
+                expiresAtMs: nowMs + this.ttlMs
+            }, this.maxSecrets, () => this.warnCapacity());
+        }
+    }
+    async cleanupExpired(nowMs) {
+        let removed = 0;
+        for (const [messageId, entry] of this.secrets) {
+            if (entry.expiresAtMs > nowMs)
+                continue;
+            this.secrets.delete(messageId);
+            removed += 1;
+        }
+        return removed;
+    }
+    async clear() {
+        this.secrets.clear();
+    }
+    async destroy() {
+        this.cleanup.destroy();
+        this.secrets.clear();
+    }
+}

package/dist/esm/store/{providers/memory → memory}/message.store.js

@@ -1,5 +1,5 @@
-import { resolvePositive } from '../../../util/coercion.js';
-import { normalizeQueryLimit, setBoundedMapEntry } from '../../../util/collections.js';
+import { resolvePositive } from '../../util/coercion.js';
+import { normalizeQueryLimit, setBoundedMapEntry } from '../../util/collections.js';
 const DEFAULT_MESSAGE_MEMORY_STORE_LIMITS = Object.freeze({
     messages: 50000
 });

package/dist/esm/store/memory/pre-key.store.js

@@ -0,0 +1,97 @@
+import { resolvePositive } from '../../util/coercion.js';
+import { setBoundedMapEntry } from '../../util/collections.js';
+const DEFAULT_MAX_PRE_KEYS = 4096;
+export class WaPreKeyMemoryStore {
+    constructor(options = {}) {
+        this.preKeys = new Map();
+        this.uploadedPreKeys = new Set();
+        this.serverHasPreKeys = false;
+        this.nextPreKeyId = 1;
+        this.maxPreKeys = resolvePositive(options.maxPreKeys, DEFAULT_MAX_PRE_KEYS, 'WaPreKeyMemoryStoreOptions.maxPreKeys');
+    }
+    async putPreKey(record) {
+        setBoundedMapEntry(this.preKeys, record.keyId, record, this.maxPreKeys, (keyId) => {
+            this.uploadedPreKeys.delete(keyId);
+        });
+        if (record.keyId >= this.nextPreKeyId) {
+            this.nextPreKeyId = record.keyId + 1;
+        }
+    }
+    async getOrGenPreKeys(count, generator) {
+        if (!Number.isSafeInteger(count) || count <= 0) {
+            throw new Error(`invalid prekey count: ${count}`);
+        }
+        const available = [];
+        const availableKeyIds = [];
+        for (const keyId of this.preKeys.keys()) {
+            if (!this.uploadedPreKeys.has(keyId)) {
+                availableKeyIds.push(keyId);
+            }
+        }
+        availableKeyIds.sort((left, right) => left - right);
+        for (let index = 0; index < availableKeyIds.length; index += 1) {
+            const keyId = availableKeyIds[index];
+            const record = this.preKeys.get(keyId);
+            if (!record) {
+                continue;
+            }
+            available.push(record);
+            if (available.length >= count) {
+                return available;
+            }
+        }
+        while (available.length < count) {
+            const record = await generator(this.nextPreKeyId++);
+            setBoundedMapEntry(this.preKeys, record.keyId, record, this.maxPreKeys, (keyId) => {
+                this.uploadedPreKeys.delete(keyId);
+            });
+            available.push(record);
+        }
+        return available;
+    }
+    async getPreKeyById(keyId) {
+        return this.preKeys.get(keyId) ?? null;
+    }
+    async getPreKeysById(keyIds) {
+        const result = new Array(keyIds.length);
+        for (let i = 0; i < keyIds.length; i += 1) {
+            result[i] = this.preKeys.get(keyIds[i]) ?? null;
+        }
+        return result;
+    }
+    async consumePreKeyById(keyId) {
+        const record = this.preKeys.get(keyId) ?? null;
+        if (!record) {
+            return null;
+        }
+        this.preKeys.delete(keyId);
+        this.uploadedPreKeys.delete(keyId);
+        return record;
+    }
+    async getOrGenSinglePreKey(generator) {
+        const preKeys = await this.getOrGenPreKeys(1, generator);
+        return preKeys[0];
+    }
+    async markKeyAsUploaded(keyId) {
+        if (keyId < 0 || keyId >= this.nextPreKeyId) {
+            throw new Error(`prekey ${keyId} is out of boundary`);
+        }
+        for (const candidate of this.preKeys.keys()) {
+            if (candidate <= keyId) {
+                this.uploadedPreKeys.add(candidate);
+            }
+        }
+    }
+    async setServerHasPreKeys(value) {
+        this.serverHasPreKeys = value;
+    }
+    async getServerHasPreKeys() {
+        return this.serverHasPreKeys;
+    }
+    async clear() {
+        this.preKeys.clear();
+        this.uploadedPreKeys.clear();
+        this.serverHasPreKeys = false;
+        this.nextPreKeyId = 1;
+    }
+}

package/dist/esm/store/{providers/memory → memory}/privacy-token.store.js

@@ -1,4 +1,4 @@
-import { setBoundedMapEntry } from '../../../util/collections.js';
+import { setBoundedMapEntry } from '../../util/collections.js';
 const DEFAULT_MAX_ENTRIES = 10000;
 export class WaPrivacyTokenMemoryStore {
     constructor(maxEntries = DEFAULT_MAX_ENTRIES) {

package/dist/esm/store/{providers/memory → memory}/retry.store.js

@@ -1,15 +1,43 @@
-import { resolveCleanupIntervalMs } from '../../../util/collections.js';
-const DEFAULT_RETRY_TTL_MS = 60 * 1000;
+import { resolvePositive } from '../../util/coercion.js';
+import { createPeriodicCleanup, setBoundedMapEntry } from '../../util/collections.js';
+const DEFAULTS = Object.freeze({
+    ttlMs: 60 * 1000,
+    maxOutboundMessages: 10000,
+    maxInboundCounters: 20000
+});
 export class WaRetryMemoryStore {
-    constructor(ttlMs = DEFAULT_RETRY_TTL_MS) {
+    constructor(ttlMs = DEFAULTS.ttlMs, options = {}) {
+        if (!Number.isFinite(ttlMs) || ttlMs <= 0) {
+            throw new Error('retry ttlMs must be a positive finite number');
+        }
         this.outboundMessages = new Map();
         this.eligibleSets = new Map();
         this.inboundCounters = new Map();
         this.ttlMs = ttlMs;
-        this.cleanupTimer = setInterval(() => {
+        this.maxOutboundMessages = resolvePositive(options.maxOutboundMessages, DEFAULTS.maxOutboundMessages, 'WaRetryMemoryStoreOptions.maxOutboundMessages');
+        this.maxInboundCounters = resolvePositive(options.maxInboundCounters, DEFAULTS.maxInboundCounters, 'WaRetryMemoryStoreOptions.maxInboundCounters');
+        this.logger = options.logger;
+        this.outboundCapacityWarned = false;
+        this.inboundCapacityWarned = false;
+        this.cleanup = createPeriodicCleanup(this.ttlMs, () => {
             void this.cleanupExpired(Date.now());
-        }, resolveCleanupIntervalMs(ttlMs));
-        this.cleanupTimer.unref();
+        });
+    }
+    warnOutboundCapacity() {
+        if (this.outboundCapacityWarned || !this.logger)
+            return;
+        this.outboundCapacityWarned = true;
+        this.logger.warn('retry outbound store at capacity, evicting oldest', {
+            max: this.maxOutboundMessages
+        });
+    }
+    warnInboundCapacity() {
+        if (this.inboundCapacityWarned || !this.logger)
+            return;
+        this.inboundCapacityWarned = true;
+        this.logger.warn('retry inbound counters at capacity, evicting oldest', {
+            max: this.maxInboundCounters
+        });
     }
     getTtlMs() {
         return this.ttlMs;
@@ -54,7 +82,7 @@ export class WaRetryMemoryStore {
         return { eligible: true, delivered: false };
     }
     async upsertOutboundMessage(record) {
-        this.outboundMessages.set(record.messageId, {
+        const storedRecord = {
             ...record,
             eligibleRequesterDeviceJids: record.eligibleRequesterDeviceJids
                 ? [...record.eligibleRequesterDeviceJids]
@@ -62,6 +90,10 @@ export class WaRetryMemoryStore {
             deliveredRequesterDeviceJids: record.deliveredRequesterDeviceJids
                 ? [...record.deliveredRequesterDeviceJids]
                 : undefined
+        };
+        setBoundedMapEntry(this.outboundMessages, record.messageId, storedRecord, this.maxOutboundMessages, (messageId) => {
+            this.eligibleSets.delete(messageId);
+            this.warnOutboundCapacity();
         });
         if (record.eligibleRequesterDeviceJids && record.eligibleRequesterDeviceJids.length > 0) {
             this.eligibleSets.set(record.messageId, new Set(record.eligibleRequesterDeviceJids));
@@ -83,11 +115,14 @@ export class WaRetryMemoryStore {
         if (!current) {
             return;
         }
-        this.outboundMessages.set(messageId, {
+        setBoundedMapEntry(this.outboundMessages, messageId, {
             ...current,
             state,
             updatedAtMs,
             expiresAtMs
+        }, this.maxOutboundMessages, (evictedMessageId) => {
+            this.eligibleSets.delete(evictedMessageId);
+            this.warnOutboundCapacity();
         });
     }
     async markOutboundRequesterDelivered(messageId, requesterDeviceJid, updatedAtMs, expiresAtMs) {
@@ -97,21 +132,21 @@ export class WaRetryMemoryStore {
         }
         const delivered = new Set(current.deliveredRequesterDeviceJids ?? []);
         delivered.add(requesterDeviceJid);
-        this.outboundMessages.set(messageId, {
+        setBoundedMapEntry(this.outboundMessages, messageId, {
             ...current,
             deliveredRequesterDeviceJids: Array.from(delivered),
             updatedAtMs,
             expiresAtMs
+        }, this.maxOutboundMessages, (evictedMessageId) => {
+            this.eligibleSets.delete(evictedMessageId);
+            this.warnOutboundCapacity();
         });
     }
     async incrementInboundCounter(messageId, requesterJid, _updatedAtMs, expiresAtMs) {
         const key = this.counterKey(messageId, requesterJid);
         const current = this.inboundCounters.get(key);
         const count = current ? current.count + 1 : 1;
-        this.inboundCounters.set(key, {
-            count,
-            expiresAtMs
-        });
+        setBoundedMapEntry(this.inboundCounters, key, { count, expiresAtMs }, this.maxInboundCounters, () => this.warnInboundCapacity());
         return count;
     }
     async cleanupExpired(nowMs) {
@@ -137,7 +172,7 @@ export class WaRetryMemoryStore {
         this.inboundCounters.clear();
     }
     async destroy() {
-        clearInterval(this.cleanupTimer);
+        this.cleanup.destroy();
         await this.clear();
     }
     counterKey(messageId, requesterJid) {

package/dist/esm/store/{providers/memory → memory}/sender-key.store.js

@@ -1,6 +1,6 @@
-import { signalAddressKey } from '../../../protocol/jid.js';
-import { resolvePositive } from '../../../util/coercion.js';
-import { setBoundedMapEntry } from '../../../util/collections.js';
+import { signalAddressKey } from '../../protocol/jid.js';
+import { resolvePositive } from '../../util/coercion.js';
+import { setBoundedMapEntry } from '../../util/collections.js';
 const DEFAULT_SENDER_KEY_STORE_LIMITS = Object.freeze({
     senderKeys: 8192,
     senderDistributions: 8192

package/dist/esm/store/memory/session.store.js

@@ -0,0 +1,45 @@
+import { signalAddressKey } from '../../protocol/jid.js';
+import { resolvePositive } from '../../util/coercion.js';
+import { setBoundedMapEntry } from '../../util/collections.js';
+const DEFAULT_MAX_SESSIONS = 8192;
+export class WaSessionMemoryStore {
+    constructor(options = {}) {
+        this.signalSessions = new Map();
+        this.maxSessions = resolvePositive(options.maxSessions, DEFAULT_MAX_SESSIONS, 'WaSessionMemoryStoreOptions.maxSessions');
+    }
+    async hasSession(address) {
+        return this.signalSessions.has(signalAddressKey(address));
+    }
+    async hasSessions(addresses) {
+        const result = new Array(addresses.length);
+        for (let i = 0; i < addresses.length; i += 1) {
+            result[i] = this.signalSessions.has(signalAddressKey(addresses[i]));
+        }
+        return result;
+    }
+    async getSession(address) {
+        return this.signalSessions.get(signalAddressKey(address)) ?? null;
+    }
+    async getSessionsBatch(addresses) {
+        const result = new Array(addresses.length);
+        for (let i = 0; i < addresses.length; i += 1) {
+            result[i] = this.signalSessions.get(signalAddressKey(addresses[i])) ?? null;
+        }
+        return result;
+    }
+    async setSession(address, session) {
+        setBoundedMapEntry(this.signalSessions, signalAddressKey(address), session, this.maxSessions);
+    }
+    async setSessionsBatch(entries) {
+        for (let index = 0; index < entries.length; index += 1) {
+            const entry = entries[index];
+            setBoundedMapEntry(this.signalSessions, signalAddressKey(entry.address), entry.session, this.maxSessions);
+        }
+    }
+    async deleteSession(address) {
+        this.signalSessions.delete(signalAddressKey(address));
+    }
+    async clear() {
+        this.signalSessions.clear();
+    }
+}

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

@@ -0,0 +1,36 @@
+export class WaSignalMemoryStore {
+    constructor() {
+        this.registrationInfo = null;
+        this.signedPreKey = null;
+        this.signedPreKeyRotationTs = null;
+    }
+    async getRegistrationInfo() {
+        return this.registrationInfo;
+    }
+    async setRegistrationInfo(info) {
+        this.registrationInfo = info;
+    }
+    async getSignedPreKey() {
+        return this.signedPreKey;
+    }
+    async setSignedPreKey(record) {
+        this.signedPreKey = record;
+    }
+    async getSignedPreKeyById(keyId) {
+        if (!this.signedPreKey) {
+            return null;
+        }
+        return this.signedPreKey.keyId === keyId ? this.signedPreKey : null;
+    }
+    async setSignedPreKeyRotationTs(value) {
+        this.signedPreKeyRotationTs = value;
+    }
+    async getSignedPreKeyRotationTs() {
+        return this.signedPreKeyRotationTs;
+    }
+    async clear() {
+        this.registrationInfo = null;
+        this.signedPreKey = null;
+        this.signedPreKeyRotationTs = null;
+    }
+}

package/dist/esm/store/{providers/memory → memory}/thread.store.js

@@ -1,5 +1,5 @@
-import { resolvePositive } from '../../../util/coercion.js';
-import { normalizeQueryLimit, setBoundedMapEntry } from '../../../util/collections.js';
+import { resolvePositive } from '../../util/coercion.js';
+import { normalizeQueryLimit, setBoundedMapEntry } from '../../util/collections.js';
 const DEFAULT_THREAD_MEMORY_STORE_LIMITS = Object.freeze({
     threads: 10000
 });