zapo-js 0.1.2 → 0.3.0

package/dist/types/protocol/privacy.d.ts

@@ -0,0 +1,75 @@
+export declare const WA_PRIVACY_CATEGORIES: Readonly<{
+    readonly READ_RECEIPTS: "readreceipts";
+    readonly LAST_SEEN: "last";
+    readonly ONLINE: "online";
+    readonly PROFILE_PICTURE: "profile";
+    readonly ABOUT: "status";
+    readonly GROUP_ADD: "groupadd";
+    readonly CALL_ADD: "calladd";
+    readonly MESSAGES: "messages";
+    readonly DEFENSE_MODE: "defense";
+}>;
+export type WaPrivacyCategory = (typeof WA_PRIVACY_CATEGORIES)[keyof typeof WA_PRIVACY_CATEGORIES];
+export declare const WA_PRIVACY_VALUES: Readonly<{
+    readonly ALL: "all";
+    readonly CONTACTS: "contacts";
+    readonly CONTACT_BLACKLIST: "contact_blacklist";
+    readonly NONE: "none";
+    readonly MATCH_LAST_SEEN: "match_last_seen";
+    readonly KNOWN: "known";
+    readonly OFF: "off";
+    readonly ON_STANDARD: "on_standard";
+    readonly ERROR: "error";
+}>;
+export type WaPrivacyValue = (typeof WA_PRIVACY_VALUES)[keyof typeof WA_PRIVACY_VALUES];
+export declare const WA_PRIVACY_CATEGORY_TO_SETTING: Readonly<{
+    readonly readreceipts: "readReceipts";
+    readonly last: "lastSeen";
+    readonly online: "online";
+    readonly profile: "profilePicture";
+    readonly status: "about";
+    readonly groupadd: "groupAdd";
+    readonly calladd: "callAdd";
+    readonly messages: "messages";
+    readonly defense: "defenseMode";
+}>;
+export declare const WA_PRIVACY_SETTING_TO_CATEGORY: Readonly<{
+    readonly readReceipts: "readreceipts";
+    readonly lastSeen: "last";
+    readonly online: "online";
+    readonly profilePicture: "profile";
+    readonly about: "status";
+    readonly groupAdd: "groupadd";
+    readonly callAdd: "calladd";
+    readonly messages: "messages";
+    readonly defenseMode: "defense";
+}>;
+export type WaPrivacySettingName = keyof typeof WA_PRIVACY_SETTING_TO_CATEGORY;
+export type WaPrivacyVisibility = 'all' | 'contacts' | 'contact_blacklist' | 'none';
+export interface WaPrivacySettingValueMap {
+    readonly readReceipts: 'all' | 'none';
+    readonly lastSeen: WaPrivacyVisibility;
+    readonly online: 'all' | 'none' | 'match_last_seen';
+    readonly profilePicture: WaPrivacyVisibility;
+    readonly about: WaPrivacyVisibility;
+    readonly groupAdd: 'all' | 'contacts' | 'contact_blacklist';
+    readonly callAdd: 'all' | 'known' | 'contacts';
+    readonly messages: 'all' | 'contacts';
+    readonly defenseMode: 'off' | 'on_standard';
+}
+export declare const WA_PRIVACY_DISALLOWED_LIST_CATEGORIES: Readonly<{
+    readonly ABOUT: "status";
+    readonly GROUP_ADD: "groupadd";
+    readonly LAST_SEEN: "last";
+    readonly PROFILE_PICTURE: "profile";
+}>;
+type DisallowedCategoryToSetting = {
+    readonly [K in keyof typeof WA_PRIVACY_DISALLOWED_LIST_CATEGORIES]: (typeof WA_PRIVACY_CATEGORY_TO_SETTING)[(typeof WA_PRIVACY_DISALLOWED_LIST_CATEGORIES)[K]];
+};
+export type WaPrivacyDisallowedListSettingName = DisallowedCategoryToSetting[keyof DisallowedCategoryToSetting];
+export declare const WA_PRIVACY_TAGS: Readonly<{
+    readonly CATEGORY: "category";
+    readonly LIST: "list";
+    readonly USER: "user";
+}>;
+export {};

package/dist/types/protocol/stream.d.ts

@@ -39,6 +39,7 @@ export declare const WA_LOGOUT_REASONS: Readonly<{
     readonly WEB_FAIL_ENC_SALT: "web_fail_enc_salt";
     readonly CACHE_STORAGE_OPEN_FAILED: "cache_storage_open_failed";
 }>;
