zapo-js 0.1.1 → 0.2.0

package/dist/esm/client/WaClient.js

@@ -3,14 +3,14 @@ import { downloadExternalBlobReference } from '../appstate/utils.js';
 import { parseChatEventFromAppStateMutation } from './events/chat.js';
 import { processHistorySyncNotification } from './history-sync.js';
 import { persistIncomingMailboxEntities } from './mailbox.js';
+import { WriteBehindPersistence } from './persistence/WriteBehindPersistence.js';
 import { buildWaClientDependencies, resolveWaClientBase } from './WaClientFactory.js';
 import { ConsoleLogger } from '../infra/log/ConsoleLogger.js';
 import { proto } from '../proto.js';
-import { WA_APP_STATE_COLLECTION_STATES, WA_DEFAULTS, WA_MESSAGE_TAGS } from '../protocol/constants.js';
-import { normalizeDeviceJid, toUserJid } from '../protocol/jid.js';
+import { WA_APP_STATE_COLLECTION_STATES, WA_DEFAULTS } from '../protocol/constants.js';
+import { normalizeDeviceJid, parsePhoneJid, toUserJid } from '../protocol/jid.js';
 import { queryWithContext as queryNodeWithContext } from '../transport/node/query.js';
-import { WaComms } from '../transport/WaComms.js';
-import { decodeProtoBytes } from '../util/base64.js';
+import { decodeProtoBytes } from '../util/bytes.js';
 import { bytesToHex } from '../util/bytes.js';
 import { toError } from '../util/primitives.js';
 const SYNC_RELATED_PROTOCOL_TYPES = new Set([
@@ -24,15 +24,10 @@ const WA_APP_STATE_KEY_SHARE_MAX_RETRIES = 2;
 export class WaClient extends EventEmitter {
     constructor(options, logger = new ConsoleLogger('info')) {
         super();
-        this.clockSkewMs = null;
-        this.mediaConnCache = null;
-        this.comms = null;
-        this.pairingReconnectPromise = null;
         this.connectPromise = null;
-        this.danglingReceipts = [];
-        this.appStateKeyShareWaiters = new Set();
-        this.appStateKeyShareVersion = 0;
-        this.appStateBootstrapKeyShareWaitDone = false;
+        this.acceptingIncomingEvents = true;
+        this.activeIncomingHandlers = 0;
+        this.incomingHandlersDrainedWaiters = [];
         const base = resolveWaClientBase(options, logger);
         this.options = base.options;
         this.logger = base.logger;
@@ -40,36 +35,34 @@ export class WaClient extends EventEmitter {
         this.contactStore = base.sessionStore.contacts;
         this.messageStore = base.sessionStore.messages;
         this.participantsStore = base.sessionStore.participants;
+        this.privacyTokenStore = base.sessionStore.privacyToken;
         this.deviceListStore = base.sessionStore.deviceList;
         this.retryStore = base.sessionStore.retry;
         this.signalStore = base.sessionStore.signal;
         this.senderKeyStore = base.sessionStore.senderKey;
         this.threadStore = base.sessionStore.threads;
-        const host = {
-            sendNode: (node) => this.sendNode(node),
-            query: (node, timeoutMs) => this.query(node, timeoutMs),
-            queryWithContext: this.queryWithContext.bind(this),
-            syncAppState: () => this.syncAppState().then(() => { }),
-            emitEvent: this.emit.bind(this),
-            handleIncomingMessageEvent: this.handleIncomingMessageEvent.bind(this),
-            handleError: this.handleError.bind(this),
-            scheduleReconnectAfterPairing: this.scheduleReconnectAfterPairing.bind(this),
-            updateClockSkewFromSuccess: this.updateClockSkewFromSuccess.bind(this),
-            getComms: () => this.comms,
-            getMediaConnCache: () => this.mediaConnCache,
-            setMediaConnCache: (mediaConn) => {
-                this.mediaConnCache = mediaConn;
-            },
-            disconnect: this.disconnect.bind(this),
-            clearStoredState: this.clearStoredState.bind(this),
-            connect: this.connect.bind(this),
-            shouldQueueDanglingReceipt: (node, error) => this.shouldQueueDanglingReceipt(node, error),
-            enqueueDanglingReceipt: this.enqueueDanglingReceipt.bind(this),
-            takeDanglingReceipts: () => this.danglingReceipts.splice(0)
-        };
+        this.writeBehind = new WriteBehindPersistence({
+            messageStore: this.messageStore,
+            threadStore: this.threadStore,
+            contactStore: this.contactStore
+        }, this.logger, this.options.writeBehind);
         const dependencies = buildWaClientDependencies({
             base,
-            host
+            runtime: {
+                sendNode: (node) => this.sendNode(node),
+                query: (node, timeoutMs) => this.query(node, timeoutMs),
+                queryWithContext: this.queryWithContext.bind(this),
+                syncAppState: () => this.syncAppState().then(() => { }),
+                syncAppStateWithOptions: (syncOptions) => this.syncAppState(syncOptions),
+                emitEvent: this.emit.bind(this),
+                handleIncomingMessageEvent: this.handleIncomingMessageEvent.bind(this),
+                handleError: this.handleError.bind(this),
+                handleIncomingFrame: this.handleIncomingFrame.bind(this),
+                clearStoredState: this.clearStoredState.bind(this),
+                resumeIncomingEvents: () => {
+                    this.acceptingIncomingEvents = true;
+                }
+            }
         });
         Object.assign(this, dependencies);
         this.bindNodeTransportEvents();
@@ -87,7 +80,7 @@ export class WaClient extends EventEmitter {
         return super.emit(event, ...args);
     }
     getState() {
-        const connected = this.comms !== null && this.comms.getCommsState().connected;
+        const connected = this.connectionManager.isConnected();
         this.logger.trace('wa client state requested', { connected });
         return this.authClient.getState(connected);
     }
@@ -95,7 +88,7 @@ export class WaClient extends EventEmitter {
         return this.authClient.getCurrentCredentials();
     }
     getClockSkewMs() {
-        return this.clockSkewMs;
+        return this.connectionManager.getClockSkewMs();
     }
     async sendNode(node) {
         try {
@@ -103,13 +96,13 @@ export class WaClient extends EventEmitter {
         }
         catch (error) {
             const normalized = toError(error);
-            if (this.shouldQueueDanglingReceipt(node, normalized)) {
-                this.enqueueDanglingReceipt(node);
+            if (this.receiptQueue.shouldQueue(node, normalized)) {
+                this.receiptQueue.enqueue(node);
                 this.logger.warn('queued dangling receipt after send failure', {
                     id: node.attrs.id,
                     to: node.attrs.to,
                     message: normalized.message,
-                    queueSize: this.danglingReceipts.length
+                    queueSize: this.receiptQueue.size()
                 });
                 return;
             }
@@ -117,7 +110,7 @@ export class WaClient extends EventEmitter {
         }
     }
     async query(node, timeoutMs = this.options.iqTimeoutMs ?? WA_DEFAULTS.IQ_TIMEOUT_MS) {
-        if (!this.comms || !this.comms.getCommsState().connected) {
+        if (!this.connectionManager.isConnected()) {
             throw new Error('client is not connected');
         }
         this.logger.debug('wa client query', { tag: node.tag, id: node.attrs.id, timeoutMs });
@@ -140,57 +133,64 @@ export class WaClient extends EventEmitter {
         });
     }
     async handleIncomingMessageEvent(event) {
-        this.emit('message', event);
-        void persistIncomingMailboxEntities({
-            logger: this.logger,
-            contactStore: this.contactStore,
-            messageStore: this.messageStore,
-            event
-        });
-        const protocolMessage = event.message?.protocolMessage;
-        if (!protocolMessage) {
+        if (!this.tryEnterIncomingHandler()) {
             return;
         }
-        const protocolEvent = {
-            ...event,
-            protocolMessage
-        };
-        this.emit('message_protocol', protocolEvent);
-        const protocolType = protocolMessage.type;
-        if (protocolType === null || protocolType === undefined) {
-            this.logger.debug('incoming protocol message without type', {
-                id: event.stanzaId,
-                from: event.chatJid
+        try {
+            this.emit('message', event);
+            void persistIncomingMailboxEntities({
+                logger: this.logger,
+                writeBehind: this.writeBehind,
+                event
             });
-            return;
-        }
-        if (protocolType === proto.Message.ProtocolMessage.Type.APP_STATE_SYNC_KEY_REQUEST) {
-            await this.handleIncomingAppStateSyncKeyRequest(event, protocolMessage);
-            return;
-        }
-        if (protocolType === proto.Message.ProtocolMessage.Type.APP_STATE_SYNC_KEY_SHARE) {
-            await this.handleIncomingAppStateSyncKeyShare(event, protocolMessage);
-            return;
-        }
-        if (protocolType === proto.Message.ProtocolMessage.Type.HISTORY_SYNC_NOTIFICATION) {
-            if (this.options.history?.enabled && protocolMessage.historySyncNotification) {
-                await this.handleHistorySyncNotification(protocolMessage.historySyncNotification);
+            const protocolMessage = event.message?.protocolMessage;
+            if (!protocolMessage) {
+                return;
             }
-            return;
-        }
-        if (SYNC_RELATED_PROTOCOL_TYPES.has(protocolType)) {
-            this.logger.info('incoming sync-related protocol message', {
+            const protocolEvent = {
+                ...event,
+                protocolMessage
+            };
+            this.emit('message_protocol', protocolEvent);
+            const protocolType = protocolMessage.type;
+            if (protocolType === null || protocolType === undefined) {
+                this.logger.debug('incoming protocol message without type', {
+                    id: event.stanzaId,
+                    from: event.chatJid
+                });
+                return;
+            }
+            if (protocolType === proto.Message.ProtocolMessage.Type.APP_STATE_SYNC_KEY_REQUEST) {
+                await this.handleIncomingAppStateSyncKeyRequest(event, protocolMessage);
+                return;
+            }
+            if (protocolType === proto.Message.ProtocolMessage.Type.APP_STATE_SYNC_KEY_SHARE) {
+                await this.handleIncomingAppStateSyncKeyShare(event, protocolMessage);
+                return;
+            }
+            if (protocolType === proto.Message.ProtocolMessage.Type.HISTORY_SYNC_NOTIFICATION) {
+                if (this.options.history?.enabled && protocolMessage.historySyncNotification) {
+                    await this.handleHistorySyncNotification(protocolMessage.historySyncNotification);
+                }
+                return;
+            }
+            if (SYNC_RELATED_PROTOCOL_TYPES.has(protocolType)) {
+                this.logger.info('incoming sync-related protocol message', {
+                    id: event.stanzaId,
+                    from: event.chatJid,
+                    protocolType
+                });
+                return;
+            }
+            this.logger.debug('incoming protocol message received', {
                 id: event.stanzaId,
                 from: event.chatJid,
                 protocolType
             });
-            return;
         }
-        this.logger.debug('incoming protocol message received', {
-            id: event.stanzaId,
-            from: event.chatJid,
-            protocolType
-        });
+        finally {
+            this.leaveIncomingHandler();
+        }
     }
     async handleIncomingAppStateSyncKeyShare(event, protocolMessage) {
         const share = protocolMessage.appStateSyncKeyShare;
@@ -209,9 +209,8 @@ export class WaClient extends EventEmitter {
                 imported
             });
             if (imported > 0) {
-                const hadWaiters = this.appStateKeyShareWaiters.size > 0;
-                this.appStateKeyShareVersion += 1;
-                this.notifyAppStateKeyShareWaiters(true);
+                const hadWaiters = this.keyShareCoordinator.hasWaiters();
+                this.keyShareCoordinator.notifyReceived();
                 if (hadWaiters) {
                     this.logger.debug('app-state key share imported and waiters released', {
                         id: event.stanzaId,
@@ -280,9 +279,18 @@ export class WaClient extends EventEmitter {
             });
             return;
         }
-        const requestedKeys = await Promise.all(requestedKeyIds.map((keyId) => this.appStateStore.getSyncKey(keyId)));
-        const availableKeys = requestedKeys.filter((key) => key !== null);
-        const missingKeyIds = requestedKeyIds.filter((_, index) => requestedKeys[index] === null);
+        const requestedKeys = await this.appStateStore.getSyncKeysBatch(requestedKeyIds);
+        const availableKeys = [];
+        const missingKeyIds = [];
+        for (let i = 0; i < requestedKeys.length; i += 1) {
+            const key = requestedKeys[i];
+            if (key !== null) {
+                availableKeys.push(key);
+            }
+            else {
+                missingKeyIds.push(requestedKeyIds[i]);
+            }
+        }
         try {
             await this.messageDispatch.sendAppStateSyncKeyShare(requesterDeviceJid, availableKeys, missingKeyIds);
             this.logger.info('responded to app-state key request', {
@@ -329,20 +337,18 @@ export class WaClient extends EventEmitter {
             return false;
         }
         const candidateUser = toUserJid(candidateJid);
-        const meUsers = [credentials.meJid, credentials.meLid]
-            .filter((value) => !!value)
-            .map((jid) => toUserJid(jid));
-        return meUsers.includes(candidateUser);
+        return ((!!credentials.meJid && toUserJid(credentials.meJid) === candidateUser) ||
+            (!!credentials.meLid && toUserJid(credentials.meLid) === candidateUser));
     }
     async handleHistorySyncNotification(notification) {
         try {
             await processHistorySyncNotification({
                 logger: this.logger,
                 mediaTransfer: this.mediaTransfer,
-                contactStore: this.contactStore,
-                messageStore: this.messageStore,
-                threadStore: this.threadStore,
-                emitEvent: this.emit.bind(this)
+                writeBehind: this.writeBehind,
+                emitEvent: this.emit.bind(this),
+                onPrivacyTokens: (conversations) => this.trustedContactToken.hydrateFromHistorySync(conversations),
+                onNctSalt: (salt) => this.trustedContactToken.hydrateNctSaltFromHistorySync(salt)
             }, notification);
         }
         catch (error) {
@@ -369,144 +375,118 @@ export class WaClient extends EventEmitter {
             this.logger.trace('wa client connect already in-flight');
             return this.connectPromise;
         }
-        this.connectPromise = this.connectInternal().finally(() => {
+        this.acceptingIncomingEvents = true;
+        this.connectPromise = this.connectionManager
+            .connect((frame) => this.handleIncomingFrame(frame))
+            .then(() => {
+            this.emit('connection', {
+                status: 'open',
+                reason: 'connected',
+                code: null,
+                isLogout: false,
+                isNewLogin: this.connectionManager.wasNewLogin()
+            });
+        })
+            .finally(() => {
             this.connectPromise = null;
         });
         return this.connectPromise;
     }
-    async connectInternal() {
-        if (this.comms) {
-            this.logger.trace('wa client connect skipped: comms already created');
-            return;
-        }
-        this.logger.info('wa client connect start');
-        let credentials = await this.authClient.loadOrCreateCredentials();
-        try {
-            await this.startCommsWithCredentials(credentials);
-        }
-        catch (error) {
-            if (credentials.routingInfo) {
-                this.logger.warn('connect failed with routing info, retrying without routing info', {
-                    message: toError(error).message
-                });
-                await this.disconnect();
-                credentials = await this.authClient.clearRoutingInfo();
-                await this.startCommsWithCredentials(credentials);
-            }
-            else {
-                await this.disconnect();
-                throw error;
-            }
-        }
-        this.logger.info('wa client connected');
-        this.emit('connection_open', {});
-    }
-    scheduleReconnectAfterPairing() {
-        this.logger.debug('wa client scheduling reconnect after pairing');
-        setTimeout(() => {
-            void this.reconnectAsRegisteredAfterPairing().catch((error) => {
-                this.handleError(toError(error));
+    async disconnect() {
+        await this.pauseIncomingEventsAndWaitDrain();
+        const writeBehindFlush = await this.writeBehind.flush(this.options.writeBehind?.flushTimeoutMs);
+        if (writeBehindFlush.remaining > 0) {
+            this.logger.warn('disconnect continuing with pending write-behind entries', {
+                remaining: writeBehindFlush.remaining
             });
-        }, 0);
-    }
-    async reconnectAsRegisteredAfterPairing() {
-        if (this.pairingReconnectPromise) {
-            this.logger.trace('pairing reconnect already in-flight');
-            return this.pairingReconnectPromise;
         }
-        this.pairingReconnectPromise = this.reconnectAsRegisteredAfterPairingInternal().finally(() => {
-            this.pairingReconnectPromise = null;
+        this.keyShareCoordinator.notifyDisconnected();
+        await this.connectionManager.disconnect();
+        this.emit('connection', {
+            status: 'close',
+            reason: 'client_disconnected',
+            code: null,
+            isLogout: false,
+            isNewLogin: false
         });
-        return this.pairingReconnectPromise;
-    }
-    async reconnectAsRegisteredAfterPairingInternal() {
-        const credentials = this.authClient.getCurrentCredentials();
-        if (!credentials?.meJid) {
-            this.logger.trace('pairing reconnect skipped: still unregistered');
-            return;
-        }
-        const currentComms = this.comms;
-        if (!currentComms) {
-            this.logger.trace('pairing reconnect skipped: no active comms');
-            return;
-        }
-        this.logger.info('pairing completed, restarting comms as registered');
-        this.keepAlive.stop();
-        this.nodeOrchestrator.clearPending(new Error('restarting comms after pairing'));
-        this.clearCommsBinding();
-        try {
-            await currentComms.stopComms();
-        }
-        catch (error) {
-            this.logger.warn('failed to stop pre-registration comms', {
-                message: toError(error).message
-            });
-        }
-        try {
-            await this.startCommsWithCredentials(credentials);
-        }
-        catch (error) {
-            this.logger.warn('pairing reconnect failed while starting registered comms', {
-                message: toError(error).message
-            });
-            throw error;
-        }
-    }
-    async disconnect() {
-        this.logger.info('wa client disconnect start');
-        this.keepAlive.stop();
-        this.notifyAppStateKeyShareWaiters(false);
-        this.appStateBootstrapKeyShareWaitDone = false;
-        await this.authClient.clearTransientState();
-        this.nodeOrchestrator.clearPending(new Error('client disconnected'));
-        this.clockSkewMs = null;
-        this.mediaConnCache = null;
-        this.passiveTasks.resetInFlightState();
-        const comms = this.comms;
-        this.clearCommsBinding();
-        if (comms) {
-            await comms.stopComms();
-            this.logger.info('wa client disconnected');
-            this.emit('connection_close', {});
-        }
     }
     async requestPairingCode(phoneNumber, shouldShowPushNotification = false) {
-        if (!this.comms || !this.authClient.getCurrentCredentials()) {
+        if (!this.connectionManager.isConnected() || !this.authClient.getCurrentCredentials()) {
             throw new Error('client is not connected');
         }
         this.logger.debug('wa client request pairing code');
         return this.authClient.requestPairingCode(phoneNumber, shouldShowPushNotification);
     }
     async fetchPairingCountryCodeIso() {
-        if (!this.comms || !this.authClient.getCurrentCredentials()) {
+        if (!this.connectionManager.isConnected() || !this.authClient.getCurrentCredentials()) {
             throw new Error('client is not connected');
         }
         this.logger.trace('wa client fetch pairing country code iso');
         return this.authClient.fetchPairingCountryCodeIso();
     }
-    async sendMessage(to, content, options = {}) {
+    async getLidsByPhoneNumbers(phoneNumbers) {
+        if (!this.connectionManager.isConnected() || !this.authClient.getCurrentCredentials()) {
+            throw new Error('client is not connected');
+        }
+        const normalizedPhoneJids = new Array(phoneNumbers.length);
+        for (let index = 0; index < phoneNumbers.length; index += 1) {
+            normalizedPhoneJids[index] = parsePhoneJid(phoneNumbers[index]);
+        }
+        this.logger.trace('wa client query lids by phone numbers', {
+            phones: normalizedPhoneJids.length
+        });
+        return this.signalDeviceSync.queryLidsByPhoneJids(normalizedPhoneJids);
+    }
+    sendMessage(to, content, options = {}) {
         return this.messageDispatch.sendMessage(to, content, options);
     }
     async syncSignalSession(jid, reasonIdentity = false) {
         await this.messageDispatch.syncSignalSession(jid, reasonIdentity);
+        if (reasonIdentity) {
+            this.trustedContactToken.reissueOnIdentityChange(jid).catch((err) => this.logger.warn('tc token reissue on identity change failed', {
+                jid,
+                message: toError(err).message
+            }));
+        }
+    }
+    get chat() {
+        return this.chatCoordinator;
     }
-    async sendReceipt(input) {
-        await this.messageDispatch.sendReceipt(input);
+    get group() {
+        return this.groupCoordinator;
+    }
+    get privacy() {
+        return this.privacyCoordinator;
+    }
+    get profile() {
+        return this.profileCoordinator;
+    }
+    get business() {
+        return this.businessCoordinator;
+    }
+    sendReceipt(input) {
+        return this.messageDispatch.sendReceipt(input);
+    }
+    flushAppStateMutations() {
+        return this.chatCoordinator.flushMutations();
+    }
+    flushWriteBehind(timeoutMs) {
+        return this.writeBehind.flush(timeoutMs);
     }
     async exportAppState() {
         return this.appStateSync.exportState();
     }
     async syncAppState(options = {}) {
-        if (!this.comms) {
+        if (!this.connectionManager.isConnected()) {
             throw new Error('client is not connected');
         }
         const shouldWaitForKeyShare = (await this.appStateStore.getActiveSyncKey()) === null;
-        if (shouldWaitForKeyShare && !this.appStateBootstrapKeyShareWaitDone) {
-            this.appStateBootstrapKeyShareWaitDone = true;
+        if (shouldWaitForKeyShare && !this.keyShareCoordinator.isBootstrapDone()) {
+            this.keyShareCoordinator.markBootstrapDone();
             this.logger.info('app-state bootstrap pre-sync waiting for key share', {
                 timeoutMs: WA_APP_STATE_KEY_SHARE_WAIT_TIMEOUT_MS
             });
-            const received = await this.waitForAppStateKeyShare(WA_APP_STATE_KEY_SHARE_WAIT_TIMEOUT_MS);
+            const received = await this.keyShareCoordinator.waitForShare(WA_APP_STATE_KEY_SHARE_WAIT_TIMEOUT_MS);
             if (received) {
                 this.logger.info('app-state bootstrap pre-sync received key share, continuing sync');
             }
@@ -523,17 +503,16 @@ export class WaClient extends EventEmitter {
             return syncResult;
         }
         let retryCount = 0;
-        let observedKeyShareVersion = this.appStateKeyShareVersion;
-        while (blockedCollections.length > 0 &&
-            retryCount < WA_APP_STATE_KEY_SHARE_MAX_RETRIES) {
-            const hasFreshShare = this.appStateKeyShareVersion !== observedKeyShareVersion;
+        let observedKeyShareVersion = this.keyShareCoordinator.getVersion();
+        while (blockedCollections.length > 0 && retryCount < WA_APP_STATE_KEY_SHARE_MAX_RETRIES) {
+            const hasFreshShare = this.keyShareCoordinator.getVersion() !== observedKeyShareVersion;
             if (!hasFreshShare) {
                 this.logger.info('app-state bootstrap waiting for key share', {
                     blockedCollections: blockedCollections.join(','),
                     timeoutMs: WA_APP_STATE_KEY_SHARE_WAIT_TIMEOUT_MS,
                     retryCount: retryCount + 1
                 });
-                const received = await this.waitForAppStateKeyShare(WA_APP_STATE_KEY_SHARE_WAIT_TIMEOUT_MS);
+                const received = await this.keyShareCoordinator.waitForShare(WA_APP_STATE_KEY_SHARE_WAIT_TIMEOUT_MS);
                 if (!received) {
                     this.logger.warn('app-state bootstrap key share wait timed out', {
                         blockedCollections: blockedCollections.join(','),
@@ -542,7 +521,7 @@ export class WaClient extends EventEmitter {
                     break;
                 }
             }
-            observedKeyShareVersion = this.appStateKeyShareVersion;
+            observedKeyShareVersion = this.keyShareCoordinator.getVersion();
             retryCount += 1;
             this.logger.info('app-state bootstrap retrying sync after key share', {
                 retryCount,
@@ -569,41 +548,13 @@ export class WaClient extends EventEmitter {
             });
     }
     getBlockedAppStateCollections(syncResult) {
-        return syncResult.collections
-            .filter((entry) => entry.state === WA_APP_STATE_COLLECTION_STATES.BLOCKED)
-            .map((entry) => entry.collection);
-    }
-    async waitForAppStateKeyShare(timeoutMs) {
-        return new Promise((resolve) => {
-            let settled = false;
-            let timeoutHandle = null;
-            const waiter = (received) => {
-                if (settled) {
-                    return;
-                }
-                settled = true;
-                if (timeoutHandle) {
-                    clearTimeout(timeoutHandle);
-                    timeoutHandle = null;
-                }
-                this.appStateKeyShareWaiters.delete(waiter);
-                resolve(received);
-            };
-            this.appStateKeyShareWaiters.add(waiter);
-            timeoutHandle = setTimeout(() => {
-                waiter(false);
-            }, timeoutMs);
-        });
-    }
-    notifyAppStateKeyShareWaiters(received) {
-        if (this.appStateKeyShareWaiters.size === 0) {
-            return;
-        }
-        const waiters = [...this.appStateKeyShareWaiters.values()];
-        this.appStateKeyShareWaiters.clear();
-        for (const waiter of waiters) {
-            waiter(received);
+        const blocked = [];
+        for (const entry of syncResult.collections) {
+            if (entry.state === WA_APP_STATE_COLLECTION_STATES.BLOCKED) {
+                blocked.push(entry.collection);
+            }
         }
+        return blocked;
     }
     emitChatEventsFromAppStateSyncResult(syncResult) {
         const shouldEmitSnapshotMutations = this.options.chatEvents?.emitSnapshotMutations === true;
@@ -627,6 +578,7 @@ export class WaClient extends EventEmitter {
                     continue;
                 }
                 try {
+                    this.handleNctSaltMutation(mutation);
                     const event = parseChatEventFromAppStateMutation(mutation);
                     if (!event) {
                         continue;
@@ -644,102 +596,101 @@ export class WaClient extends EventEmitter {
             }
         }
     }
-    async startCommsWithCredentials(credentials) {
-        this.logger.debug('starting comms with credentials', {
-            registered: credentials.meJid !== null && credentials.meJid !== undefined
-        });
-        const commsConfig = this.authClient.buildCommsConfig(this.options);
-        const comms = new WaComms(commsConfig, this.logger);
-        this.mediaConnCache = null;
-        this.nodeTransport.bindComms(comms);
-        try {
-            comms.startComms(async (frame) => this.handleIncomingFrame(frame));
-            await comms.waitForConnection(commsConfig.connectTimeoutMs);
-            this.comms = comms;
-            this.logger.info('comms connected');
-            comms.startHandlingRequests();
-            if (credentials.meJid) {
-                this.keepAlive.start();
-            }
-            else {
-                this.keepAlive.stop();
-            }
-            const serverStaticKey = comms.getServerStaticKey();
-            if (!serverStaticKey) {
-                this.logger.trace('no server static key available to persist');
-            }
-            else {
-                await this.authClient.persistServerStaticKey(serverStaticKey);
-                this.logger.debug('persisted server static key after comms connect');
-            }
-            this.passiveTasks.startPassiveTasksAfterConnect();
+    handleNctSaltMutation(mutation) {
+        const nctAction = mutation.value?.nctSaltSyncAction;
+        if (!nctAction) {
+            return;
         }
-        catch (error) {
-            this.clearCommsBinding();
-            try {
-                await comms.stopComms();
-            }
-            catch (stopError) {
-                this.logger.warn('failed to cleanup comms after connection start failure', {
-                    message: toError(stopError).message
-                });
-            }
-            throw error;
+        if (mutation.operation === 'set' && nctAction.salt) {
+            this.trustedContactToken.handleNctSaltSync(nctAction.salt).catch((err) => this.logger.warn('nct salt sync set failed', {
+                message: toError(err).message
+            }));
+        }
+        else if (mutation.operation === 'remove') {
+            this.trustedContactToken.handleNctSaltSync(null).catch((err) => this.logger.warn('nct salt sync remove failed', {
+                message: toError(err).message
+            }));
         }
     }
-    shouldQueueDanglingReceipt(node, error) {
-        if (node.tag !== WA_MESSAGE_TAGS.RECEIPT) {
+    async clearStoredState() {
+        await this.pauseIncomingEventsAndWaitDrain();
+        const writeBehindDestroy = await this.writeBehind.destroy(this.options.writeBehind?.flushTimeoutMs);
+        if (writeBehindDestroy.remaining > 0) {
+            throw new Error(`clear stored state aborted: write-behind did not fully drain (remaining=${writeBehindDestroy.remaining})`);
+        }
+        const danglingReceipts = this.receiptQueue.take();
+        if (danglingReceipts.length > 0) {
+            this.logger.debug('cleared dangling receipts while clearing stored state', {
+                count: danglingReceipts.length
+            });
+        }
+        const s = this.options.logoutStoreClear;
+        const shouldClear = (key) => s === undefined || s[key] !== false;
+        if (shouldClear('auth'))
+            await this.authClient.clearStoredCredentials();
+        if (shouldClear('appState'))
+            await this.appStateStore.clear();
+        if (shouldClear('contacts'))
+            await this.contactStore.clear();
+        if (shouldClear('messages'))
+            await this.messageStore.clear();
+        if (shouldClear('participants'))
+            await this.participantsStore.clear();
+        if (shouldClear('deviceList'))
+            await this.deviceListStore.clear();
+        if (shouldClear('retry'))
+            await this.retryStore.clear();
+        if (shouldClear('signal'))
+            await this.signalStore.clear();
+        if (shouldClear('senderKey'))
+            await this.senderKeyStore.clear();
+        if (shouldClear('threads'))
+            await this.threadStore.clear();
+        if (shouldClear('privacyToken'))
+            await this.privacyTokenStore.clear();
+    }
+    tryEnterIncomingHandler() {
+        if (!this.acceptingIncomingEvents) {
             return false;
         }
-        const normalized = error.message.trim().toLowerCase();
-        return (normalized === 'comms is not connected' ||
-            normalized === 'websocket is not connected' ||
-            normalized === 'noise session socket closed' ||
-            normalized.startsWith('socket closed ('));
+        this.activeIncomingHandlers += 1;
+        if (this.acceptingIncomingEvents) {
+            return true;
+        }
+        this.leaveIncomingHandler();
+        return false;
     }
-    enqueueDanglingReceipt(node) {
-        if (this.danglingReceipts.length >= WA_DEFAULTS.MAX_DANGLING_RECEIPTS) {
-            this.danglingReceipts.shift();
+    leaveIncomingHandler() {
+        if (this.activeIncomingHandlers <= 0) {
+            return;
+        }
+        this.activeIncomingHandlers -= 1;
+        if (this.activeIncomingHandlers === 0) {
+            this.notifyIncomingHandlersDrained();
         }
-        this.danglingReceipts.push(node.content === undefined
-            ? {
-                tag: node.tag,
-                attrs: { ...node.attrs }
-            }
-            : {
-                tag: node.tag,
-                attrs: { ...node.attrs },
-                content: node.content
-            });
     }
-    async clearStoredState() {
-        await this.authClient.clearStoredCredentials();
-        await this.appStateStore.clear();
-        await this.contactStore.clear();
-        await this.messageStore.clear();
-        await this.participantsStore.clear();
-        await this.deviceListStore.clear();
-        await this.retryStore.clear();
-        await this.signalStore.clear();
-        await this.senderKeyStore.clear();
-        await this.threadStore.clear();
+    async pauseIncomingEventsAndWaitDrain() {
+        this.acceptingIncomingEvents = false;
+        if (this.activeIncomingHandlers === 0) {
+            return;
+        }
+        await new Promise((resolve) => {
+            this.incomingHandlersDrainedWaiters[this.incomingHandlersDrainedWaiters.length] =
+                resolve;
+        });
+    }
+    notifyIncomingHandlersDrained() {
+        if (this.incomingHandlersDrainedWaiters.length === 0) {
+            return;
+        }
+        const waitersLength = this.incomingHandlersDrainedWaiters.length;
+        for (let index = 0; index < waitersLength; index += 1) {
+            this.incomingHandlersDrainedWaiters[index]();
+        }
+        this.incomingHandlersDrainedWaiters.length = 0;
     }
     handleError(error) {
         this.logger.error('wa client error', { message: error.message });
         this.emit('client_error', { error });
     }
-    clearCommsBinding() {
-        this.notifyAppStateKeyShareWaiters(false);
-        this.comms = null;
-        this.nodeTransport.bindComms(null);
-    }
-    updateClockSkewFromSuccess(serverUnixSeconds) {
-        const serverMs = serverUnixSeconds * 1000;
-        const nowMs = Date.now();
-        this.clockSkewMs = serverMs - nowMs;
-        this.logger.debug('updated clock skew from success', {
-            serverUnixSeconds,
-            clockSkewMs: this.clockSkewMs
-        });
-    }
 }