zapo-js 0.1.1 → 0.2.0

package/dist/types/signal/session/resolver.d.ts

@@ -0,0 +1,22 @@
+import type { Logger } from '../../infra/log/types';
+import type { SignalIdentitySyncApi } from '../api/SignalIdentitySyncApi';
+import type { SignalSessionSyncApi } from '../api/SignalSessionSyncApi';
+import type { SignalProtocol } from '../session/SignalProtocol';
+import type { SignalAddress, SignalSessionRecord } from '../types';
+import type { WaSignalStore } from '../../store/contracts/signal.store';
+export interface SignalResolvedSessionTarget {
+    readonly jid: string;
+    readonly address: SignalAddress;
+    readonly session: SignalSessionRecord;
+}
+export type SignalSessionResolver = {
+    ensureSession(address: SignalAddress, jid: string, expectedIdentity?: Uint8Array, reasonIdentity?: boolean): Promise<void>;
+    ensureSessionsBatch(targetJids: readonly string[], expectedIdentityByJid?: ReadonlyMap<string, Uint8Array>): Promise<readonly SignalResolvedSessionTarget[]>;
+};
+export declare function createSignalSessionResolver(options: {
+    readonly signalProtocol: SignalProtocol;
+    readonly signalStore: WaSignalStore;
+    readonly signalIdentitySync: SignalIdentitySyncApi;
+    readonly signalSessionSync: SignalSessionSyncApi;
+    readonly logger: Logger;
+}): SignalSessionResolver;

package/dist/types/store/contracts/appstate.store.d.ts