+export type WaLogoutReason = (typeof WA_LOGOUT_REASONS)[keyof typeof WA_LOGOUT_REASONS];
 export declare const WA_STREAM_SIGNALING: Readonly<{
     readonly STREAM_ERROR_TAG: "stream:error";
     readonly XML_STREAM_END_TAG: "xmlstreamend";
@@ -49,6 +50,18 @@ export declare const WA_STREAM_SIGNALING: Readonly<{
     readonly FORCE_LOGIN_CODE: 515;
     readonly FORCE_LOGOUT_CODE: 516;
 }>;
+export declare const WA_FAILURE_REASONS: Readonly<{
+    readonly GENERIC_FAILURE: 400;
+    readonly NOT_AUTHORIZED: 401;
+    readonly TEMP_BANNED: 402;
+    readonly LOCKED: 403;
+    readonly CLIENT_TOO_OLD: 405;
+    readonly BANNED: 406;
+    readonly BAD_USER_AGENT: 409;
+    readonly INTERNAL_SERVER_ERROR: 500;
+    readonly EXPERIMENTAL: 501;
+    readonly SERVICE_UNAVAILABLE: 503;
+}>;
 export declare const WA_DISCONNECT_REASONS: Readonly<{
     readonly CLIENT_DISCONNECTED: "client_disconnected";
     readonly COMMS_STOPPED: "comms_stopped";
@@ -57,4 +70,22 @@ export declare const WA_DISCONNECT_REASONS: Readonly<{
     readonly STREAM_ERROR_ACK: "stream_error_ack";
     readonly STREAM_ERROR_XML_NOT_WELL_FORMED: "stream_error_xml_not_well_formed";
     readonly STREAM_ERROR_OTHER: "stream_error_other";
+    readonly STREAM_ERROR_FORCE_LOGIN: "stream_error_force_login";
+    readonly STREAM_ERROR_FORCE_LOGOUT: "stream_error_force_logout";
+    readonly FAILURE_LOCKED: "failure_locked";
+    readonly FAILURE_NOT_AUTHORIZED: "failure_not_authorized";
+    readonly FAILURE_BANNED: "failure_banned";
+    readonly FAILURE_CLIENT_TOO_OLD: "failure_client_too_old";
+    readonly FAILURE_BAD_USER_AGENT: "failure_bad_user_agent";
+    readonly FAILURE_SERVICE_UNAVAILABLE: "failure_service_unavailable";
+    readonly PRIMARY_IDENTITY_KEY_CHANGE: "primary_identity_key_change";
+}>;
+export declare const WA_CONNECTION_REASONS: Readonly<{
+    readonly CONNECTED: "connected";
+    readonly RECONNECTED: "reconnected";
 }>;
+export type WaFailureReasonCode = (typeof WA_FAILURE_REASONS)[keyof typeof WA_FAILURE_REASONS];
+export type WaStreamErrorCode = typeof WA_STREAM_SIGNALING.FORCE_LOGIN_CODE | typeof WA_STREAM_SIGNALING.FORCE_LOGOUT_CODE;
+export type WaConnectionCode = WaFailureReasonCode | WaStreamErrorCode;
+export type WaDisconnectReason = (typeof WA_DISCONNECT_REASONS)[keyof typeof WA_DISCONNECT_REASONS];
+export type WaConnectionOpenReason = (typeof WA_CONNECTION_REASONS)[keyof typeof WA_CONNECTION_REASONS];

package/dist/types/retry/codec.d.ts

@@ -0,0 +1,3 @@
+import type { WaRetryReplayPayload } from './types';
+export declare function encodeRetryReplayPayload(payload: WaRetryReplayPayload): Uint8Array;
+export declare function decodeRetryReplayPayload(raw: Uint8Array): WaRetryReplayPayload;

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

@@ -1,8 +1,8 @@
 export { MAX_RETRY_ATTEMPTS, RETRY_KEYS_MIN_COUNT, RETRY_OUTBOUND_TTL_MS, RETRY_REASON, RETRY_RECEIPT_VERSION } from './constants';
 export type { WaRetryReasonCode } from './constants';
 export { mapRetryReasonFromError } from './reason';
-export { parseRetryReceiptRequest } from './parse';
-export type { WaParsedRetryRequest, WaRetryDecryptFailureContext, WaRetryEncryptedReplayPayload, WaRetryKey, WaRetryKeyBundle, WaRetryOpaqueNodeReplayPayload, WaRetryOutboundMessageRecord, WaRetryOutboundMode, WaRetryOutboundState, WaRetryPlaintextReplayPayload, WaRetryReceiptType, WaRetryReplayPayload, WaRetrySignedKey } from './types';
-export { decodeRetryReplayPayload, encodeRetryReplayPayload, pickRetryStateMax } from './outbound';
+export { parseRetryReceiptRequest, pickRetryStateMax } from './parse';
+export type { WaParsedRetryRequest, WaRetryDecryptFailureContext, WaRetryEncryptedReplayPayload, WaRetryKey, WaRetryKeyBundle, WaRetryOpaqueNodeReplayPayload, WaRetryOutboundMessageRecord, WaRetryOutboundMode, WaRetryOutboundState, WaRetryPlaintextReplayPayload, WaRetryReceiptType, WaRetryReplayPayload, WaRetryStoredReplayPayload, WaRetrySignedKey } from './types';
+export { decodeRetryReplayPayload, encodeRetryReplayPayload } from './codec';
 export { WaRetryReplayService, type WaRetryReplayServiceOptions, type WaRetryResendResult } from './replay';
 export { createOutboundRetryTracker, type OutboundRetryTrackHint, type OutboundRetryTracker } from './tracker';

package/dist/types/retry/parse.d.ts

@@ -1,3 +1,6 @@
-import type { WaParsedRetryRequest } from './types';
+import type { WaParsedRetryRequest, WaRetryOutboundState } from './types';
 import type { BinaryNode } from '../transport/types';
-export declare function parseRetryReceiptRequest(node: BinaryNode): WaParsedRetryRequest | null;
+export declare function parseRetryReceiptRequest(node: BinaryNode, options?: {
+    readonly expectedToJids?: readonly string[];
+}): WaParsedRetryRequest | null;
+export declare function pickRetryStateMax(left: WaRetryOutboundState, right: WaRetryOutboundState): WaRetryOutboundState;

package/dist/types/retry/reason.d.ts

@@ -1,2 +1,2 @@
 import { type WaRetryReasonCode } from './constants';
-export declare function mapRetryReasonFromError(error: unknown): WaRetryReasonCode;
+export declare function mapRetryReasonFromError(error: unknown): WaRetryReasonCode | undefined;

package/dist/types/retry/tracker.d.ts

@@ -9,6 +9,7 @@ export type OutboundRetryTrackHint = {
     readonly replayPayload: WaRetryReplayPayload;
     readonly participantJid?: string;
     readonly recipientJid?: string;
+    readonly eligibleRequesterDeviceJids?: readonly string[];
 };
 export type OutboundRetryTracker = {
     track(hint: OutboundRetryTrackHint, publish: () => Promise<WaMessagePublishResult>): Promise<WaMessagePublishResult>;

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

@@ -22,6 +22,8 @@ export interface WaParsedRetryRequest {
     readonly from: string;
     readonly participant?: string;
     readonly recipient?: string;
+    readonly offline: boolean;
+    readonly isLid: boolean;
     readonly originalMsgId: string;
     readonly retryCount: number;
     readonly retryReason?: number;
@@ -56,14 +58,17 @@ export interface WaRetryOpaqueNodeReplayPayload {
     readonly node: Uint8Array;
 }
 export type WaRetryReplayPayload = WaRetryPlaintextReplayPayload | WaRetryEncryptedReplayPayload | WaRetryOpaqueNodeReplayPayload;
+export type WaRetryStoredReplayPayload = Uint8Array | WaRetryReplayPayload;
 export interface WaRetryOutboundMessageRecord {
     readonly messageId: string;
     readonly toJid: string;
     readonly participantJid?: string;
     readonly recipientJid?: string;
+    readonly eligibleRequesterDeviceJids?: readonly string[];
+    readonly deliveredRequesterDeviceJids?: readonly string[];
     readonly messageType: string;
     readonly replayMode: WaRetryOutboundMode;
-    readonly replayPayload: Uint8Array;
+    readonly replayPayload: WaRetryStoredReplayPayload;
     readonly state: WaRetryOutboundState;
     readonly createdAtMs: number;
     readonly updatedAtMs: number;

package/dist/types/signal/api/SignalDeviceSyncApi.d.ts

@@ -22,11 +22,13 @@ export declare class SignalDeviceSyncApi {
     private readonly defaultTimeoutMs;
     private readonly hostDomain;
     private readonly generateSid;
+    private readonly syncDedup;
     constructor(options: SignalDeviceSyncApiOptions);
     syncDeviceList(userJids: readonly string[], timeoutMs?: number): Promise<readonly {
         readonly jid: string;
         readonly deviceJids: readonly string[];
     }[]>;
+    private syncDeviceListInternal;
     queryLidsByPhoneJids(phoneJids: readonly string[], timeoutMs?: number): Promise<readonly SignalLidSyncResult[]>;
     private collectUsersToQuery;
     private makeDeviceSyncRequest;
@@ -38,6 +40,5 @@ export declare class SignalDeviceSyncApi {
     private parseUserDeviceJids;
     private normalizeUsers;
     private normalizeUserJid;
-    private toDeviceJid;
 }
 export {};

package/dist/types/signal/api/SignalDigestSyncApi.d.ts

@@ -1,10 +1,13 @@
 import type { Logger } from '../../infra/log/types';
+import type { RegistrationInfo, SignedPreKeyRecord } from '../types';
+import type { WaPreKeyStore } from '../../store/contracts/pre-key.store';
 import type { WaSignalStore } from '../../store/contracts/signal.store';
 import type { BinaryNode } from '../../transport/types';
 interface SignalDigestSyncApiOptions {
     readonly logger: Logger;
     readonly query: (node: BinaryNode, timeoutMs?: number) => Promise<BinaryNode>;
     readonly signalStore: WaSignalStore;
+    readonly preKeyStore: WaPreKeyStore;
     readonly defaultTimeoutMs?: number;
     readonly hostDomain?: string;
 }
@@ -14,14 +17,20 @@ export interface SignalDigestValidationResult {
     readonly reason: 'ok' | 'missing_remote_digest' | 'unsupported_key_bundle_type' | 'missing_local_state' | 'registration_mismatch' | 'identity_mismatch' | 'signed_prekey_mismatch' | 'missing_local_prekey' | 'hash_mismatch';
     readonly preKeyCount: number;
 }
+export interface SignalDigestPrefetchedLocalKeyBundle {
+    readonly registrationInfo: RegistrationInfo;
+    readonly signedPreKey: SignedPreKeyRecord;
+}
 export declare class SignalDigestSyncApi {
     private readonly logger;
     private readonly query;
     private readonly signalStore;
+    private readonly preKeyStore;
     private readonly defaultTimeoutMs;
     private readonly hostDomain;
     constructor(options: SignalDigestSyncApiOptions);
     validateLocalKeyBundle(timeoutMs?: number): Promise<SignalDigestValidationResult>;
+    validateLocalKeyBundle(prefetched?: SignalDigestPrefetchedLocalKeyBundle, timeoutMs?: number): Promise<SignalDigestValidationResult>;
     private parseDigestPayload;
 }
 export {};

package/dist/types/signal/api/SignalIdentitySyncApi.d.ts

@@ -1,5 +1,5 @@
 import type { Logger } from '../../infra/log/types';
-import type { WaSignalStore } from '../../store/contracts/signal.store';
+import type { WaIdentityStore } from '../../store/contracts/identity.store';
 import type { BinaryNode } from '../../transport/types';
 export interface SignalIdentitySyncEntry {
     readonly jid: string;
@@ -9,18 +9,20 @@ export interface SignalIdentitySyncEntry {
 interface SignalIdentitySyncApiOptions {
     readonly logger: Logger;
     readonly query: (node: BinaryNode, timeoutMs?: number) => Promise<BinaryNode>;
-    readonly signalStore?: WaSignalStore;
+    readonly identityStore?: WaIdentityStore;
     readonly defaultTimeoutMs?: number;
     readonly hostDomain?: string;
 }
 export declare class SignalIdentitySyncApi {
     private readonly logger;
     private readonly query;
-    private readonly signalStore?;
+    private readonly identityStore?;
     private readonly defaultTimeoutMs;
     private readonly hostDomain;
+    private readonly syncDedup;
     constructor(options: SignalIdentitySyncApiOptions);
     syncIdentityKeys(targetJids: readonly string[], timeoutMs?: number): Promise<readonly SignalIdentitySyncEntry[]>;
+    private syncIdentityKeysInternal;
     private parseIdentitySyncResponse;
 }
 export {};

package/dist/types/signal/api/SignalRotateKeyApi.d.ts

@@ -7,16 +7,15 @@ interface SignalRotateKeyApiOptions {
     readonly signalStore: WaSignalStore;
     readonly defaultTimeoutMs?: number;
 }
-export interface SignalRotateKeyResult {
-    readonly shouldDigestKey: boolean;
-    readonly errorCode?: number;
-}
 export declare class SignalRotateKeyApi {
     private readonly logger;
     private readonly query;
     private readonly signalStore;
     private readonly defaultTimeoutMs;
     constructor(options: SignalRotateKeyApiOptions);
-    rotateSignedPreKey(timeoutMs?: number): Promise<SignalRotateKeyResult>;
+    rotateSignedPreKey(timeoutMs?: number): Promise<{
+        shouldDigestKey: boolean;
+        errorCode?: number;
+    }>;
 }
 export {};

package/dist/types/signal/api/SignalSessionSyncApi.d.ts

@@ -7,10 +7,6 @@ interface SignalSessionSyncApiOptions {
     readonly defaultTimeoutMs?: number;
     readonly hostDomain?: string;
 }
-interface SignalSessionSyncTarget {
-    readonly jid: string;
-    readonly reasonIdentity?: boolean;
-}
 export type SignalSessionKeyBundleResult = {
     readonly jid: string;
     readonly bundle: SignalPreKeyBundle;
@@ -26,12 +22,18 @@ export declare class SignalSessionSyncApi {
     private readonly defaultTimeoutMs;
     private readonly hostDomain;
     constructor(options: SignalSessionSyncApiOptions);
-    fetchKeyBundle(target: SignalSessionSyncTarget, timeoutMs?: number): Promise<{
+    fetchKeyBundle(target: {
+        readonly jid: string;
+        readonly reasonIdentity?: boolean;
+    }, timeoutMs?: number): Promise<{
         readonly jid: string;
         readonly bundle: SignalPreKeyBundle;
         readonly deviceIdentity?: Uint8Array;
     }>;
-    fetchKeyBundles(targets: readonly SignalSessionSyncTarget[], timeoutMs?: number): Promise<readonly SignalSessionKeyBundleResult[]>;
+    fetchKeyBundles(targets: readonly {
+        readonly jid: string;
+        readonly reasonIdentity?: boolean;
+    }[], timeoutMs?: number): Promise<readonly SignalSessionKeyBundleResult[]>;
     private parseFetchKeyBundleResponse;
     private parseUserKeyBundle;
 }

package/dist/types/signal/api/result-map.d.ts

@@ -0,0 +1 @@
+export declare function registerParsedResultByRawAndCanonicalKey<T>(parsedByRawKey: Map<string, T>, parsedByCanonicalKey: Map<string, T>, rawKey: string, canonicalKey: string, result: T, isPreferred: (value: T) => boolean): void;

package/dist/types/signal/constants.d.ts

@@ -1,9 +1,6 @@
 export declare const SIGNAL_VERSION = 3;
 export declare const SIGNAL_GROUP_VERSION = 3;
-export declare const SERIALIZED_PUB_KEY_PREFIX = 5;
-export declare const KEY_TYPE_CURVE25519 = 5;
 export declare const SIGNAL_MAC_SIZE = 8;
-export declare const SIGNATURE_SIZE = 64;
 export declare const MAX_PREV_SESSIONS = 40;
 export declare const MAX_UNUSED_KEYS = 2000;
 export declare const FUTURE_MESSAGES_MAX = 2000;

package/dist/types/signal/crypto/WaAdvSignature.d.ts

@@ -1,7 +1,5 @@
 import type { SignalKeyPair } from '../../crypto/curves/types';
 export { ADV_PREFIX_ACCOUNT_SIGNATURE, ADV_PREFIX_DEVICE_SIGNATURE, ADV_PREFIX_HOSTED_ACCOUNT_SIGNATURE, ADV_PREFIX_HOSTED_DEVICE_SIGNATURE } from '../crypto/constants';
-export declare function verifySignalSignature(publicKey: Uint8Array, message: Uint8Array, signature: Uint8Array): Promise<boolean>;
-export declare function signSignalMessage(privateKey: Uint8Array, message: Uint8Array): Promise<Uint8Array>;
 export declare function verifyDeviceIdentityAccountSignature(details: Uint8Array, accountSignature: Uint8Array, identityPublicKey: Uint8Array, accountSignatureKey: Uint8Array, isHosted?: boolean): Promise<boolean>;
 export declare function generateDeviceSignature(details: Uint8Array, identityKeyPair: SignalKeyPair, accountSignatureKey: Uint8Array, isHosted?: boolean): Promise<Uint8Array>;
 export declare function computeAdvIdentityHmac(secretKey: Uint8Array, details: Uint8Array): Promise<Uint8Array>;

package/dist/types/signal/crypto/constants.d.ts

@@ -1,4 +1,3 @@
-export declare const SIGNAL_PREFIX_SIGNATURE_RANDOM: Uint8Array<ArrayBuffer>;
 export declare const ADV_PREFIX_ACCOUNT_SIGNATURE: Uint8Array<ArrayBuffer>;
 export declare const ADV_PREFIX_DEVICE_SIGNATURE: Uint8Array<ArrayBuffer>;
 export declare const ADV_PREFIX_HOSTED_ACCOUNT_SIGNATURE: Uint8Array<ArrayBuffer>;

package/dist/types/signal/{store/sqlite.d.ts → encoding.d.ts}

@@ -1,4 +1,5 @@
-import type { PreKeyRecord, RegistrationInfo, SenderKeyDistributionRecord, SenderKeyRecord, SignalAddress, SignalSessionRecord, SignedPreKeyRecord } from '../types';
+import { type Proto } from '..';
+import type { PreKeyRecord, RegistrationInfo, SenderKeyDistributionRecord, SenderKeyRecord, SignalAddress, SignalMessageKey, SignalRecvChain, SignalSessionRecord, SignalSessionSnapshot, SignedPreKeyRecord } from './types';
 export interface SignalAddressParts {
     readonly user: string;
     readonly server: string;
@@ -51,7 +52,7 @@ export interface SenderKeyDistributionRow extends Record<string, unknown> {
     readonly key_id: unknown;
     readonly timestamp_ms: unknown;
 }
-export interface SqliteCountRow extends Record<string, unknown> {
+export interface StoreCountRow extends Record<string, unknown> {
     readonly count: unknown;
 }
 export declare function toSignalAddressParts(address: SignalAddress): SignalAddressParts;
@@ -63,10 +64,15 @@ export declare function decodeSignalAddressFromRow(row: Pick<SenderKeyRow | Send
 export declare function decodeSignalRegistrationRow(row: SignalRegistrationRow): RegistrationInfo;
 export declare function decodeSignalPreKeyRow(row: SignalPreKeyRow): PreKeyRecord;
 export declare function decodeSignalSignedPreKeyRow(row: SignalSignedPreKeyRow): SignedPreKeyRecord;
+export declare function encodeSignalSessionSnapshot(session: SignalSessionSnapshot): Proto.ISessionStructure;
+export declare function encodeSignalRecvChain(chain: SignalRecvChain): Proto.SessionStructure.IChain;
+export declare function decodeSignalMessageKey(messageKey: Proto.SessionStructure.Chain.IMessageKey, field: string): SignalMessageKey;
+export declare function decodeSignalRecvChain(chain: Proto.SessionStructure.IChain, field: string): SignalRecvChain;
+export declare function decodeSignalSessionSnapshot(session: Proto.ISessionStructure, field: string): SignalSessionSnapshot;
 export declare function encodeSignalSessionRecord(record: SignalSessionRecord): Uint8Array;
 export declare function decodeSignalSessionRecord(raw: unknown): SignalSessionRecord;
 export declare function encodeSenderKeyRecord(record: SenderKeyRecord): Uint8Array;
 export declare function decodeSenderKeyRecord(raw: unknown, groupId: string, sender: SignalAddress): SenderKeyRecord;
 export declare function decodeSenderKeyDistributionRow(row: SenderKeyDistributionRow): SenderKeyDistributionRecord;
-export declare function decodeSqliteCount(row: SqliteCountRow | null, field: string): number;
+export declare function decodeStoreCount(row: StoreCountRow | null, field: string): number;
 export declare function decodeSignalRemoteIdentity(raw: unknown): Uint8Array;

package/dist/types/signal/group/SenderKeyChain.d.ts

@@ -7,5 +7,5 @@ export interface SenderKeyMessageKeySelection {
     readonly messageKey: SenderMessageKey;
     readonly updatedRecord: SenderKeyRecord;
 }
-export declare function selectMessageKey(senderKey: SenderKeyRecord, targetIteration: number): Promise<SenderKeyMessageKeySelection>;
+export declare function selectMessageKey(senderKey: SenderKeyRecord, targetIteration: number, futureMessagesMax?: number): Promise<SenderKeyMessageKeySelection>;
 export declare function deriveSenderKeyMsgKey(iteration: number, chainKey: Uint8Array): Promise<SenderKeyMessageKeyDerivation>;

package/dist/types/signal/group/SenderKeyManager.d.ts

@@ -1,4 +1,4 @@
-import type { Proto } from '../..';
+import { type Proto } from '../..';
 import type { SenderKeyRecord, SignalAddress } from '../types';
 import type { WaSenderKeyStore } from '../../store/contracts/sender-key.store';
 interface GroupSenderKeyCiphertext {
@@ -10,13 +10,23 @@ interface GroupSenderKeyCiphertext {
 }
 export declare class SenderKeyManager {
     private readonly store;
-    constructor(store: WaSenderKeyStore);
-    createSenderKeyDistributionMessage(groupId: string, sender: SignalAddress): Promise<Proto.Message.ISenderKeyDistributionMessage>;
-    filterParticipantsNeedingDistribution(groupId: string, sender: SignalAddress, participants: readonly SignalAddress[]): Promise<readonly SignalAddress[]>;
-    markSenderKeyDistributed(groupId: string, sender: SignalAddress, participants: readonly SignalAddress[]): Promise<void>;
+    private readonly senderLock;
+    private readonly getFutureMessagesMax;
+    private readonly skipSignatureVerification;
+    constructor(store: WaSenderKeyStore, options?: {
+        readonly getFutureMessagesMax?: () => number;
+        readonly skipSignatureVerification?: boolean;
+    });
+    prepareGroupEncryption(groupId: string, sender: SignalAddress, plaintext: Uint8Array): Promise<{
+        readonly distributionMessage: Proto.Message.ISenderKeyDistributionMessage;
+        readonly ciphertext: GroupSenderKeyCiphertext;
+        readonly keyId: number;
+    }>;
+    filterParticipantsNeedingDistribution(groupId: string, senderKeyId: number, participants: readonly SignalAddress[]): Promise<readonly SignalAddress[]>;
+    markSenderKeyDistributed(groupId: string, senderKeyId: number, participants: readonly SignalAddress[]): Promise<void>;
     processSenderKeyDistributionPayload(groupId: string, sender: SignalAddress, payload: Uint8Array): Promise<SenderKeyRecord>;
-    encryptGroupMessage(groupId: string, sender: SignalAddress, plaintext: Uint8Array): Promise<GroupSenderKeyCiphertext>;
     decryptGroupMessage(payload: GroupSenderKeyCiphertext): Promise<Uint8Array>;
-    private ensureSenderKey;
+    private ensureSenderKeyInternal;
+    private runWithSenderLock;
 }
 export {};

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

@@ -1,4 +1,6 @@
 export { PreKeyRecord, RegistrationInfo, SenderKeyDistributionRecord, SenderKeyRecord, SignalAddress, SignalPreKeyBundle, SignedPreKeyRecord } from './types';
+export type { SignalSessionRecord } from './types';
+export { decodeSignalPreKeyRow, decodeSignalRegistrationRow, decodeSignalRemoteIdentity, decodeSignalSessionRecord, decodeSignalSignedPreKeyRow, decodeSenderKeyDistributionRow, decodeSenderKeyRecord, decodeStoreCount, encodeSenderKeyRecord, encodeSignalSessionRecord, toSignalAddressParts, type SenderKeyDistributionRow, type SenderKeyRow, type SignalAddressParts, type SignalIdentityRow, type SignalMetaRow, type SignalPreKeyRow, type SignalRegistrationRow, type SignalSessionRow, type SignalSignedPreKeyRow, type StoreCountRow } from './encoding';
 export { generatePreKeyPair, generateRegistrationId, generateRegistrationInfo, generateSignedPreKey } from './registration/keygen';
 export { buildPreKeyUploadIq, parsePreKeyUploadFailure } from './api/prekeys';
 export { SignalDigestSyncApi } from './api/SignalDigestSyncApi';

package/dist/types/signal/registration/utils.d.ts

@@ -1,9 +1,10 @@
 import type { PreKeyRecord, RegistrationInfo, SignedPreKeyRecord } from '../types';
+import type { WaPreKeyStore } from '../../store/contracts/pre-key.store';
 import type { WaSignalStore } from '../../store/contracts/signal.store';
 interface RegistrationBundle {
     readonly registrationInfo: RegistrationInfo;
     readonly signedPreKey: SignedPreKeyRecord;
     readonly firstPreKey: PreKeyRecord;
 }
-export declare function createAndStoreInitialKeys(store: WaSignalStore): Promise<RegistrationBundle>;
+export declare function createAndStoreInitialKeys(store: WaSignalStore, preKeyStore: WaPreKeyStore): Promise<RegistrationBundle>;
 export {};

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

@@ -1,13 +1,24 @@
 import type { Logger } from '../../infra/log/types';
 import type { SignalAddress, SignalPreKeyBundle, SignalSessionRecord } from '../types';
+import type { WaIdentityStore } from '../../store/contracts/identity.store';
+import type { WaPreKeyStore } from '../../store/contracts/pre-key.store';
+import type { WaSessionStore } from '../../store/contracts/session.store';
 import type { WaSignalStore } from '../../store/contracts/signal.store';
+interface EstablishOutgoingSessionOptions {
+    readonly reuseExisting?: boolean;
+}
+export interface SignalProtocolStores {
+    readonly signal: WaSignalStore;
+    readonly preKey: WaPreKeyStore;
+    readonly session: WaSessionStore;
+    readonly identity: WaIdentityStore;
+}
 export declare class SignalProtocol {
-    private readonly store;
+    private readonly stores;
     private readonly logger;
-    constructor(store: WaSignalStore, logger?: Logger);
-    hasSession(address: SignalAddress): Promise<boolean>;
-    hasSessions(addresses: readonly SignalAddress[]): Promise<readonly boolean[]>;
-    establishOutgoingSession(address: SignalAddress, remoteBundle: SignalPreKeyBundle): Promise<SignalSessionRecord>;
+    private readonly sessionMutationLock;
+    constructor(stores: SignalProtocolStores, logger?: Logger);
+    establishOutgoingSession(address: SignalAddress, remoteBundle: SignalPreKeyBundle, options?: EstablishOutgoingSessionOptions): Promise<SignalSessionRecord>;
     encryptMessage(address: SignalAddress, plaintext: Uint8Array, expectedIdentity?: Uint8Array): Promise<{
         readonly type: 'msg' | 'pkmsg';
         readonly ciphertext: Uint8Array;
@@ -17,6 +28,9 @@ export declare class SignalProtocol {
         readonly address: SignalAddress;
         readonly plaintext: Uint8Array;
         readonly expectedIdentity?: Uint8Array;
+    }[], prefetchedSessions?: readonly {
+        readonly address: SignalAddress;
+        readonly session: SignalSessionRecord;
     }[]): Promise<readonly {
         readonly type: 'msg' | 'pkmsg';
         readonly ciphertext: Uint8Array;
@@ -26,6 +40,7 @@ export declare class SignalProtocol {
         readonly type: 'msg' | 'pkmsg';
         readonly ciphertext: Uint8Array;
     }): Promise<Uint8Array>;
-    private decryptMsgInternal;
+    private runWithAddressLock;
     private decryptPkMsg;
 }
+export {};

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

@@ -1,6 +1,7 @@
 import type { ParsedPreKeySignalMessage, ParsedSignalMessage, PreKeyRecord, SignedPreKeyRecord } from '../types';
+import type { WaPreKeyStore } from '../../store/contracts/pre-key.store';
 import type { WaSignalStore } from '../../store/contracts/signal.store';
 export declare function deserializeMsg(versionContentMac: Uint8Array): ParsedSignalMessage;
 export declare function deserializePkMsg(versionContent: Uint8Array): ParsedPreKeySignalMessage;
 export declare function requireSignedPreKey(store: WaSignalStore, id: number): Promise<SignedPreKeyRecord>;
-export declare function requirePreKey(store: WaSignalStore, id: number): Promise<PreKeyRecord>;
+export declare function requirePreKey(store: WaPreKeyStore, id: number): Promise<PreKeyRecord>;

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

@@ -2,15 +2,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 } from '../types';
-import type { WaSignalStore } from '../../store/contracts/signal.store';
+import type { SignalAddress, SignalSessionRecord } from '../types';
+import type { WaIdentityStore } from '../../store/contracts/identity.store';
+import type { WaSessionStore } from '../../store/contracts/session.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<void>;
+    ensureSessionsBatch(targetJids: readonly string[], expectedIdentityByJid?: ReadonlyMap<string, Uint8Array>): Promise<readonly SignalResolvedSessionTarget[]>;
 };
 export declare function createSignalSessionResolver(options: {
     readonly signalProtocol: SignalProtocol;
-    readonly signalStore: WaSignalStore;
+    readonly sessionStore: WaSessionStore;
+    readonly identityStore: WaIdentityStore;
     readonly signalIdentitySync: SignalIdentitySyncApi;
     readonly signalSessionSync: SignalSessionSyncApi;
     readonly logger: Logger;

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

@@ -1,4 +1,5 @@
 import type { SignalKeyPair } from '../crypto/curves/types';
+import type { Proto } from '..';
 export interface RegistrationInfo {
     readonly registrationId: number;
     readonly identityKeyPair: SignalKeyPair;
@@ -37,8 +38,14 @@ export interface SignalRecvChain {
     readonly ratchetPubKey: Uint8Array;
     readonly nextMsgIndex: number;
     readonly chainKey: Uint8Array;
-    readonly unusedMsgKeys: readonly SignalMessageKey[];
-}
+    readonly unusedMsgKeys: readonly Proto.SessionStructure.Chain.IMessageKey[];
+}
+/**
+ * Raw protobuf recv chain kept as-is to avoid eager decode.
+ * Use {@link decodeSignalRecvChain} only for the chain that
+ * actually needs to be read/modified.
+ */
+export type RawSignalRecvChain = Proto.SessionStructure.IChain;
 export interface SignalSendChain {
     readonly ratchetKey: SignalSerializedKeyPair;
     readonly nextMsgIndex: number;
@@ -54,14 +61,19 @@ export interface SignalSessionSnapshot {
     readonly remote: SignalPeer;
     readonly rootKey: Uint8Array;
     readonly sendChain: SignalSendChain;
-    readonly recvChains: readonly SignalRecvChain[];
+    readonly recvChains: readonly RawSignalRecvChain[];
     readonly initialExchangeInfo: SignalInitialExchangeInfo | null;
     readonly prevSendChainHighestIndex: number;
     readonly aliceBaseKey: Uint8Array | null;
 }
 export interface SignalSessionRecord extends SignalSessionSnapshot {
-    readonly prevSessions: readonly SignalSessionSnapshot[];
+    readonly prevSessions: readonly RawSignalSessionSnapshot[];
 }
+/**
+ * Raw protobuf session snapshot kept as-is to avoid eager decode.
+ * Only decoded on demand in rare fallback paths (session mismatch).
+ */
+export type RawSignalSessionSnapshot = Proto.ISessionStructure;
 export interface SignalPreKeyBundle {
     readonly regId: number;
     readonly identity: Uint8Array;

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

@@ -14,7 +14,7 @@ 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>;

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

@@ -0,0 +1,11 @@
+import type { SignalAddress } from '../../signal/types';
+export interface WaIdentityStore {
+    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;
+        readonly identityKey: Uint8Array;
+    }[]): Promise<void>;
+    clear(): Promise<void>;
+}