zapo-js 0.1.0 → 0.1.2

package/dist/types/auth/WaAuthClient.d.ts

@@ -3,14 +3,7 @@ import type { Logger } from '../infra/log/types';
 import type { WaAuthStore } from '../store/contracts/auth.store';
 import type { WaSignalStore } from '../store/contracts/signal.store';
 import type { BinaryNode } from '../transport/types';
-interface WaAuthClientCallbacks {
-    readonly onQr?: (qr: string, ttlMs: number) => void;
-    readonly onPairingCode?: (code: string) => void;
-    readonly onPairingRefresh?: (forceManual: boolean) => void;
-    readonly onPaired?: (credentials: WaAuthCredentials) => void;
-    readonly onError?: (error: Error) => void;
-}
-interface WaAuthClientDependencies {
+type WaAuthClientDeps = Readonly<{
     readonly logger: Logger;
     readonly authStore: WaAuthStore;
     readonly signalStore: WaSignalStore;
@@ -18,8 +11,14 @@ interface WaAuthClientDependencies {
         readonly sendNode: (node: BinaryNode) => Promise<void>;
         readonly query: (node: BinaryNode, timeoutMs?: number) => Promise<BinaryNode>;
     };
-    readonly callbacks?: WaAuthClientCallbacks;
-}
+    readonly callbacks?: {
+        readonly onQr?: (qr: string, ttlMs: number) => void;
+        readonly onPairingCode?: (code: string) => void;
+        readonly onPairingRefresh?: (forceManual: boolean) => void;
+        readonly onPaired?: (credentials: WaAuthCredentials) => void;
+        readonly onError?: (error: Error) => void;
+    };
+}>;
 export declare class WaAuthClient {
     private readonly options;
     private readonly logger;
@@ -29,7 +28,7 @@ export declare class WaAuthClient {
     private readonly qrFlow;
     private readonly pairingFlow;
     private credentials;
-    constructor(options: WaAuthClientOptions, deps: WaAuthClientDependencies);
+    constructor(options: WaAuthClientOptions, deps: WaAuthClientDeps);
     getState(connected?: boolean): {
         connected: boolean;
         registered: boolean;
@@ -45,7 +44,6 @@ export declare class WaAuthClient {
     persistServerHasPreKeys(serverHasPreKeys: boolean): Promise<void>;
     persistRoutingInfo(routingInfo: Uint8Array): Promise<void>;
     clearRoutingInfo(): Promise<WaAuthCredentials>;
-    persistMeLid(meLid: string): Promise<void>;
     persistSuccessAttributes(attributes: WaSuccessPersistAttributes): Promise<void>;
     requestPairingCode(phoneNumber: string, shouldShowPushNotification?: boolean): Promise<string>;
     fetchPairingCountryCodeIso(): Promise<string>;

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

@@ -1,6 +1,4 @@
 export * from './types';
-export { getLoginIdentity } from '../protocol/jid';
 export { WaAuthClient } from './WaAuthClient';
 export { completeCompanionFinish, createCompanionHello } from './pairing/WaPairingCodeCrypto';
 export { WaAuthSqliteStore } from '../store/providers/sqlite/auth.store';
-export type { WaAuthStore } from '../store/contracts/auth.store';

package/dist/types/auth/pairing/WaQrFlow.d.ts

@@ -6,7 +6,7 @@ export declare class WaQrFlow {
     private readonly getDevicePlatform;
     private readonly emitQr;
     private qrRefs;
-    private currentRef;
+    private qrRefIndex;
     private currentQrTimer;
     constructor(args: {
         readonly logger: Logger;

package/dist/types/auth/types.d.ts

@@ -1,6 +1,7 @@
 import type { SignalKeyPair } from '../crypto/curves/types';
 import type { Proto } from '..';
 import type { RegistrationInfo, SignedPreKeyRecord } from '../signal/types';
+import type { WaCommsConfig, WaProxyTransport } from '../transport/types';
 export interface WaAuthCredentials {
     readonly noiseKeyPair: SignalKeyPair;
     readonly registrationInfo: RegistrationInfo;
@@ -21,15 +22,11 @@ export interface WaAuthCredentials {
     readonly connectionLocation?: string;
     readonly accountCreationTs?: number;
 }
-export interface WaAuthSocketOptions {
-    readonly url?: string;
-    readonly urls?: readonly string[];
-    readonly protocols?: readonly string[];
-    readonly connectTimeoutMs?: number;
-    readonly reconnectIntervalMs?: number;
-    readonly timeoutIntervalMs?: number;
-    readonly maxReconnectAttempts?: number;
-}
+export type WaAuthSocketOptions = Pick<WaCommsConfig, 'url' | 'urls' | 'protocols' | 'connectTimeoutMs' | 'reconnectIntervalMs' | 'timeoutIntervalMs' | 'maxReconnectAttempts'> & {
+    readonly proxy?: {
+        readonly ws?: WaProxyTransport;
+    };
+};
 export interface WaAuthClientOptions {
     readonly deviceBrowser?: string;
     readonly devicePlatform?: string;

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

@@ -2,14 +2,14 @@ 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 { WaGroupCoordinator } from './coordinators/WaGroupCoordinator';
 import type { WaMessageDispatchCoordinator } from './coordinators/WaMessageDispatchCoordinator';
-import type { WaClientEventMap, WaClientOptions, WaSendMessageOptions, WaIncomingNodeHandlerRegistration } from './types';
+import type { WaAppStateMessageKey, WaClearChatOptions, WaClientOptions, WaDeleteChatOptions, WaDeleteMessageForMeOptions, 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;
@@ -25,42 +25,44 @@ 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;
+    private readonly appStateMutations;
     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;
+    private readonly passiveTasks;
+    private readonly keepAlive;
+    private readonly receiptQueue;
+    private readonly keyShareCoordinator;
+    private readonly connectionManager;
     private connectPromise;
-    private readonly danglingReceipts;
-    private readonly appStateKeyShareWaiters;
-    private appStateKeyShareVersion;
-    private appStateBootstrapKeyShareWaitDone;
     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>;
     registerIncomingHandler(registration: WaIncomingNodeHandlerRegistration): () => void;
     unregisterIncomingHandler(registration: WaIncomingNodeHandlerRegistration): boolean;
     private bindNodeTransportEvents;
+    private getMailboxPersistenceDeps;
     private handleIncomingMessageEvent;
     private handleIncomingAppStateSyncKeyShare;
     private handleIncomingAppStateSyncKeyRequest;
@@ -70,28 +72,28 @@ 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>;
     sendReceipt(input: WaSendReceiptInput): Promise<void>;
+    setChatMute(chatJid: string, muted: boolean, muteEndTimestampMs?: number): 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>;
+    setChatLock(chatJid: string, locked: boolean): Promise<void>;
+    setMessageStar(message: WaAppStateMessageKey, starred: boolean): Promise<void>;
+    deleteMessageForMe(message: WaAppStateMessageKey, options?: WaDeleteMessageForMeOptions): Promise<void>;
+    flushAppStateMutations(): Promise<void>;
     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 clearStoredState;
     private handleError;
-    private clearCommsBinding;
-    private updateClockSkewFromSuccess;
 }

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

@@ -1,5 +1,10 @@
+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 WaGroupCoordinator } from './coordinators/WaGroupCoordinator';
 import { WaIncomingNodeCoordinator } from './coordinators/WaIncomingNodeCoordinator';
 import { WaMessageDispatchCoordinator } from './coordinators/WaMessageDispatchCoordinator';
@@ -9,7 +14,6 @@ import { type WaStreamControlHandler } from './coordinators/WaStreamControlCoord
 import { buildMediaMessageContent } 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,13 +28,24 @@ 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>;
+}
 interface WaClientDependencies {
     readonly nodeTransport: WaNodeTransport;
     readonly nodeOrchestrator: WaNodeOrchestrator;
@@ -50,34 +65,18 @@ interface WaClientDependencies {
     readonly messageDispatch: WaMessageDispatchCoordinator;
     readonly retryCoordinator: WaRetryCoordinator;
     readonly appStateSync: WaAppStateSyncClient;
+    readonly appStateMutations: 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 receiptQueue: WaReceiptQueue;
+    readonly keyShareCoordinator: WaKeyShareCoordinator;
+    readonly connectionManager: WaConnectionManager;
 }
 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,64 @@
+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;
+    constructor(options: WaConnectionManagerOptions);
+    connect(frameHandler: (frame: Uint8Array) => Promise<void>): Promise<void>;
+    scheduleReconnectAfterPairing(): void;
+    disconnect(): Promise<void>;
+    clearStoredCredentials(): Promise<void>;
+    isConnected(): 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/WaIncomingNodeCoordinator.d.ts

@@ -51,7 +51,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,31 +1,28 @@
 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 { 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 getCurrentMeJid: () => string | null | undefined;
     readonly getCurrentMeLid: () => string | null | undefined;
     readonly getCurrentSignedIdentity: () => Proto.IADVSignedDeviceIdentity | null | undefined;
@@ -33,17 +30,14 @@ interface WaMessageDispatchCoordinatorOptions {
 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 getCurrentMeJid;
     private readonly getCurrentMeLid;
     private readonly getCurrentSignedIdentity;
@@ -57,34 +51,17 @@ 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 requireCurrentMeJid;
 }
 export {};

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

@@ -38,6 +38,7 @@ export declare class WaRetryCoordinator {
     private readonly getCurrentMeLid;
     private readonly getCurrentSignedIdentity;
     private readonly retryProcessingByMessageId;
+    private nextRetryCleanupAtMs;
     constructor(options: WaRetryCoordinatorOptions);
     onDecryptFailure(context: WaRetryDecryptFailureContext, error: unknown): Promise<boolean>;
     handleIncomingRetryReceipt(receiptNode: BinaryNode): Promise<void>;
@@ -57,5 +58,6 @@ export declare class WaRetryCoordinator {
     private isRequesterAuthorizedDevice;
     private mapOutboundStateFromReceiptType;
     private sendRetryAckSafe;
+    private maybeCleanupRetryStore;
 }
 export {};

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

@@ -11,6 +11,7 @@ interface WaDirtySyncRuntime {
     readonly queryWithContext: (context: string, node: BinaryNode, timeoutMs?: number, contextData?: Readonly<Record<string, unknown>>) => Promise<BinaryNode>;
     readonly getCurrentCredentials: () => WaAuthCredentials | null;
     readonly syncAppState: () => Promise<void>;
+    readonly generateUsyncSid: () => Promise<string>;
 }
 export declare function parseDirtyBits(nodes: readonly BinaryNode[], logger: Logger): readonly WaDirtyBit[];
 export declare function handleDirtyBits(runtime: WaDirtySyncRuntime, dirtyBits: readonly WaDirtyBit[]): Promise<void>;

package/dist/types/client/events/group.d.ts

@@ -1,7 +1,8 @@
-import type { WaGroupEvent, WaIncomingUnhandledStanzaEvent } from '../types';
+import type { WaGroupEvent, WaGroupEventParticipant, WaIncomingUnhandledStanzaEvent } from '../types';
 import type { BinaryNode } from '../../transport/types';
 export interface WaParseGroupNotificationResult {
     readonly events: readonly WaGroupEvent[];
     readonly unhandled: readonly WaIncomingUnhandledStanzaEvent[];
 }
+export declare function parseParticipants(node: BinaryNode): readonly WaGroupEventParticipant[];
 export declare function parseGroupNotificationEvents(notificationNode: BinaryNode): WaParseGroupNotificationResult;

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

@@ -1,2 +1,2 @@
 export { WaClient } from './WaClient';
-export type { WaChatEvent, WaChatEventAction, WaChatEventSource, WaClientEventMap, WaClientOptions, WaHistorySyncChunkEvent, WaHistorySyncOptions } from './types';
+export type { WaAppStateMessageKey, WaClientProxyOptions, WaClearChatOptions, WaChatEvent, WaChatEventAction, WaChatEventSource, WaClientEventMap, WaClientOptions, WaDeleteChatOptions, WaDeleteMessageForMeOptions, WaHistorySyncChunkEvent, WaHistorySyncOptions } from './types';

package/dist/types/client/messaging/fanout.d.ts

@@ -0,0 +1,14 @@
+import type { Logger } from '../../infra/log/types';
+import type { SignalDeviceSyncApi } from '../../signal/api/SignalDeviceSyncApi';
+export type DeviceFanoutResolver = {
+    resolveDirectFanoutDeviceJids(recipientJid: string, selfDeviceJid: string): Promise<readonly string[]>;
+    resolveGroupParticipantDeviceJids(participantUserJids: readonly string[]): Promise<readonly string[]>;
+    resolveOwnPeerDeviceJids(): Promise<readonly string[]>;
+    resolveSelfDeviceJidForRecipient(recipientJid: string, meJid: string, meLid: string | null | undefined): string;
+};
+export declare function createDeviceFanoutResolver(options: {
+    readonly signalDeviceSync: SignalDeviceSyncApi;
+    readonly getCurrentMeJid: () => string | null | undefined;
+    readonly getCurrentMeLid: () => string | null | undefined;
+    readonly logger: Logger;
+}): DeviceFanoutResolver;

package/dist/types/client/messaging/key-protocol.d.ts

@@ -0,0 +1,18 @@
+import type { WaAppStateSyncKey } from '../../appstate/types';
+import type { DeviceFanoutResolver } from '../messaging/fanout';
+import type { WaSignalMessagePublishInput } from '../types';
+import type { Logger } from '../../infra/log/types';
+import type { WaMessagePublishOptions, WaMessagePublishResult } from '../../message/types';
+type PublishSignalMessageFn = (input: WaSignalMessagePublishInput, options?: WaMessagePublishOptions) => Promise<WaMessagePublishResult>;
+export type AppStateSyncKeyProtocol = {
+    requestKeys(keyIds: readonly Uint8Array[]): Promise<readonly string[]>;
+    sendKeyShare(toDeviceJid: string, keys: readonly WaAppStateSyncKey[], missingKeyIds?: readonly Uint8Array[]): Promise<void>;
+};
+export declare function createAppStateSyncKeyProtocol(options: {
+    readonly publishSignalMessage: PublishSignalMessageFn;
+    readonly fanoutResolver: DeviceFanoutResolver;
+    readonly getCurrentMeJid: () => string | null | undefined;
+    readonly getCurrentMeLid: () => string | null | undefined;
+    readonly logger: Logger;
+}): AppStateSyncKeyProtocol;
+export {};

package/dist/types/client/messaging/participants.d.ts

@@ -0,0 +1,13 @@
+import type { WaGroupEvent } from '../types';
+import type { Logger } from '../../infra/log/types';
+import type { WaParticipantsStore } from '../../store/contracts/participants.store';
+export type GroupParticipantsCache = {
+    resolveParticipantUsers(groupJid: string): Promise<readonly string[]>;
+    refreshParticipantUsers(groupJid: string): Promise<readonly string[]>;
+    mutateFromGroupEvent(event: WaGroupEvent): Promise<void>;
+};
+export declare function createGroupParticipantsCache(options: {
+    readonly participantsStore: WaParticipantsStore;
+    readonly queryGroupParticipantJids: (groupJid: string) => Promise<readonly string[]>;
+    readonly logger: Logger;
+}): GroupParticipantsCache;