zapo-js 0.1.1 → 0.2.0

package/dist/types/client/WaClient.d.ts

@@ -2,14 +2,19 @@ import { EventEmitter } from 'node:events';
 import type { WaAppStateStoreData, WaAppStateSyncResult } from '../appstate/types';
 import type { WaAppStateSyncOptions } from '../appstate/types';
 import type { WaAppStateSyncClient } from '../appstate/WaAppStateSyncClient';
-import type { WaAuthCredentials } from '../auth/types';
+import type { WaAppStateMutationCoordinator } from './coordinators/WaAppStateMutationCoordinator';
+import type { WaBusinessCoordinator } from './coordinators/WaBusinessCoordinator';
 import type { WaGroupCoordinator } from './coordinators/WaGroupCoordinator';
 import type { WaMessageDispatchCoordinator } from './coordinators/WaMessageDispatchCoordinator';
-import type { WaClientEventMap, WaClientOptions, WaSendMessageOptions, WaIncomingNodeHandlerRegistration } from './types';
+import type { WaPrivacyCoordinator } from './coordinators/WaPrivacyCoordinator';
+import type { WaProfileCoordinator } from './coordinators/WaProfileCoordinator';
+import type { WriteBehindDrainResult } from './persistence/WriteBehindPersistence';
+import type { WaClientOptions, WaSendMessageOptions, WaClientEventMap, WaIncomingNodeHandlerRegistration } from './types';
 import type { Logger } from '../infra/log/types';
 import type { WaMediaTransferClient } from '../media/WaMediaTransferClient';
 import type { WaMessagePublishResult, WaSendMessageContent, WaSendReceiptInput } from '../message/types';
 import type { WaMessageClient } from '../message/WaMessageClient';
