zapo-js 0.1.1 → 0.2.0

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

@@ -11,6 +11,66 @@ export declare const WA_MESSAGE_TYPES: Readonly<{
     readonly ACK_TYPE_ERROR: "error";
     readonly ACK_CLASS_ERROR: "error";
     readonly ACK_CLASS_MESSAGE: "message";
+    readonly RECEIPT_TYPE_DELIVERY: "delivery";
+    readonly RECEIPT_TYPE_SENDER: "sender";
+    readonly RECEIPT_TYPE_INACTIVE: "inactive";
+    readonly RECEIPT_TYPE_READ: "read";
+    readonly RECEIPT_TYPE_READ_SELF: "read-self";
+    readonly RECEIPT_TYPE_PLAYED: "played";
+    readonly RECEIPT_TYPE_PLAYED_SELF: "played-self";
+    readonly RECEIPT_TYPE_HISTORY_SYNC: "hist_sync";
     readonly RECEIPT_TYPE_PEER: "peer_msg";
+    readonly RECEIPT_TYPE_SERVER_ERROR: "server-error";
+    readonly RECEIPT_TYPE_RETRY: "retry";
 }>;
 export declare const WA_RETRYABLE_ACK_CODES: readonly ["408", "429", "500", "503"];
+export declare const WA_STANZA_MSG_TYPES: Readonly<{
+    readonly TEXT: "text";
+    readonly MEDIA: "media";
+    readonly MEDIA_NOTIFY: "medianotify";
+    readonly PAY: "pay";
+    readonly POLL: "poll";
+    readonly REACTION: "reaction";
+    readonly EVENT: "event";
+}>;
+export declare const WA_EDIT_ATTRS: Readonly<{
+    readonly MESSAGE_EDIT: "1";
+    readonly PIN_IN_CHAT: "2";
+    readonly SENDER_REVOKE: "7";
+    readonly ADMIN_REVOKE: "8";
+}>;
+export declare const WA_POLL_META_TYPES: Readonly<{
+    readonly CREATION: "creation";
+    readonly VOTE: "vote";
+    readonly RESULT_SNAPSHOT: "result_snapshot";
+    readonly EDIT: "edit";
+}>;
+export declare const WA_EVENT_META_TYPES: Readonly<{
+    readonly CREATION: "creation";
+    readonly RESPONSE: "response";
+    readonly EDIT: "edit";
+}>;
+export declare const WA_ENC_MEDIA_TYPES: Readonly<{
+    readonly IMAGE: "image";
+    readonly VIDEO: "video";
+    readonly PTV: "ptv";
+    readonly AUDIO: "audio";
+    readonly PTT: "ptt";
+    readonly LOCATION: "location";
+    readonly LIVE_LOCATION: "livelocation";
+    readonly VCARD: "vcard";
+    readonly CONTACT_ARRAY: "contact_array";
+    readonly DOCUMENT: "document";
+    readonly URL: "url";
+    readonly GIF: "gif";
+    readonly STICKER: "sticker";
+    readonly STICKER_PACK: "sticker_pack";
+    readonly LIST: "list";
+    readonly LIST_RESPONSE: "list_response";
+    readonly BUTTON: "button";
+    readonly BUTTON_RESPONSE: "buttons_response";
+    readonly ORDER: "order";
+    readonly PRODUCT: "product";
+    readonly NATIVE_FLOW_RESPONSE: "native_flow_response";
+    readonly GROUP_HISTORY: "group_history";
+}>;

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