@@ -1,5 +1,6 @@
 import type { AppStateCollectionName, WaAppStateStoreData, WaAppStateSyncKey } from '../../appstate/types';
 export interface WaAppStateCollectionStoreState {
+    readonly initialized: boolean;
     readonly version: number;
     readonly hash: Uint8Array;
     readonly indexValueMap: ReadonlyMap<string, Uint8Array>;
@@ -13,10 +14,12 @@ export interface WaAppStateCollectionStateUpdate {
 export interface WaAppStateStore {
     exportData(): Promise<WaAppStateStoreData>;
     upsertSyncKeys(keys: readonly WaAppStateSyncKey[]): Promise<number>;
-    getSyncKey(keyId: Uint8Array): Promise<WaAppStateSyncKey | null>;
+    getSyncKeysBatch(keyIds: readonly Uint8Array[]): Promise<readonly (WaAppStateSyncKey | null)[]>;
     getSyncKeyData(keyId: Uint8Array): Promise<Uint8Array | null>;
+    getSyncKeyDataBatch(keyIds: readonly Uint8Array[]): Promise<readonly (Uint8Array | null)[]>;
     getActiveSyncKey(): Promise<WaAppStateSyncKey | null>;
     getCollectionState(collection: AppStateCollectionName): Promise<WaAppStateCollectionStoreState>;
+    getCollectionStates(collections: readonly AppStateCollectionName[]): Promise<readonly WaAppStateCollectionStoreState[]>;
     setCollectionStates(updates: readonly WaAppStateCollectionStateUpdate[]): Promise<void>;
     clear(): Promise<void>;
 }

package/dist/types/store/contracts/contact.store.d.ts

@@ -8,6 +8,7 @@ export interface WaStoredContactRecord {
 }
 export interface WaContactStore {
     upsert(record: WaStoredContactRecord): Promise<void>;
+    upsertBatch(records: readonly WaStoredContactRecord[]): Promise<void>;
     getByJid(jid: string): Promise<WaStoredContactRecord | null>;
     deleteByJid(jid: string): Promise<number>;
     clear(): Promise<void>;

package/dist/types/store/contracts/device-list.store.d.ts

@@ -4,11 +4,8 @@ export interface WaDeviceListSnapshot {
     readonly updatedAtMs: number;
 }
 export interface WaDeviceListStore {
-    getTtlMs(): number;
     destroy?(): Promise<void>;
-    upsertUserDevices(snapshot: WaDeviceListSnapshot): Promise<void>;
     upsertUserDevicesBatch(snapshots: readonly WaDeviceListSnapshot[]): Promise<void>;
-    getUserDevices(userJid: string, nowMs?: number): Promise<WaDeviceListSnapshot | null>;
     getUserDevicesBatch(userJids: readonly string[], nowMs?: number): Promise<readonly (WaDeviceListSnapshot | null)[]>;
     deleteUserDevices(userJid: string): Promise<number>;
     cleanupExpired(nowMs: number): Promise<number>;

package/dist/types/store/contracts/message.store.d.ts

@@ -11,6 +11,7 @@ export interface WaStoredMessageRecord {
 }
 export interface WaMessageStore {
     upsert(record: WaStoredMessageRecord): Promise<void>;
+    upsertBatch(records: readonly WaStoredMessageRecord[]): Promise<void>;
     getById(id: string): Promise<WaStoredMessageRecord | null>;
     listByThread(threadJid: string, limit?: number, beforeTimestampMs?: number): Promise<readonly WaStoredMessageRecord[]>;
     deleteById(id: string): Promise<number>;

package/dist/types/store/contracts/participants.store.d.ts

@@ -4,7 +4,6 @@ export interface WaParticipantsSnapshot {
     readonly updatedAtMs: number;
 }
 export interface WaParticipantsStore {
-    getTtlMs(): number;
     destroy?(): Promise<void>;
     upsertGroupParticipants(snapshot: WaParticipantsSnapshot): Promise<void>;
     getGroupParticipants(groupJid: string, nowMs?: number): Promise<WaParticipantsSnapshot | null>;

package/dist/types/store/contracts/privacy-token.store.d.ts

@@ -0,0 +1,16 @@
+export interface WaStoredPrivacyTokenRecord {
+    readonly jid: string;
+    readonly tcToken?: Uint8Array;
+    readonly tcTokenTimestamp?: number;
+    readonly tcTokenSenderTimestamp?: number;
+    readonly nctSalt?: Uint8Array;
+    readonly updatedAtMs: number;
+}
+export interface WaPrivacyTokenStore {
+    upsert(record: WaStoredPrivacyTokenRecord): Promise<void>;
+    upsertBatch(records: readonly WaStoredPrivacyTokenRecord[]): Promise<void>;
+    getByJid(jid: string): Promise<WaStoredPrivacyTokenRecord | null>;
+    deleteByJid(jid: string): Promise<number>;
+    clear(): Promise<void>;
+    destroy?(): Promise<void>;
+}

package/dist/types/store/contracts/retry.store.d.ts

@@ -1,10 +1,17 @@
 import type { WaRetryOutboundMessageRecord, WaRetryOutboundState } from '../../retry/types';
 export interface WaRetryStore {
+    getOutboundRequesterStatus(messageId: string, requesterDeviceJid: string): Promise<{
+        readonly eligible: boolean;
+        readonly delivered: boolean;
+    } | null>;
     getTtlMs?(): number;
+    supportsRawReplayPayload?(): boolean;
     destroy?(): Promise<void>;
     upsertOutboundMessage(record: WaRetryOutboundMessageRecord): Promise<void>;
+    deleteOutboundMessage(messageId: string): Promise<number>;
     getOutboundMessage(messageId: string): Promise<WaRetryOutboundMessageRecord | null>;
     updateOutboundMessageState(messageId: string, state: WaRetryOutboundState, updatedAtMs: number, expiresAtMs: number): Promise<void>;
+    markOutboundRequesterDelivered(messageId: string, requesterDeviceJid: string, updatedAtMs: number, expiresAtMs: number): Promise<void>;
     incrementInboundCounter(messageId: string, requesterJid: string, updatedAtMs: number, expiresAtMs: number): Promise<number>;
     cleanupExpired(nowMs: number): Promise<number>;
     clear(): Promise<void>;

package/dist/types/store/contracts/sender-key.store.d.ts

@@ -8,7 +8,6 @@ export interface WaSenderKeyStore {
         readonly skDistribList: readonly SenderKeyDistributionRecord[];
     }>;
     getDeviceSenderKey(groupId: string, sender: SignalAddress): Promise<SenderKeyRecord | null>;
-    getDeviceSenderKeyDistribution(groupId: string, sender: SignalAddress): Promise<SenderKeyDistributionRecord | null>;
     getDeviceSenderKeyDistributions(groupId: string, senders: readonly SignalAddress[]): Promise<readonly (SenderKeyDistributionRecord | null)[]>;
     deleteDeviceSenderKey(target: SignalAddress, groupId?: string): Promise<number>;
     markForgetSenderKey(groupId: string, participants: readonly SignalAddress[]): Promise<number>;

package/dist/types/store/contracts/signal.store.d.ts

@@ -1,4 +1,10 @@
 import type { PreKeyRecord, RegistrationInfo, SignalAddress, SignalSessionRecord, SignedPreKeyRecord } from '../../signal/types';
+export interface WaSignalMetaSnapshot {
+    readonly serverHasPreKeys: boolean;
+    readonly signedPreKeyRotationTs: number | null;
+    readonly registrationInfo: RegistrationInfo | null;
+    readonly signedPreKey: SignedPreKeyRecord | null;
+}
 export interface WaSignalStore {
     getRegistrationInfo(): Promise<RegistrationInfo | null>;
     setRegistrationInfo(info: RegistrationInfo): Promise<void>;
@@ -16,12 +22,19 @@ export interface WaSignalStore {
     markKeyAsUploaded(keyId: number): Promise<void>;
     setServerHasPreKeys(value: boolean): Promise<void>;
     getServerHasPreKeys(): Promise<boolean>;
+    getSignalMeta(): Promise<WaSignalMetaSnapshot>;
     hasSession(address: SignalAddress): Promise<boolean>;
     hasSessions(addresses: readonly SignalAddress[]): Promise<readonly boolean[]>;
     getSession(address: SignalAddress): Promise<SignalSessionRecord | null>;
+    getSessionsBatch(addresses: readonly SignalAddress[]): Promise<readonly (SignalSessionRecord | null)[]>;
     setSession(address: SignalAddress, session: SignalSessionRecord): Promise<void>;
+    setSessionsBatch(entries: readonly {
+        readonly address: SignalAddress;
+        readonly session: SignalSessionRecord;
+    }[]): Promise<void>;
     deleteSession(address: SignalAddress): Promise<void>;
     getRemoteIdentity(address: SignalAddress): Promise<Uint8Array | null>;
+    getRemoteIdentities(addresses: readonly SignalAddress[]): Promise<readonly (Uint8Array | null)[]>;
     setRemoteIdentity(address: SignalAddress, identityKey: Uint8Array): Promise<void>;
     setRemoteIdentities(entries: readonly {
         readonly address: SignalAddress;

package/dist/types/store/contracts/thread.store.d.ts

@@ -10,6 +10,7 @@ export interface WaStoredThreadRecord {
 }
 export interface WaThreadStore {
     upsert(record: WaStoredThreadRecord): Promise<void>;
+    upsertBatch(records: readonly WaStoredThreadRecord[]): Promise<void>;
     getByJid(jid: string): Promise<WaStoredThreadRecord | null>;
     list(limit?: number): Promise<readonly WaStoredThreadRecord[]>;
     deleteByJid(jid: string): Promise<number>;

package/dist/types/store/createStore.d.ts

@@ -1,2 +1,2 @@
 import type { WaCreateStoreOptions, WaStore } from './types';
-export declare function createStore(options: WaCreateStoreOptions): WaStore;
+export declare function createStore<B extends string>(options: WaCreateStoreOptions<B>): WaStore;

package/dist/types/store/index.d.ts

@@ -1,22 +1,16 @@
-export type { WaCreateStoreCustomCacheProviders, WaCreateStoreCustomProviders, WaCreateStoreOptions, WaSqliteDriver, WaSqliteStorageOptions, WaStoreSqliteBatchSizeSelection, WaStoreMemoryLimitSelection, WaStoreCacheProviderSelection, WaStoreCacheTtlSelection, WaStore, WaStoreDomainValueOrFactory, WaStoreProviderSelection, WaStoreSession } from './types';
-export { WaAuthSqliteStore } from './providers/sqlite/auth.store';
-export { WaAppStateSqliteStore } from './providers/sqlite/appstate.store';
+export type { WaCreateStoreOptions, WaStore, WaStoreBackend, WaCacheDomain, WaStoreDomain, WaStoreMemoryLimitSelection, WaStoreSession } from './types';
 export { createStore } from './createStore';
 export type { WaAuthStore } from './contracts/auth.store';
 export type { WaContactStore, WaStoredContactRecord } from './contracts/contact.store';
 export type { WaDeviceListSnapshot, WaDeviceListStore } from './contracts/device-list.store';
 export type { WaMessageStore, WaStoredMessageRecord } from './contracts/message.store';
 export type { WaParticipantsSnapshot, WaParticipantsStore } from './contracts/participants.store';
-export type { WaAppStateCollectionStoreState, WaAppStateStore } from './contracts/appstate.store';
+export type { WaAppStateCollectionStateUpdate, WaAppStateCollectionStoreState, WaAppStateStore } from './contracts/appstate.store';
 export type { WaSenderKeyStore } from './contracts/sender-key.store';
-export type { WaSignalStore } from './contracts/signal.store';
+export type { WaSignalMetaSnapshot, WaSignalStore } from './contracts/signal.store';
 export type { WaRetryStore } from './contracts/retry.store';
 export type { WaStoredThreadRecord, WaThreadStore } from './contracts/thread.store';
-export { WaSignalSqliteStore } from './providers/sqlite/signal.store';
-export { SenderKeySqliteStore } from './providers/sqlite/sender-key.store';
-export { WaRetrySqliteStore } from './providers/sqlite/retry.store';
-export { WaParticipantsSqliteStore } from './providers/sqlite/participants.store';
-export { WaDeviceListSqliteStore } from './providers/sqlite/device-list.store';
+export type { WaPrivacyTokenStore, WaStoredPrivacyTokenRecord } from './contracts/privacy-token.store';
 export { WaAppStateMemoryStore } from './providers/memory/appstate.store';
 export { WaSignalMemoryStore } from './providers/memory/signal.store';
 export { SenderKeyMemoryStore } from './providers/memory/sender-key.store';
@@ -26,6 +20,4 @@ export { WaDeviceListMemoryStore } from './providers/memory/device-list.store';
 export { WaContactMemoryStore } from './providers/memory/contact.store';
 export { WaMessageMemoryStore } from './providers/memory/message.store';
 export { WaThreadMemoryStore } from './providers/memory/thread.store';
-export { WaContactSqliteStore } from './providers/sqlite/contact.store';
-export { WaMessageSqliteStore } from './providers/sqlite/message.store';
-export { WaThreadSqliteStore } from './providers/sqlite/thread.store';
+export { WaPrivacyTokenMemoryStore } from './providers/memory/privacy-token.store';

package/dist/types/store/locks/appstate.lock.d.ts

@@ -0,0 +1,3 @@
+import type { WaAppStateStore } from '../contracts/appstate.store';
+import type { WithDestroyLifecycle } from '../types';
+export declare function withAppStateLock(store: WaAppStateStore): WithDestroyLifecycle<WaAppStateStore>;

package/dist/types/store/locks/auth.lock.d.ts

@@ -0,0 +1,3 @@
+import type { WaAuthStore } from '../contracts/auth.store';
+import type { WithDestroyLifecycle } from '../types';
+export declare function withAuthLock(store: WaAuthStore): WithDestroyLifecycle<WaAuthStore>;

package/dist/types/store/locks/contact.lock.d.ts

@@ -0,0 +1,3 @@
+import type { WaContactStore } from '../contracts/contact.store';
+import type { WithDestroyLifecycle } from '../types';
+export declare function withContactLock(store: WaContactStore): WithDestroyLifecycle<WaContactStore>;

package/dist/types/store/locks/device-list.lock.d.ts

@@ -0,0 +1,2 @@
+import type { WaDeviceListStore } from '../contracts/device-list.store';
+export declare function withDeviceListLock(store: WaDeviceListStore): WaDeviceListStore;

package/dist/types/store/locks/message.lock.d.ts

@@ -0,0 +1,3 @@
+import type { WaMessageStore } from '../contracts/message.store';
+import type { WithDestroyLifecycle } from '../types';
+export declare function withMessageLock(store: WaMessageStore): WithDestroyLifecycle<WaMessageStore>;

package/dist/types/store/locks/participants.lock.d.ts

@@ -0,0 +1,2 @@
+import type { WaParticipantsStore } from '../contracts/participants.store';
+export declare function withParticipantsLock(store: WaParticipantsStore): WaParticipantsStore;

package/dist/types/store/locks/privacy-token.lock.d.ts

@@ -0,0 +1,2 @@
+import type { WaPrivacyTokenStore } from '../contracts/privacy-token.store';
+export declare function withPrivacyTokenLock(store: WaPrivacyTokenStore): WaPrivacyTokenStore;

package/dist/types/store/locks/retry.lock.d.ts

@@ -0,0 +1,2 @@
+import type { WaRetryStore } from '../contracts/retry.store';
+export declare function withRetryLock(store: WaRetryStore): WaRetryStore;

package/dist/types/store/locks/sender-key.lock.d.ts

@@ -0,0 +1,3 @@
+import type { WaSenderKeyStore } from '../contracts/sender-key.store';
+import type { WithDestroyLifecycle } from '../types';
+export declare function withSenderKeyLock(store: WaSenderKeyStore): WithDestroyLifecycle<WaSenderKeyStore>;

package/dist/types/store/locks/signal.lock.d.ts

@@ -0,0 +1,3 @@
+import type { WaSignalStore } from '../contracts/signal.store';
+import type { WithDestroyLifecycle } from '../types';
+export declare function withSignalLock(store: WaSignalStore): WithDestroyLifecycle<WaSignalStore>;

package/dist/types/store/locks/thread.lock.d.ts

@@ -0,0 +1,3 @@
+import type { WaThreadStore } from '../contracts/thread.store';
+import type { WithDestroyLifecycle } from '../types';
+export declare function withThreadLock(store: WaThreadStore): WithDestroyLifecycle<WaThreadStore>;

package/dist/types/store/providers/memory/appstate.store.d.ts

@@ -12,10 +12,12 @@ export declare class WaAppStateMemoryStore implements WaAppStateStore {
     constructor(initial?: WaAppStateStoreData, options?: WaAppStateMemoryStoreOptions);
     exportData(): Promise<WaAppStateStoreData>;
     upsertSyncKeys(keys: readonly WaAppStateSyncKey[]): Promise<number>;
-    getSyncKey(keyId: Uint8Array): Promise<WaAppStateSyncKey | null>;
+    getSyncKeysBatch(keyIds: readonly Uint8Array[]): Promise<readonly (WaAppStateSyncKey | null)[]>;
     getSyncKeyData(keyId: Uint8Array): Promise<Uint8Array | null>;
+    getSyncKeyDataBatch(keyIds: readonly Uint8Array[]): Promise<readonly (Uint8Array | null)[]>;
     getActiveSyncKey(): Promise<WaAppStateSyncKey | null>;
     getCollectionState(collection: AppStateCollectionName): Promise<WaAppStateCollectionStoreState>;
+    getCollectionStates(collections: readonly AppStateCollectionName[]): Promise<readonly WaAppStateCollectionStoreState[]>;
     setCollectionStates(updates: readonly WaAppStateCollectionStateUpdate[]): Promise<void>;
     clear(): Promise<void>;
 }

package/dist/types/store/providers/memory/contact.store.d.ts

@@ -7,6 +7,7 @@ export declare class WaContactMemoryStore implements Contract {
     private readonly maxContacts;
     constructor(options?: WaContactMemoryStoreOptions);
     upsert(record: WaStoredContactRecord): Promise<void>;
+    upsertBatch(records: readonly WaStoredContactRecord[]): Promise<void>;
     getByJid(jid: string): Promise<WaStoredContactRecord | null>;
     deleteByJid(jid: string): Promise<number>;
     clear(): Promise<void>;

package/dist/types/store/providers/memory/device-list.store.d.ts

@@ -8,10 +8,7 @@ export declare class WaDeviceListMemoryStore implements WaDeviceListStore {
     private readonly maxUsers;
     private readonly cleanupTimer;
     constructor(ttlMs?: number, options?: WaDeviceListMemoryStoreOptions);
-    getTtlMs(): number;
-    upsertUserDevices(snapshot: WaDeviceListSnapshot): Promise<void>;
     upsertUserDevicesBatch(snapshots: readonly WaDeviceListSnapshot[]): Promise<void>;
-    getUserDevices(userJid: string, nowMs?: number): Promise<WaDeviceListSnapshot | null>;
     getUserDevicesBatch(userJids: readonly string[], nowMs?: number): Promise<readonly (WaDeviceListSnapshot | null)[]>;
     deleteUserDevices(userJid: string): Promise<number>;
     cleanupExpired(nowMs: number): Promise<number>;

package/dist/types/store/providers/memory/message.store.d.ts

@@ -7,6 +7,7 @@ export declare class WaMessageMemoryStore implements Contract {
     private readonly maxMessages;
     constructor(options?: WaMessageMemoryStoreOptions);
     upsert(record: WaStoredMessageRecord): Promise<void>;
+    upsertBatch(records: readonly WaStoredMessageRecord[]): Promise<void>;
     getById(id: string): Promise<WaStoredMessageRecord | null>;
     listByThread(threadJid: string, limit?: number, beforeTimestampMs?: number): Promise<readonly WaStoredMessageRecord[]>;
     deleteById(id: string): Promise<number>;

package/dist/types/store/providers/memory/participants.store.d.ts

@@ -8,7 +8,6 @@ export declare class WaParticipantsMemoryStore implements WaParticipantsStore {
     private readonly maxGroups;
     private readonly cleanupTimer;
     constructor(ttlMs?: number, options?: WaParticipantsMemoryStoreOptions);
-    getTtlMs(): number;
     upsertGroupParticipants(snapshot: WaParticipantsSnapshot): Promise<void>;
     getGroupParticipants(groupJid: string, nowMs?: number): Promise<WaParticipantsSnapshot | null>;
     deleteGroupParticipants(groupJid: string): Promise<number>;

package/dist/types/store/providers/memory/privacy-token.store.d.ts

@@ -0,0 +1,13 @@
+import type { WaPrivacyTokenStore, WaStoredPrivacyTokenRecord } from '../../contracts/privacy-token.store';
+export declare class WaPrivacyTokenMemoryStore implements WaPrivacyTokenStore {
+    private readonly records;
+    private readonly maxEntries;
+    constructor(maxEntries?: number);
+    upsert(record: WaStoredPrivacyTokenRecord): Promise<void>;
+    upsertBatch(records: readonly WaStoredPrivacyTokenRecord[]): Promise<void>;
+    getByJid(jid: string): Promise<WaStoredPrivacyTokenRecord | null>;
+    deleteByJid(jid: string): Promise<number>;
+    clear(): Promise<void>;
+    destroy(): Promise<void>;
+    private mergeRecord;
+}

package/dist/types/store/providers/memory/retry.store.d.ts

@@ -2,14 +2,22 @@ import type { WaRetryOutboundMessageRecord, WaRetryOutboundState } from '../../.
 import type { WaRetryStore } from '../../contracts/retry.store';
 export declare class WaRetryMemoryStore implements WaRetryStore {
     private readonly outboundMessages;
+    private readonly eligibleSets;
     private readonly inboundCounters;
     private readonly ttlMs;
     private readonly cleanupTimer;
     constructor(ttlMs?: number);
     getTtlMs(): number;
+    supportsRawReplayPayload(): boolean;
+    getOutboundRequesterStatus(messageId: string, requesterDeviceJid: string): Promise<{
+        readonly eligible: boolean;
+        readonly delivered: boolean;
+    } | null>;
     upsertOutboundMessage(record: WaRetryOutboundMessageRecord): Promise<void>;
+    deleteOutboundMessage(messageId: string): Promise<number>;
     getOutboundMessage(messageId: string): Promise<WaRetryOutboundMessageRecord | null>;
     updateOutboundMessageState(messageId: string, state: WaRetryOutboundState, updatedAtMs: number, expiresAtMs: number): Promise<void>;
+    markOutboundRequesterDelivered(messageId: string, requesterDeviceJid: string, updatedAtMs: number, expiresAtMs: number): Promise<void>;
     incrementInboundCounter(messageId: string, requesterJid: string, _updatedAtMs: number, expiresAtMs: number): Promise<number>;
     cleanupExpired(nowMs: number): Promise<number>;
     clear(): Promise<void>;

package/dist/types/store/providers/memory/sender-key.store.d.ts

@@ -18,7 +18,6 @@ export declare class SenderKeyMemoryStore implements WaSenderKeyStoreContract {
         readonly skDistribList: readonly SenderKeyDistributionRecord[];
     }>;
     getDeviceSenderKey(groupId: string, sender: SignalAddress): Promise<SenderKeyRecord | null>;
-    getDeviceSenderKeyDistribution(groupId: string, sender: SignalAddress): Promise<SenderKeyDistributionRecord | null>;
     getDeviceSenderKeyDistributions(groupId: string, senders: readonly SignalAddress[]): Promise<readonly (SenderKeyDistributionRecord | null)[]>;
     deleteDeviceSenderKey(target: SignalAddress, groupId?: string): Promise<number>;
     markForgetSenderKey(groupId: string, participants: readonly SignalAddress[]): Promise<number>;

package/dist/types/store/providers/memory/signal.store.d.ts

@@ -1,5 +1,5 @@
 import type { PreKeyRecord, RegistrationInfo, SignalAddress, SignalSessionRecord, SignedPreKeyRecord } from '../../../signal/types';
-import type { WaSignalStore as WaSignalStoreContract } from '../../contracts/signal.store';
+import type { WaSignalMetaSnapshot, WaSignalStore as WaSignalStoreContract } from '../../contracts/signal.store';
 export interface WaSignalMemoryStoreOptions {
     readonly maxPreKeys?: number;
     readonly maxSessions?: number;
@@ -35,12 +35,19 @@ export declare class WaSignalMemoryStore implements WaSignalStoreContract {
     markKeyAsUploaded(keyId: number): Promise<void>;
     setServerHasPreKeys(value: boolean): Promise<void>;
     getServerHasPreKeys(): Promise<boolean>;
+    getSignalMeta(): Promise<WaSignalMetaSnapshot>;
     hasSession(address: SignalAddress): Promise<boolean>;
     hasSessions(addresses: readonly SignalAddress[]): Promise<readonly boolean[]>;
     getSession(address: SignalAddress): Promise<SignalSessionRecord | null>;
+    getSessionsBatch(addresses: readonly SignalAddress[]): Promise<readonly (SignalSessionRecord | null)[]>;
     setSession(address: SignalAddress, session: SignalSessionRecord): Promise<void>;
+    setSessionsBatch(entries: readonly {
+        readonly address: SignalAddress;
+        readonly session: SignalSessionRecord;
+    }[]): Promise<void>;
     deleteSession(address: SignalAddress): Promise<void>;
     getRemoteIdentity(address: SignalAddress): Promise<Uint8Array | null>;
+    getRemoteIdentities(addresses: readonly SignalAddress[]): Promise<readonly (Uint8Array | null)[]>;
     setRemoteIdentity(address: SignalAddress, identityKey: Uint8Array): Promise<void>;
     setRemoteIdentities(entries: readonly {
         readonly address: SignalAddress;

package/dist/types/store/providers/memory/thread.store.d.ts

@@ -7,6 +7,7 @@ export declare class WaThreadMemoryStore implements Contract {
     private readonly maxThreads;
     constructor(options?: WaThreadMemoryStoreOptions);
     upsert(record: WaStoredThreadRecord): Promise<void>;
+    upsertBatch(records: readonly WaStoredThreadRecord[]): Promise<void>;
     getByJid(jid: string): Promise<WaStoredThreadRecord | null>;
     list(limit?: number): Promise<readonly WaStoredThreadRecord[]>;
     deleteByJid(jid: string): Promise<number>;

package/dist/types/store/types.d.ts

@@ -4,17 +4,14 @@ import type { WaContactStore } from './contracts/contact.store';
 import type { WaDeviceListStore } from './contracts/device-list.store';
 import type { WaMessageStore } from './contracts/message.store';
 import type { WaParticipantsStore } from './contracts/participants.store';
+import type { WaPrivacyTokenStore } from './contracts/privacy-token.store';
 import type { WaRetryStore } from './contracts/retry.store';
 import type { WaSenderKeyStore } from './contracts/sender-key.store';
 import type { WaSignalStore } from './contracts/signal.store';
 import type { WaThreadStore } from './contracts/thread.store';
-export type WaSqliteDriver = 'auto' | 'better-sqlite3' | 'bun';
-export interface WaSqliteStorageOptions {
-    readonly path: string;
-    readonly sessionId: string;
-    readonly driver?: WaSqliteDriver;
-    readonly pragmas?: Readonly<Record<string, string | number>>;
-}
+export type WithDestroyLifecycle<T> = T & {
+    readonly destroy?: () => Promise<void>;
+};
 export interface WaStoreSession {
     readonly auth: WaAuthStore;
     readonly signal: WaSignalStore;
@@ -26,6 +23,7 @@ export interface WaStoreSession {
     readonly messages: WaMessageStore;
     readonly threads: WaThreadStore;
     readonly contacts: WaContactStore;
+    readonly privacyToken: WaPrivacyTokenStore;
     destroyCaches(): Promise<void>;
     destroy(): Promise<void>;
 }
@@ -34,30 +32,50 @@ export interface WaStore {
     destroyCaches(): Promise<void>;
     destroy(): Promise<void>;
 }
-export interface WaStoreProviderSelection {
-    readonly auth?: 'sqlite';
-    readonly signal?: 'sqlite' | 'memory';
-    readonly senderKey?: 'sqlite' | 'memory';
-    readonly appState?: 'sqlite' | 'memory';
-    readonly messages?: 'none' | 'sqlite' | 'memory';
-    readonly threads?: 'none' | 'sqlite' | 'memory';
-    readonly contacts?: 'none' | 'sqlite' | 'memory';
-}
-export interface WaStoreCacheProviderSelection {
-    readonly retry?: 'sqlite' | 'memory';
-    readonly participants?: 'none' | 'sqlite' | 'memory';
-    readonly deviceList?: 'none' | 'sqlite' | 'memory';
-}
-export interface WaStoreCacheTtlSelection {
-    readonly retryMs?: number;
-    readonly participantsMs?: number;
-    readonly deviceListMs?: number;
+export interface WaStoreBackend {
+    readonly stores: {
+        readonly auth: (sessionId: string) => WaAuthStore;
+        readonly signal: (sessionId: string) => WaSignalStore;
+        readonly senderKey: (sessionId: string) => WaSenderKeyStore;
+        readonly appState: (sessionId: string) => WaAppStateStore;
+        readonly messages: (sessionId: string) => WaMessageStore;
+        readonly threads: (sessionId: string) => WaThreadStore;
+        readonly contacts: (sessionId: string) => WaContactStore;
+        readonly privacyToken: (sessionId: string) => WaPrivacyTokenStore;
+    };
+    readonly caches: {
+        readonly retry: (sessionId: string) => WaRetryStore;
+        readonly participants: (sessionId: string) => WaParticipantsStore;
+        readonly deviceList: (sessionId: string) => WaDeviceListStore;
+    };
 }
-export interface WaStoreSqliteBatchSizeSelection {
-    readonly deviceList?: number;
-    readonly senderKeyDistribution?: number;
-    readonly signalPreKey?: number;
-    readonly signalHasSession?: number;
+export type WaStoreDomain = keyof WaStoreBackend['stores'];
+export type WaCacheDomain = keyof WaStoreBackend['caches'];
+export interface WaCreateStoreOptions<B extends string = string> {
+    readonly backends?: Readonly<Record<B, WaStoreBackend>>;
+    readonly providers?: {
+        readonly auth?: B | 'memory';
+        readonly signal?: B | 'memory';
+        readonly senderKey?: B | 'memory';
+        readonly appState?: B | 'memory';
+        readonly messages?: B | 'memory' | 'none';
+        readonly threads?: B | 'memory' | 'none';
+        readonly contacts?: B | 'memory' | 'none';
+        readonly privacyToken?: B | 'memory';
+    };
+    readonly cacheProviders?: {
+        readonly retry?: B | 'memory';
+        readonly participants?: B | 'memory' | 'none';
+        readonly deviceList?: B | 'memory' | 'none';
+    };
+    readonly memory?: {
+        readonly limits?: WaStoreMemoryLimitSelection;
+        readonly cacheTtlMs?: {
+            readonly retryMs?: number;
+            readonly participantsMs?: number;
+            readonly deviceListMs?: number;
+        };
+    };
 }
 export interface WaStoreMemoryLimitSelection {
     readonly appStateSyncKeys?: number;
@@ -72,32 +90,5 @@ export interface WaStoreMemoryLimitSelection {
     readonly messages?: number;
     readonly threads?: number;
     readonly contacts?: number;
-}
-export type WaStoreDomainValueOrFactory<T> = T | ((sessionId: string) => T);
-export interface WaCreateStoreCustomProviders {
-    readonly auth?: WaStoreDomainValueOrFactory<WaAuthStore>;
-    readonly signal?: WaStoreDomainValueOrFactory<WaSignalStore>;
-    readonly senderKey?: WaStoreDomainValueOrFactory<WaSenderKeyStore>;
-    readonly appState?: WaStoreDomainValueOrFactory<WaAppStateStore>;
-    readonly messages?: WaStoreDomainValueOrFactory<WaMessageStore>;
-    readonly threads?: WaStoreDomainValueOrFactory<WaThreadStore>;
-    readonly contacts?: WaStoreDomainValueOrFactory<WaContactStore>;
-}
-export interface WaCreateStoreCustomCacheProviders {
-    readonly retry?: WaStoreDomainValueOrFactory<WaRetryStore>;
-    readonly participants?: WaStoreDomainValueOrFactory<WaParticipantsStore>;
-    readonly deviceList?: WaStoreDomainValueOrFactory<WaDeviceListStore>;
-}
-export interface WaCreateStoreOptions {
-    readonly sqlite?: Omit<WaSqliteStorageOptions, 'sessionId'> & {
-        readonly batchSizes?: WaStoreSqliteBatchSizeSelection;
-    };
-    readonly memory?: {
-        readonly limits?: WaStoreMemoryLimitSelection;
-    };
-    readonly providers?: WaStoreProviderSelection;
-    readonly cacheProviders?: WaStoreCacheProviderSelection;
-    readonly cacheTtlMs?: WaStoreCacheTtlSelection;
-    readonly custom?: WaCreateStoreCustomProviders;
-    readonly customCache?: WaCreateStoreCustomCacheProviders;
+    readonly privacyTokens?: number;
 }

package/dist/types/transport/WaWebSocket.d.ts

@@ -10,16 +10,17 @@ export declare class WaWebSocket {
     private handlers;
     private socket;
     private closeWaiter;
+    private nodeWsCtorPromise;
     constructor(config: WaSocketConfig, logger?: Logger);
     setHandlers(handlers: WaSocketHandlers): void;
     isOpen(): boolean;
     isConnecting(): boolean;
-    getReadyState(): number;
     open(): Promise<SocketOpenInfo>;
     close(code?: number, reason?: string): Promise<SocketCloseInfo | null>;
     send(data: string | ArrayBuffer | Uint8Array): Promise<void>;
     private openSingle;
     private openConcurrently;
+    private releasePendingSocketsAfterSetupFailure;
     private bindRuntimeHandlers;
     private handleMessage;
     private normalizePayload;
@@ -33,4 +34,5 @@ export declare class WaWebSocket {
     private handleRuntimeClose;
     private closeSocketSafe;
     private createRawSocket;
+    private resolveNodeWsConstructor;
 }

package/dist/types/transport/binary/constants.d.ts

@@ -17,33 +17,3 @@ export declare const NIBBLE_ALPHABET: readonly string[];
 export declare const HEX_ALPHABET: readonly string[];
 export declare const SINGLE_BYTE_TOKEN_MAP: ReadonlyMap<string, number>;
 export declare const DICTIONARY_TOKEN_MAPS: readonly ReadonlyMap<string, number>[];
-export declare const WAP_ENCODE_CONSTANTS: Readonly<{
-    LIST_EMPTY: 0;
-    LIST_8: 248;
-    LIST_16: 249;
-    JID_PAIR: 250;
-    HEX_8: 251;
-    BINARY_8: 252;
-    BINARY_20: 253;
-    BINARY_32: 254;
-    NIBBLE_8: 255;
-    DICTIONARY_0: 236;
-    DICTIONARY_3: 239;
-}>;
-export declare const WAP_DECODE_CONSTANTS: Readonly<{
-    LIST_EMPTY: 0;
-    LIST_8: 248;
-    LIST_16: 249;
-    JID_PAIR: 250;
-    JID_FB: 246;
-    JID_INTEROP: 245;
-    JID_U: 247;
-    HEX_8: 251;
-    BINARY_8: 252;
-    BINARY_20: 253;
-    BINARY_32: 254;
-    NIBBLE_8: 255;
-    DICTIONARY_0: 236;
-    DICTIONARY_3: 239;
-    STREAM_END: 2;
-}>;

package/dist/types/transport/binary/index.d.ts

@@ -1,4 +1,3 @@
 export * from '../binary/tokens';
 export * from '../binary/encoder';
 export * from '../binary/decoder';
-export { WAP_DECODE_CONSTANTS as WapDecodeConstants, WAP_ENCODE_CONSTANTS as WapEncodeConstants } from '../binary/constants';

package/dist/types/transport/index.d.ts

@@ -1,4 +1,5 @@
-export type { BinaryNode, RawWebSocket, RawWebSocketConstructor, SocketCloseInfo, SocketOpenInfo, WaCommsConfig, WaCommsState, WaNoiseConfig, WaSocketConfig, WaSocketHandlers } from './types';
+export type { BinaryNode, RawWebSocket, RawWebSocketConstructor, WaRawWebSocketInit, SocketCloseInfo, SocketOpenInfo, WaCommsConfig, WaCommsState, WaNoiseConfig, WaProxyAgent, WaProxyDispatcher, WaProxyTransport, WaSocketConfig, WaSocketHandlers } from './types';
+export { isProxyAgent, isProxyDispatcher, isProxyTransport, toProxyAgent, toProxyDispatcher } from './proxy';
 export { WaComms } from './WaComms';
 export { WaWebSocket } from './WaWebSocket';
 export { WaKeepAlive } from './keepalive/WaKeepAlive';