+import type { SignalLidSyncResult } from '../signal/api/SignalDeviceSyncApi';
 import type { BinaryNode } from '../transport/types';
 export declare class WaClient extends EventEmitter {
     private readonly options;
@@ -18,6 +23,7 @@ export declare class WaClient extends EventEmitter {
     private readonly contactStore;
     private readonly messageStore;
     private readonly participantsStore;
+    private readonly privacyTokenStore;
     private readonly deviceListStore;
     private readonly retryStore;
     private readonly signalStore;
@@ -25,36 +31,45 @@ export declare class WaClient extends EventEmitter {
     private readonly threadStore;
     private readonly authClient;
     private readonly nodeOrchestrator;
-    private readonly keepAlive;
     private readonly nodeTransport;
+    private readonly signalDeviceSync;
     readonly appStateSync: WaAppStateSyncClient;
+    readonly chatCoordinator: WaAppStateMutationCoordinator;
     private readonly incomingNode;
-    private readonly passiveTasks;
     readonly mediaTransfer: WaMediaTransferClient;
     readonly messageDispatch: WaMessageDispatchCoordinator;
     readonly messageClient: WaMessageClient;
     readonly groupCoordinator: WaGroupCoordinator;
-    private clockSkewMs;
-    private mediaConnCache;
-    private comms;
-    private pairingReconnectPromise;
+    readonly privacyCoordinator: WaPrivacyCoordinator;
+    readonly profileCoordinator: WaProfileCoordinator;
+    readonly businessCoordinator: WaBusinessCoordinator;
+    private readonly passiveTasks;
+    private readonly keepAlive;
+    private readonly receiptQueue;
+    private readonly keyShareCoordinator;
+    private readonly connectionManager;
+    private readonly trustedContactToken;
+    private readonly writeBehind;
     private connectPromise;
-    private readonly danglingReceipts;
-    private readonly appStateKeyShareWaiters;
-    private appStateKeyShareVersion;
-    private appStateBootstrapKeyShareWaitDone;
+    private acceptingIncomingEvents;
+    private activeIncomingHandlers;
+    private readonly incomingHandlersDrainedWaiters;
     constructor(options: WaClientOptions, logger?: Logger);
     on<K extends keyof WaClientEventMap>(event: K, listener: WaClientEventMap[K]): this;
+    on(event: string | symbol, listener: (...args: unknown[]) => void): this;
     once<K extends keyof WaClientEventMap>(event: K, listener: WaClientEventMap[K]): this;
+    once(event: string | symbol, listener: (...args: unknown[]) => void): this;
     off<K extends keyof WaClientEventMap>(event: K, listener: WaClientEventMap[K]): this;
-    emit<K extends keyof WaClientEventMap>(event: K, ...args: Parameters<WaClientEventMap[K]>): boolean;
+    off(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    emit<K extends keyof WaClientEventMap>(event: K, payload: Parameters<WaClientEventMap[K]>[0]): boolean;
+    emit(event: string | symbol, ...args: unknown[]): boolean;
     getState(): {
         connected: boolean;
         registered: boolean;
         hasQr: boolean;
         hasPairingCode: boolean;
     };
-    getCredentials(): WaAuthCredentials | null;
+    getCredentials(): import("../auth").WaAuthCredentials | null;
     getClockSkewMs(): number | null;
     sendNode(node: BinaryNode): Promise<void>;
     query(node: BinaryNode, timeoutMs?: number): Promise<BinaryNode>;
@@ -70,28 +85,30 @@ export declare class WaClient extends EventEmitter {
     private queryWithContext;
     private handleIncomingFrame;
     connect(): Promise<void>;
-    private connectInternal;
-    private scheduleReconnectAfterPairing;
-    private reconnectAsRegisteredAfterPairing;
-    private reconnectAsRegisteredAfterPairingInternal;
     disconnect(): Promise<void>;
     requestPairingCode(phoneNumber: string, shouldShowPushNotification?: boolean): Promise<string>;
     fetchPairingCountryCodeIso(): Promise<string>;
+    getLidsByPhoneNumbers(phoneNumbers: readonly string[]): Promise<readonly SignalLidSyncResult[]>;
     sendMessage(to: string, content: WaSendMessageContent, options?: WaSendMessageOptions): Promise<WaMessagePublishResult>;
     syncSignalSession(jid: string, reasonIdentity?: boolean): Promise<void>;
+    get chat(): WaAppStateMutationCoordinator;
+    get group(): WaGroupCoordinator;
+    get privacy(): WaPrivacyCoordinator;
+    get profile(): WaProfileCoordinator;
+    get business(): WaBusinessCoordinator;
     sendReceipt(input: WaSendReceiptInput): Promise<void>;
+    flushAppStateMutations(): Promise<void>;
+    flushWriteBehind(timeoutMs?: number): Promise<WriteBehindDrainResult>;
     exportAppState(): Promise<WaAppStateStoreData>;
     syncAppState(options?: WaAppStateSyncOptions): Promise<WaAppStateSyncResult>;
     private executeAppStateSync;
     private getBlockedAppStateCollections;
-    private waitForAppStateKeyShare;
-    private notifyAppStateKeyShareWaiters;
     private emitChatEventsFromAppStateSyncResult;
-    private startCommsWithCredentials;
-    private shouldQueueDanglingReceipt;
-    private enqueueDanglingReceipt;
+    private handleNctSaltMutation;
     private clearStoredState;
+    private tryEnterIncomingHandler;
+    private leaveIncomingHandler;
+    private pauseIncomingEventsAndWaitDrain;
+    private notifyIncomingHandlersDrained;
     private handleError;
-    private clearCommsBinding;
-    private updateClockSkewFromSuccess;
 }

package/dist/types/client/WaClientFactory.d.ts

@@ -1,15 +1,23 @@
+import type { WaAppStateSyncOptions, WaAppStateSyncResult } from '../appstate/types';
 import { WaAppStateSyncClient } from '../appstate/WaAppStateSyncClient';
 import { WaAuthClient } from '../auth/WaAuthClient';
+import { WaConnectionManager } from './connection/WaConnectionManager';
+import { WaKeyShareCoordinator } from './connection/WaKeyShareCoordinator';
+import { WaReceiptQueue } from './connection/WaReceiptQueue';
+import { WaAppStateMutationCoordinator } from './coordinators/WaAppStateMutationCoordinator';
+import { type WaBusinessCoordinator } from './coordinators/WaBusinessCoordinator';
 import { type WaGroupCoordinator } from './coordinators/WaGroupCoordinator';
 import { WaIncomingNodeCoordinator } from './coordinators/WaIncomingNodeCoordinator';
 import { WaMessageDispatchCoordinator } from './coordinators/WaMessageDispatchCoordinator';
 import { WaPassiveTasksCoordinator } from './coordinators/WaPassiveTasksCoordinator';
+import { type WaPrivacyCoordinator } from './coordinators/WaPrivacyCoordinator';
+import { type WaProfileCoordinator } from './coordinators/WaProfileCoordinator';
 import { WaRetryCoordinator } from './coordinators/WaRetryCoordinator';
 import { type WaStreamControlHandler } from './coordinators/WaStreamControlCoordinator';
-import { buildMediaMessageContent } from './messages';
+import { WaTrustedContactTokenCoordinator } from './coordinators/WaTrustedContactTokenCoordinator';
+import { type WaMediaMessageOptions } from './messages';
 import type { WaClientEventMap, WaClientOptions, WaIncomingMessageEvent } from './types';
 import type { Logger } from '../infra/log/types';
-import type { WaMediaConn } from '../media/types';
 import { WaMediaTransferClient } from '../media/WaMediaTransferClient';
 import { WaMessageClient } from '../message/WaMessageClient';
 import { SignalDeviceSyncApi } from '../signal/api/SignalDeviceSyncApi';
@@ -24,19 +32,30 @@ import { WaKeepAlive } from '../transport/keepalive/WaKeepAlive';
 import { WaNodeOrchestrator } from '../transport/node/WaNodeOrchestrator';
 import { WaNodeTransport } from '../transport/node/WaNodeTransport';
 import type { BinaryNode } from '../transport/types';
-import type { WaComms } from '../transport/WaComms';
-type WaMediaMessageBuildOptions = Parameters<typeof buildMediaMessageContent>[0];
 interface WaClientBase {
     readonly options: Readonly<WaClientOptions>;
     readonly logger: Logger;
     readonly sessionStore: ReturnType<WaClientOptions['store']['session']>;
 }
+interface WaClientBuildRuntime {
+    readonly sendNode: (node: BinaryNode) => Promise<void>;
+    readonly query: (node: BinaryNode, timeoutMs?: number) => Promise<BinaryNode>;
+    readonly queryWithContext: (context: string, node: BinaryNode, timeoutMs?: number, contextData?: Readonly<Record<string, unknown>>) => Promise<BinaryNode>;
+    readonly syncAppState: () => Promise<void>;
+    readonly syncAppStateWithOptions: (options?: WaAppStateSyncOptions) => Promise<WaAppStateSyncResult>;
+    readonly emitEvent: <K extends keyof WaClientEventMap>(event: K, ...args: Parameters<WaClientEventMap[K]>) => void;
+    readonly handleIncomingMessageEvent: (event: WaIncomingMessageEvent) => Promise<void>;
+    readonly handleError: (error: Error) => void;
+    readonly handleIncomingFrame: (frame: Uint8Array) => Promise<void>;
+    readonly clearStoredState: () => Promise<void>;
+    readonly resumeIncomingEvents: () => void;
+}
 interface WaClientDependencies {
     readonly nodeTransport: WaNodeTransport;
     readonly nodeOrchestrator: WaNodeOrchestrator;
     readonly keepAlive: WaKeepAlive;
     readonly mediaTransfer: WaMediaTransferClient;
-    readonly mediaMessageBuildOptions: WaMediaMessageBuildOptions;
+    readonly mediaMessageBuildOptions: WaMediaMessageOptions;
     readonly messageClient: WaMessageClient;
     readonly senderKeyManager: SenderKeyManager;
     readonly signalProtocol: SignalProtocol;
@@ -50,34 +69,22 @@ interface WaClientDependencies {
     readonly messageDispatch: WaMessageDispatchCoordinator;
     readonly retryCoordinator: WaRetryCoordinator;
     readonly appStateSync: WaAppStateSyncClient;
+    readonly chatCoordinator: WaAppStateMutationCoordinator;
     readonly streamControl: WaStreamControlHandler;
     readonly incomingNode: WaIncomingNodeCoordinator;
     readonly passiveTasks: WaPassiveTasksCoordinator;
     readonly groupCoordinator: WaGroupCoordinator;
-}
-export interface WaClientDependencyHost {
-    readonly sendNode: (node: BinaryNode) => Promise<void>;
-    readonly query: (node: BinaryNode, timeoutMs?: number) => Promise<BinaryNode>;
-    readonly queryWithContext: (context: string, node: BinaryNode, timeoutMs?: number, contextData?: Readonly<Record<string, unknown>>) => Promise<BinaryNode>;
-    readonly syncAppState: () => Promise<void>;
-    readonly emitEvent: <K extends keyof WaClientEventMap>(event: K, ...args: Parameters<WaClientEventMap[K]>) => void;
-    readonly handleIncomingMessageEvent: (event: WaIncomingMessageEvent) => Promise<void>;
-    readonly handleError: (error: Error) => void;
-    readonly scheduleReconnectAfterPairing: () => void;
-    readonly updateClockSkewFromSuccess: (serverUnixSeconds: number) => void;
-    readonly getComms: () => WaComms | null;
-    readonly getMediaConnCache: () => WaMediaConn | null;
-    readonly setMediaConnCache: (mediaConn: WaMediaConn | null) => void;
-    readonly disconnect: () => Promise<void>;
-    readonly clearStoredState: () => Promise<void>;
-    readonly connect: () => Promise<void>;
-    readonly shouldQueueDanglingReceipt: (node: BinaryNode, error: Error) => boolean;
-    readonly enqueueDanglingReceipt: (node: BinaryNode) => void;
-    readonly takeDanglingReceipts: () => BinaryNode[];
+    readonly privacyCoordinator: WaPrivacyCoordinator;
+    readonly profileCoordinator: WaProfileCoordinator;
+    readonly businessCoordinator: WaBusinessCoordinator;
+    readonly receiptQueue: WaReceiptQueue;
+    readonly keyShareCoordinator: WaKeyShareCoordinator;
+    readonly connectionManager: WaConnectionManager;
+    readonly trustedContactToken: WaTrustedContactTokenCoordinator;
 }
 export declare function resolveWaClientBase(options: WaClientOptions, logger: Logger): WaClientBase;
 export declare function buildWaClientDependencies(input: {
     readonly base: WaClientBase;
-    readonly host: WaClientDependencyHost;
+    readonly runtime: WaClientBuildRuntime;
 }): WaClientDependencies;
 export {};

package/dist/types/client/connection/WaConnectionManager.d.ts

@@ -0,0 +1,66 @@
+import type { WaAuthClient } from '../../auth/WaAuthClient';
+import type { WaPassiveTasksCoordinator } from '../coordinators/WaPassiveTasksCoordinator';
+import type { WaClientOptions } from '../types';
+import type { Logger } from '../../infra/log/types';
+import type { WaMediaConn } from '../../media/types';
+import type { WaKeepAlive } from '../../transport/keepalive/WaKeepAlive';
+import type { WaNodeOrchestrator } from '../../transport/node/WaNodeOrchestrator';
+import type { WaNodeTransport } from '../../transport/node/WaNodeTransport';
+import { WaComms } from '../../transport/WaComms';
+interface WaConnectionManagerOptions {
+    readonly logger: Logger;
+    readonly options: Readonly<WaClientOptions>;
+    readonly authClient: WaAuthClient;
+    readonly keepAlive: WaKeepAlive;
+    readonly nodeOrchestrator: WaNodeOrchestrator;
+    readonly nodeTransport: WaNodeTransport;
+    readonly getPassiveTasks: () => WaPassiveTasksCoordinator | null;
+    readonly clearStoredCredentials: () => Promise<void>;
+}
+export declare class WaConnectionManager {
+    private readonly logger;
+    private readonly options;
+    private readonly authClient;
+    private readonly keepAlive;
+    private readonly nodeOrchestrator;
+    private readonly nodeTransport;
+    private readonly getPassiveTasks;
+    private readonly clearStoredCredentialsCallback;
+    private comms;
+    private clockSkewMs;
+    private mediaConnCache;
+    private connectPromise;
+    private pairingReconnectPromise;
+    private frameHandler;
+    private pendingComms;
+    private lifecycleGeneration;
+    private lifecycleQueue;
+    private lastConnectWasNewLogin;
+    constructor(options: WaConnectionManagerOptions);
+    connect(frameHandler: (frame: Uint8Array) => Promise<void>): Promise<void>;
+    scheduleReconnectAfterPairing(): void;
+    disconnect(): Promise<void>;
+    clearStoredCredentials(): Promise<void>;
+    isConnected(): boolean;
+    wasNewLogin(): boolean;
+    getComms(): WaComms | null;
+    getClockSkewMs(): number | null;
+    getMediaConnCache(): WaMediaConn | null;
+    setMediaConnCache(value: WaMediaConn | null): void;
+    updateClockSkewFromSuccess(serverUnixSeconds: number): void;
+    private connectInternal;
+    private reconnectAsRegisteredAfterPairing;
+    private reconnectAsRegisteredAfterPairingInternal;
+    private disconnectInternal;
+    private startCommsWithCredentials;
+    private clearCommsBinding;
+    private stopCommsQuietly;
+    private nextLifecycleGeneration;
+    private runLifecycleOperation;
+    private invalidatePendingComms;
+    private isLifecycleCurrent;
+    private assertLifecycleCurrent;
+    private createLifecycleSupersededError;
+    private isLifecycleSupersededError;
+}
+export {};

package/dist/types/client/connection/WaKeyShareCoordinator.d.ts

@@ -0,0 +1,14 @@
+export declare class WaKeyShareCoordinator {
+    private readonly waiters;
+    private version;
+    private bootstrapDone;
+    constructor();
+    waitForShare(timeoutMs: number): Promise<boolean>;
+    notifyReceived(): void;
+    notifyDisconnected(): void;
+    isBootstrapDone(): boolean;
+    markBootstrapDone(): void;
+    getVersion(): number;
+    hasWaiters(): boolean;
+    private releaseWaiters;
+}

package/dist/types/client/connection/WaReceiptQueue.d.ts

@@ -0,0 +1,13 @@
+import type { BinaryNode } from '../../transport/types';
+export declare class WaReceiptQueue {
+    private readonly maxSize;
+    private readonly danglingReceipts;
+    private danglingHead;
+    constructor(options?: {
+        readonly maxSize?: number;
+    });
+    shouldQueue(node: BinaryNode, error: Error): boolean;
+    enqueue(node: BinaryNode): void;
+    take(): BinaryNode[];
+    size(): number;
+}

package/dist/types/client/coordinators/WaAppStateMutationCoordinator.d.ts

@@ -0,0 +1,46 @@
+import type { WaAppStateSyncOptions, WaAppStateSyncResult } from '../../appstate/types';
+import type { WaAppStateMessageKey, WaClearChatOptions, WaDeleteChatOptions, WaDeleteMessageForMeOptions } from '../types';
+import type { Logger } from '../../infra/log/types';
+import type { WaMessageStore } from '../../store/contracts/message.store';
+interface WaAppStateMutationCoordinatorOptions {
+    readonly logger: Logger;
+    readonly messageStore: WaMessageStore;
+    readonly syncAppState: (options?: WaAppStateSyncOptions) => Promise<WaAppStateSyncResult>;
+    readonly archiveRangeLimit?: number;
+}
+export declare class WaAppStateMutationCoordinator {
+    private readonly logger;
+    private readonly messageStore;
+    private readonly syncAppState;
+    private readonly archiveRangeLimit;
+    private readonly pendingMutations;
+    private flushPromise;
+    constructor(options: WaAppStateMutationCoordinatorOptions);
+    setChatMute(chatJid: string, muted: boolean, muteEndTimestampMs?: number): Promise<void>;
+    setMessageStar(message: WaAppStateMessageKey, starred: boolean): Promise<void>;
+    setChatRead(chatJid: string, read: boolean): Promise<void>;
+    setChatPin(chatJid: string, pinned: boolean): Promise<void>;
+    setChatArchive(chatJid: string, archived: boolean): Promise<void>;
+    clearChat(chatJid: string, options?: WaClearChatOptions): Promise<void>;
+    deleteChat(chatJid: string, options?: WaDeleteChatOptions): Promise<void>;
+    deleteMessageForMe(message: WaAppStateMessageKey, options?: WaDeleteMessageForMeOptions): Promise<void>;
+    setChatLock(chatJid: string, locked: boolean): Promise<void>;
+    flushMutations(): Promise<void>;
+    private enqueueAndFlush;
+    private enqueueMutation;
+    private takePendingMutationsBatch;
+    private flushPendingMutationsLoop;
+    private requeueMutations;
+    private createSetMutation;
+    private createArchiveMutation;
+    private buildChatMessageRange;
+    private toChatMessageRangeMessage;
+    private normalizeMessageRangeParticipant;
+    private toOptionalTimestampSeconds;
+    private normalizeChatMutationJid;
+    private buildMessageMutationIndex;
+    private resolveMessageMutationParticipant;
+    private buildMutationIndex;
+    private describeMutationActions;
+}
+export {};

package/dist/types/client/coordinators/WaBusinessCoordinator.d.ts

@@ -0,0 +1,57 @@
+import type { WaEditBusinessProfileInput } from '../../transport/node/builders/business';
+import type { BinaryNode } from '../../transport/types';
+export interface WaBusinessCategory {
+    readonly id: string;
+    readonly name: string;
+}
+export interface WaBusinessHoursEntry {
+    readonly dayOfWeek: string;
+    readonly mode: string;
+    readonly openTime?: number;
+    readonly closeTime?: number;
+}
+export interface WaBusinessHours {
+    readonly timezone?: string;
+    readonly config: readonly WaBusinessHoursEntry[];
+}
+export interface WaBusinessWebsite {
+    readonly url: string;
+}
+export interface WaBusinessProfileResult {
+    readonly jid: string;
+    readonly tag?: string;
+    readonly description?: string;
+    readonly address?: string;
+    readonly email?: string;
+    readonly websites?: readonly WaBusinessWebsite[];
+    readonly categories?: readonly WaBusinessCategory[];
+    readonly businessHours?: WaBusinessHours;
+    readonly latitude?: number;
+    readonly longitude?: number;
+    readonly profileOptions?: Readonly<Record<string, string>>;
+}
+export interface WaVerifiedNamePrivacyMode {
+    readonly actualActors: number;
+    readonly hostStorage: number;
+    readonly privacyModeTs: number;
+}
+export interface WaVerifiedNameResult {
+    readonly name?: string;
+    readonly level?: string;
+    readonly serial?: string;
+    readonly isApi: boolean;
+    readonly isSmb: boolean;
+    readonly privacyMode?: WaVerifiedNamePrivacyMode;
+}
+export interface WaBusinessCoordinator {
+    readonly getBusinessProfile: (jids: readonly string[]) => Promise<readonly WaBusinessProfileResult[]>;
+    readonly editBusinessProfile: (input: WaEditBusinessProfileInput) => Promise<void>;
+    readonly getVerifiedName: (jid: string) => Promise<WaVerifiedNameResult | null>;
+    readonly updateCoverPhoto: (id: string, timestamp: string, token: string) => Promise<void>;
+    readonly deleteCoverPhoto: (id: string) => Promise<void>;
+}
+interface WaBusinessCoordinatorOptions {
+    readonly queryWithContext: (context: string, node: BinaryNode, timeoutMs?: number, contextData?: Readonly<Record<string, unknown>>) => Promise<BinaryNode>;
+}
+export declare function createBusinessCoordinator(options: WaBusinessCoordinatorOptions): WaBusinessCoordinator;
+export {};

package/dist/types/client/coordinators/WaIncomingNodeCoordinator.d.ts

@@ -2,6 +2,7 @@ import type { WaSuccessPersistAttributes } from '../../auth/types';
 import type { WaDirtyBit } from '../dirty';
 import type { WaIncomingBaseEvent, WaIncomingCallEvent, WaIncomingChatstateEvent, WaIncomingFailureEvent, WaGroupEvent, WaIncomingNodeHandlerRegistration, WaIncomingNotificationEvent, WaIncomingPresenceEvent, WaIncomingReceiptEvent, WaIncomingUnhandledStanzaEvent } from '../types';
 import type { Logger } from '../../infra/log/types';
+import type { WaConnectionCode, WaDisconnectReason } from '../../protocol/stream';
 import { type WaStreamControlNodeResult } from '../../transport/stream/parse';
 import type { BinaryNode } from '../../transport/types';
 interface WaIncomingNodeRuntime {
@@ -31,7 +32,8 @@ interface WaIncomingNodeRuntime {
     readonly emitGroupEvent: (event: WaGroupEvent) => void;
     readonly emitUnhandledIncomingNode: (event: WaIncomingUnhandledStanzaEvent) => void;
     readonly syncAppState: () => Promise<void>;
-    readonly disconnect: () => Promise<void>;
+    readonly stopComms: () => void;
+    readonly disconnect: (reason: WaDisconnectReason, isLogout: boolean, code: WaConnectionCode | null) => Promise<void>;
     readonly clearStoredCredentials: () => Promise<void>;
     readonly parseDirtyBits: (nodes: readonly BinaryNode[]) => readonly WaDirtyBit[];
     readonly handleDirtyBits: (dirtyBits: readonly WaDirtyBit[]) => Promise<void>;
@@ -51,7 +53,6 @@ export declare class WaIncomingNodeCoordinator {
     unregisterIncomingHandler(registration: WaIncomingNodeHandlerRegistration): boolean;
     private dispatchIncomingNode;
     private isRetryReceiptType;
-    private getHandlersForNode;
     private registerDefaultIncomingHandlers;
     private handleSuccessNode;
     private scheduleMediaConnWarmup;

package/dist/types/client/coordinators/WaMessageDispatchCoordinator.d.ts

@@ -1,52 +1,59 @@
 import type { WaAppStateSyncKey } from '../../appstate/types';
+import type { DeviceFanoutResolver } from '../messaging/fanout';
+import type { AppStateSyncKeyProtocol } from '../messaging/key-protocol';
+import type { GroupParticipantsCache } from '../messaging/participants';
 import type { WaGroupEvent, WaSignalMessagePublishInput, WaSendMessageOptions } from '../types';
 import type { Logger } from '../../infra/log/types';
 import type { WaEncryptedMessageInput, WaMessagePublishOptions, WaMessagePublishResult, WaSendMessageContent, WaSendReceiptInput } from '../../message/types';
 import type { WaMessageClient } from '../../message/WaMessageClient';
 import type { Proto } from '../..';
-import type { SignalDeviceSyncApi } from '../../signal/api/SignalDeviceSyncApi';
-import type { SignalIdentitySyncApi } from '../../signal/api/SignalIdentitySyncApi';
-import type { SignalSessionSyncApi } from '../../signal/api/SignalSessionSyncApi';
+import type { OutboundRetryTracker } from '../../retry/tracker';
 import type { SenderKeyManager } from '../../signal/group/SenderKeyManager';
+import type { SignalSessionResolver } from '../../signal/session/resolver';
 import type { SignalProtocol } from '../../signal/session/SignalProtocol';
-import type { WaParticipantsStore } from '../../store/contracts/participants.store';
-import type { WaRetryStore } from '../../store/contracts/retry.store';
+import type { WaDeviceListStore } from '../../store/contracts/device-list.store';
 import type { WaSignalStore } from '../../store/contracts/signal.store';
 import type { BinaryNode } from '../../transport/types';
 interface WaMessageDispatchCoordinatorOptions {
     readonly logger: Logger;
     readonly messageClient: WaMessageClient;
-    readonly retryStore: WaRetryStore;
-    readonly participantsStore: WaParticipantsStore;
+    readonly retryTracker: OutboundRetryTracker;
+    readonly sessionResolver: SignalSessionResolver;
+    readonly fanoutResolver: DeviceFanoutResolver;
+    readonly participantsCache: GroupParticipantsCache;
+    readonly appStateSyncKeyProtocol: AppStateSyncKeyProtocol;
     readonly buildMessageContent: (content: WaSendMessageContent) => Promise<Proto.IMessage>;
-    readonly queryGroupParticipantJids: (groupJid: string) => Promise<readonly string[]>;
     readonly senderKeyManager: SenderKeyManager;
     readonly signalProtocol: SignalProtocol;
     readonly signalStore: WaSignalStore;
-    readonly signalDeviceSync: SignalDeviceSyncApi;
-    readonly signalIdentitySync: SignalIdentitySyncApi;
-    readonly signalSessionSync: SignalSessionSyncApi;
+    readonly deviceListStore: WaDeviceListStore;
     readonly getCurrentMeJid: () => string | null | undefined;
     readonly getCurrentMeLid: () => string | null | undefined;
     readonly getCurrentSignedIdentity: () => Proto.IADVSignedDeviceIdentity | null | undefined;
+    readonly resolvePrivacyTokenNode: (recipientJid: string) => Promise<BinaryNode | null>;
+    readonly onDirectMessageSent: (recipientJid: string) => void;
 }
 export declare class WaMessageDispatchCoordinator {
     private readonly logger;
     private readonly messageClient;
-    private readonly retryStore;
-    private readonly participantsStore;
-    private readonly retryTtlMs;
+    private readonly retryTracker;
+    private readonly sessionResolver;
+    private readonly fanoutResolver;
+    private readonly participantsCache;
+    private readonly appStateSyncKeyProtocol;
     private readonly buildMessageContent;
-    private readonly queryGroupParticipantJids;
     private readonly senderKeyManager;
     private readonly signalProtocol;
     private readonly signalStore;
-    private readonly signalDeviceSync;
-    private readonly signalIdentitySync;
-    private readonly signalSessionSync;
+    private readonly deviceListStore;
     private readonly getCurrentMeJid;
     private readonly getCurrentMeLid;
     private readonly getCurrentSignedIdentity;
+    private readonly resolvePrivacyTokenNode;
+    private readonly onDirectMessageSent;
+    private readonly icdcDedup;
+    private readonly privacyTokenDedup;
+    private readonly distributionDedup;
     constructor(options: WaMessageDispatchCoordinatorOptions);
     publishMessageNode(node: BinaryNode, options?: WaMessagePublishOptions): Promise<WaMessagePublishResult>;
     publishEncryptedMessage(input: WaEncryptedMessageInput, options?: WaMessagePublishOptions): Promise<WaMessagePublishResult>;
@@ -57,34 +64,18 @@ export declare class WaMessageDispatchCoordinator {
     requestAppStateSyncKeys(keyIds: readonly Uint8Array[]): Promise<readonly string[]>;
     sendAppStateSyncKeyShare(toDeviceJid: string, keys: readonly WaAppStateSyncKey[], missingKeyIds?: readonly Uint8Array[]): Promise<void>;
     mutateParticipantsCacheFromGroupEvent(event: WaGroupEvent): Promise<void>;
-    private publishProtocolMessageToDevice;
-    private resolveOwnPeerDeviceJids;
-    private normalizeKeyIds;
-    private publishWithRetryTracking;
-    private createRetryOutboundRecord;
-    private safeUpsertRetryOutboundRecord;
     private shouldUseGroupDirectPath;
     private publishGroupDirectMessage;
     private publishGroupSenderKeyMessage;
-    private resolveGroupParticipantUsers;
-    private resolveGroupJidForParticipantCacheEvent;
-    private extractParticipantUsersFromGroupEvent;
-    private mergeParticipantUsersIntoCache;
-    private removeParticipantUsersFromCache;
-    private replaceParticipantUsersInCache;
-    private areParticipantListsEqual;
-    private refreshGroupParticipantUsers;
-    private sanitizeParticipantUsers;
     private resolveGroupAddressingMode;
     private resolveSenderForAddressingMode;
     private encryptGroupDistributionParticipants;
-    private resolveGroupParticipantDeviceJids;
     private publishDirectSignalMessageWithFanout;
-    private ensureSignalSessionsBatch;
-    private resolveDirectFanoutDeviceJids;
-    private resolveSelfDeviceJidForRecipient;
+    private withResolvedMessageId;
+    private generateOutgoingMessageId;
+    private tryBuildReportingTokenArtifacts;
     private getEncodedSignedDeviceIdentity;
-    private ensureSignalSession;
+    private resolveUserIcdc;
     private requireCurrentMeJid;
 }
 export {};

package/dist/types/client/coordinators/WaPassiveTasksCoordinator.d.ts

@@ -32,11 +32,15 @@ export declare class WaPassiveTasksCoordinator {
         readonly runtime: WaPassiveTasksRuntime;
     });
     startPassiveTasksAfterConnect(): void;
+    handlePreKeyLowNotification(): Promise<void>;
+    handleDigestNotification(): Promise<void>;
     resetInFlightState(): void;
     private runPassiveTasksAfterConnect;
     private validateDigestAndRecoverPreKeys;
     private uploadPreKeysIfMissing;
     private rotateSignedPreKeyIfDue;
+    private resolveLocalKeyBundle;
+    private resolveLocalKeyBundleFromStore;
     private resolveRotationTimestamp;
     private flushDanglingReceipts;
 }

package/dist/types/client/coordinators/WaPrivacyCoordinator.d.ts

@@ -0,0 +1,26 @@
+import type { WaPrivacyDisallowedListSettingName, WaPrivacySettingName, WaPrivacySettingValueMap } from '../../protocol/privacy';
+import type { BinaryNode } from '../../transport/types';
+export type WaPrivacySettings = {
+    readonly [K in WaPrivacySettingName]?: WaPrivacySettingValueMap[K];
+};
+export interface WaPrivacyDisallowedListResult {
+    readonly jids: readonly string[];
+    readonly dhash?: string;
+}
+export interface WaBlocklistResult {
+    readonly jids: readonly string[];
+    readonly dhash?: string;
+}
+export interface WaPrivacyCoordinator {
+    readonly getPrivacySettings: () => Promise<WaPrivacySettings>;
+    readonly setPrivacySetting: <S extends WaPrivacySettingName>(setting: S, value: WaPrivacySettingValueMap[S]) => Promise<void>;
+    readonly getDisallowedList: (category: WaPrivacyDisallowedListSettingName) => Promise<WaPrivacyDisallowedListResult>;
+    readonly getBlocklist: () => Promise<WaBlocklistResult>;
+    readonly blockUser: (jid: string) => Promise<void>;
+    readonly unblockUser: (jid: string) => Promise<void>;
+}
+interface WaPrivacyCoordinatorOptions {
+    readonly queryWithContext: (context: string, node: BinaryNode, timeoutMs?: number, contextData?: Readonly<Record<string, unknown>>) => Promise<BinaryNode>;
+}
+export declare function createPrivacyCoordinator(options: WaPrivacyCoordinatorOptions): WaPrivacyCoordinator;
+export {};