@@ -23,6 +23,8 @@ export declare const WA_NODE_TAGS: Readonly<{
     readonly KEY_FETCH: "key_fetch";
     readonly LIST: "list";
     readonly USER: "user";
+    readonly CONTACT: "contact";
+    readonly LID: "lid";
     readonly PICTURE: "picture";
     readonly PRIVACY: "privacy";
     readonly PARTICIPATING: "participating";
@@ -76,6 +78,8 @@ export declare const WA_XMLNS: Readonly<{
     readonly PRIVACY: "privacy";
     readonly BLOCKLIST: "blocklist";
     readonly USYNC: "usync";
+    readonly BUSINESS: "w:biz";
+    readonly STATUS: "status";
     readonly GROUPS: "w:g2";
     readonly NEWSLETTER: "newsletter";
     readonly XMPP_PING: "urn:xmpp:ping";

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

@@ -1,5 +1,7 @@
 export declare const WA_NOTIFICATION_TYPES: Readonly<{
     readonly GROUP: "w:gp2";
+    readonly ENCRYPT: "encrypt";
+    readonly DEVICES: "devices";
 }>;
 export declare const WA_GROUP_NOTIFICATION_TAGS: Readonly<{
     readonly REMOVE: "remove";

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

@@ -0,0 +1,17 @@
+export declare const WA_PRIVACY_TOKEN_TYPES: Readonly<{
+    readonly TRUSTED_CONTACT: "trusted_contact";
+}>;
+export declare const WA_PRIVACY_TOKEN_TAGS: Readonly<{
+    readonly TOKENS: "tokens";
+    readonly TOKEN: "token";
+    readonly TC_TOKEN: "tctoken";
+    readonly CS_TOKEN: "cstoken";
+}>;
+export declare const WA_PRIVACY_TOKEN_NOTIFICATION_TYPE = "privacy_token";
+export declare const WA_TC_TOKEN_DEFAULTS: Readonly<{
+    readonly DURATION_S: 604800;
+    readonly NUM_BUCKETS: 4;
+    readonly SENDER_DURATION_S: 604800;
+    readonly SENDER_NUM_BUCKETS: 4;
+    readonly MAX_DURATION_S: 15552000;
+}>;

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

@@ -49,6 +49,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 +69,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/protocol/usync.d.ts

@@ -0,0 +1,11 @@
+export declare const WA_USYNC_MODES: Readonly<{
+    readonly QUERY: "query";
+}>;
+export declare const WA_USYNC_CONTEXTS: Readonly<{
+    readonly INTERACTIVE: "interactive";
+    readonly NOTIFICATION: "notification";
+}>;
+export declare const WA_USYNC_DEFAULTS: Readonly<{
+    readonly INDEX: "0";
+    readonly LAST: "true";
+}>;

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,7 +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/replay.d.ts

@@ -22,9 +22,5 @@ export declare class WaRetryReplayService {
     private resendOpaquePayload;
     private maybeWrapGroupRetryPlaintextForSelfDevice;
     private isRequesterCurrentAccount;
-    private get logger();
-    private get messageClient();
-    private get signalProtocol();
-    private getCurrentSignedIdentity;
     private isOpaqueReplayCompatible;
 }

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

@@ -0,0 +1,20 @@
+import type { Logger } from '../infra/log/types';
+import type { WaMessagePublishResult } from '../message/types';
+import type { WaRetryReplayPayload } from './types';
+import type { WaRetryStore } from '../store/contracts/retry.store';
+export type OutboundRetryTrackHint = {
+    readonly messageIdHint?: string;
+    readonly toJid?: string;
+    readonly type: string;
+    readonly replayPayload: WaRetryReplayPayload;
+    readonly participantJid?: string;
+    readonly recipientJid?: string;
+    readonly eligibleRequesterDeviceJids?: readonly string[];
+};
+export type OutboundRetryTracker = {
+    track(hint: OutboundRetryTrackHint, publish: () => Promise<WaMessagePublishResult>): Promise<WaMessagePublishResult>;
+};
+export declare function createOutboundRetryTracker(options: {
+    readonly retryStore: WaRetryStore;
+    readonly logger: Logger;
+}): OutboundRetryTracker;

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

@@ -5,15 +5,16 @@ export type WaRetryOutboundState = 'pending' | 'delivered' | 'read' | 'played' |
 export interface WaRetryKey {
     readonly id: number;
     readonly publicKey: Uint8Array;
+    readonly signature?: Uint8Array;
 }
-export interface WaRetrySignedKey extends WaRetryKey {
+export type WaRetrySignedKey = WaRetryKey & {
     readonly signature: Uint8Array;
-}
+};
 export interface WaRetryKeyBundle {
     readonly identity: Uint8Array;
     readonly deviceIdentity?: Uint8Array;
     readonly key?: WaRetryKey;
-    readonly skey: WaRetrySignedKey;
+    readonly skey: WaRetryKey;
 }
 export interface WaParsedRetryRequest {
     readonly type: WaRetryReceiptType;
@@ -21,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;
@@ -55,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

@@ -1,5 +1,6 @@
 import type { Logger } from '../../infra/log/types';
 import type { WaDeviceListStore } from '../../store/contracts/device-list.store';
+import { type WaUsyncSidGenerator } from '../../transport/node/usync';
 import type { BinaryNode } from '../../transport/types';
 interface SignalDeviceSyncApiOptions {
     readonly logger: Logger;
@@ -7,6 +8,12 @@ interface SignalDeviceSyncApiOptions {
     readonly deviceListStore?: WaDeviceListStore;
     readonly defaultTimeoutMs?: number;
     readonly hostDomain?: string;
+    readonly generateSid?: WaUsyncSidGenerator;
+}
+export interface SignalLidSyncResult {
+    readonly phoneJid: string;
+    readonly lidJid: string | null;
+    readonly exists: boolean;
 }
 export declare class SignalDeviceSyncApi {
     private readonly logger;
@@ -14,18 +21,24 @@ export declare class SignalDeviceSyncApi {
     private readonly deviceListStore?;
     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;
+    private makeLidSyncRequest;
     private parseDeviceSyncResponse;
+    private parseLidSyncResponse;
+    private buildLidSyncResult;
+    private parseLidSyncContactExists;
     private parseUserDeviceJids;
     private normalizeUsers;
     private normalizeUserJid;
-    private toDeviceJid;
-    private makeSid;
 }
 export {};

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

@@ -1,4 +1,5 @@
 import type { Logger } from '../../infra/log/types';
+import type { RegistrationInfo, SignedPreKeyRecord } from '../types';
 import type { WaSignalStore } from '../../store/contracts/signal.store';
 import type { BinaryNode } from '../../transport/types';
 interface SignalDigestSyncApiOptions {
@@ -14,6 +15,10 @@ 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;
@@ -22,6 +27,7 @@ export declare class SignalDigestSyncApi {
     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

@@ -19,8 +19,10 @@ export declare class SignalIdentitySyncApi {
     private readonly signalStore?;
     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/{store/sqlite.d.ts → encoding.d.ts}

@@ -1,4 +1,4 @@
-import type { PreKeyRecord, RegistrationInfo, SenderKeyDistributionRecord, SenderKeyRecord, SignalAddress, SignalSessionRecord, SignedPreKeyRecord } from '../types';
+import type { PreKeyRecord, RegistrationInfo, SenderKeyDistributionRecord, SenderKeyRecord, SignalAddress, SignalSessionRecord, SignedPreKeyRecord } from './types';
 export interface SignalAddressParts {
     readonly user: string;
     readonly server: string;
@@ -51,7 +51,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;
@@ -68,5 +68,5 @@ export declare function decodeSignalSessionRecord(raw: unknown): SignalSessionRe
 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/SenderKeyCodec.d.ts

@@ -1,14 +1,12 @@
-export interface ParsedDistributionPayload {
+export declare function parseDistributionPayload(payload: Uint8Array): {
     readonly keyId: number;
     readonly iteration: number;
     readonly chainKey: Uint8Array;
     readonly signingPublicKey: Uint8Array;
-}
-export interface ParsedSenderKeyMessage {
+};
+export declare function parseSenderKeyMessage(versionContentMac: Uint8Array): {
     readonly keyId: number;
     readonly iteration: number;
     readonly ciphertext: Uint8Array;
     readonly versionContentMac: Uint8Array;
-}
-export declare function parseDistributionPayload(payload: Uint8Array): ParsedDistributionPayload;
-export declare function parseSenderKeyMessage(versionContentMac: Uint8Array): ParsedSenderKeyMessage;
+};

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

@@ -10,13 +10,18 @@ interface GroupSenderKeyCiphertext {
 }
 export declare class SenderKeyManager {
     private readonly store;
+    private readonly senderLock;
     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>;
+    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';
@@ -10,3 +12,4 @@ export { SignalSessionSyncApi } from './api/SignalSessionSyncApi';
 export { SenderKeyManager } from './group/SenderKeyManager';
 export { createAndStoreInitialKeys } from './registration/utils';
 export { SignalProtocol } from './session/SignalProtocol';
+export { createSignalSessionResolver, type SignalSessionResolver } from './session/resolver';

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

@@ -1,22 +1,37 @@
 import type { Logger } from '../../infra/log/types';
 import type { SignalAddress, SignalPreKeyBundle, SignalSessionRecord } from '../types';
 import type { WaSignalStore } from '../../store/contracts/signal.store';
+interface EstablishOutgoingSessionOptions {
+    readonly reuseExisting?: boolean;
+}
 export declare class SignalProtocol {
     private readonly store;
     private readonly logger;
+    private readonly sessionMutationLock;
     constructor(store: WaSignalStore, logger?: Logger);
-    hasSession(address: SignalAddress): Promise<boolean>;
-    hasSessions(addresses: readonly SignalAddress[]): Promise<readonly boolean[]>;
-    establishOutgoingSession(address: SignalAddress, remoteBundle: SignalPreKeyBundle): Promise<SignalSessionRecord>;
+    establishOutgoingSession(address: SignalAddress, remoteBundle: SignalPreKeyBundle, options?: EstablishOutgoingSessionOptions): Promise<SignalSessionRecord>;
     encryptMessage(address: SignalAddress, plaintext: Uint8Array, expectedIdentity?: Uint8Array): Promise<{
         readonly type: 'msg' | 'pkmsg';
         readonly ciphertext: Uint8Array;
         readonly baseKey: Uint8Array | null;
     }>;
+    encryptMessagesBatch(requests: readonly {
+        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;
+        readonly baseKey: Uint8Array | null;
+    }[]>;
     decryptMessage(address: SignalAddress, envelope: {
         readonly type: 'msg' | 'pkmsg';
         readonly ciphertext: Uint8Array;
     }): Promise<Uint8Array>;
-    private decryptMsgInternal;
+    private runWithAddressLock;
     private decryptPkMsg;
 }
+export {};