zapo-js 0.1.2 → 0.3.0

package/dist/client/WaClientFactory.js

@@ -5,16 +5,25 @@ exports.buildWaClientDependencies = buildWaClientDependencies;
 const WaAppStateSyncClient_1 = require("../appstate/WaAppStateSyncClient");
 const WaAuthClient_1 = require("../auth/WaAuthClient");
 const WaConnectionManager_1 = require("./connection/WaConnectionManager");
-const WaKeyShareCoordinator_1 = require("./connection/WaKeyShareCoordinator");
 const WaReceiptQueue_1 = require("./connection/WaReceiptQueue");
+const WaAbPropsCoordinator_1 = require("./coordinators/WaAbPropsCoordinator");
 const WaAppStateMutationCoordinator_1 = require("./coordinators/WaAppStateMutationCoordinator");
+const WaBusinessCoordinator_1 = require("./coordinators/WaBusinessCoordinator");
+const WaEmailCoordinator_1 = require("./coordinators/WaEmailCoordinator");
 const WaGroupCoordinator_1 = require("./coordinators/WaGroupCoordinator");
 const WaIncomingNodeCoordinator_1 = require("./coordinators/WaIncomingNodeCoordinator");
 const WaMessageDispatchCoordinator_1 = require("./coordinators/WaMessageDispatchCoordinator");
+const WaOfflineResumeCoordinator_1 = require("./coordinators/WaOfflineResumeCoordinator");
 const WaPassiveTasksCoordinator_1 = require("./coordinators/WaPassiveTasksCoordinator");
+const WaPrivacyCoordinator_1 = require("./coordinators/WaPrivacyCoordinator");
+const WaProfileCoordinator_1 = require("./coordinators/WaProfileCoordinator");
 const WaRetryCoordinator_1 = require("./coordinators/WaRetryCoordinator");
 const WaStreamControlCoordinator_1 = require("./coordinators/WaStreamControlCoordinator");
+const WaTrustedContactTokenCoordinator_1 = require("./coordinators/WaTrustedContactTokenCoordinator");
 const dirty_1 = require("./dirty");
+const devices_1 = require("./events/devices");
+const identity_1 = require("./events/identity");
+const privacy_token_1 = require("./events/privacy-token");
 const messages_1 = require("./messages");
 const fanout_1 = require("./messaging/fanout");
 const key_protocol_1 = require("./messaging/key-protocol");
@@ -23,6 +32,7 @@ const WaMediaTransferClient_1 = require("../media/WaMediaTransferClient");
 const incoming_1 = require("../message/incoming");
 const WaMessageClient_1 = require("../message/WaMessageClient");
 const constants_1 = require("../protocol/constants");
+const jid_1 = require("../protocol/jid");
 const tracker_1 = require("../retry/tracker");
 const SignalDeviceSyncApi_1 = require("../signal/api/SignalDeviceSyncApi");
 const SignalDigestSyncApi_1 = require("../signal/api/SignalDigestSyncApi");
@@ -34,6 +44,9 @@ const SenderKeyManager_1 = require("../signal/group/SenderKeyManager");
 const resolver_1 = require("../signal/session/resolver");
 const SignalProtocol_1 = require("../signal/session/SignalProtocol");
 const WaKeepAlive_1 = require("../transport/keepalive/WaKeepAlive");
+const global_1 = require("../transport/node/builders/global");
+const presence_1 = require("../transport/node/builders/presence");
+const helpers_1 = require("../transport/node/helpers");
 const usync_1 = require("../transport/node/usync");
 const WaNodeOrchestrator_1 = require("../transport/node/WaNodeOrchestrator");
 const WaNodeTransport_1 = require("../transport/node/WaNodeTransport");
@@ -94,31 +107,6 @@ function resolveWaClientBase(options, logger) {
         sessionStore
     };
 }
-function createIncomingMessageAckOptions(input) {
-    const { logger, sendNode, emitEvent, handleIncomingMessageEvent, handleError, getCurrentMeJid, signalProtocol, senderKeyManager, retryCoordinator } = input;
-    return {
-        logger,
-        sendNode,
-        getMeJid: getCurrentMeJid,
-        signalProtocol,
-        senderKeyManager,
-        onDecryptFailure: (context, error) => retryCoordinator.onDecryptFailure(context, error),
-        emitIncomingMessage: (event) => {
-            void handleIncomingMessageEvent(event).catch((err) => handleError((0, primitives_1.toError)(err)));
-        },
-        emitUnhandledStanza: (event) => emitEvent('stanza_unhandled', event)
-    };
-}
-function createHandleClientDirtyBits(input) {
-    const { logger, queryWithContext, syncAppState, getCurrentCredentials, generateUsyncSid } = input;
-    return (dirtyBits) => (0, dirty_1.handleDirtyBits)({
-        logger,
-        queryWithContext,
-        getCurrentCredentials,
-        syncAppState,
-        generateUsyncSid
-    }, dirtyBits);
-}
 function createIncomingNodeRuntime(input) {
     const { logger, emitEvent, authClient, connectionManager, nodeOrchestrator, streamControl, mediaMessageBuildOptions, retryCoordinator, messageDispatch, sendNode, syncAppState, disconnect, clearStoredCredentials, getCurrentMeJid, handleClientDirtyBits, incomingMessageAckOptions } = input;
     return {
@@ -147,6 +135,8 @@ function createIncomingNodeRuntime(input) {
         emitIncomingFailure: (event) => emitEvent('failure', event),
         emitIncomingErrorStanza: (event) => emitEvent('stanza_error', event),
         emitIncomingNotification: (event) => emitEvent('notification', event),
+        emitRegistrationCode: (event) => emitEvent('registration_code_received', event),
+        emitAccountTakeoverNotice: (event) => emitEvent('account_takeover_notice', event),
         emitGroupEvent: (event) => {
             emitEvent('group_event', event);
             void messageDispatch.mutateParticipantsCacheFromGroupEvent(event).catch((error) => {
@@ -160,6 +150,9 @@ function createIncomingNodeRuntime(input) {
         },
         emitUnhandledIncomingNode: (event) => emitEvent('stanza_unhandled', event),
         syncAppState,
+        stopComms: () => {
+            void connectionManager.getComms()?.stopComms();
+        },
         disconnect,
         clearStoredCredentials,
         parseDirtyBits: (nodes) => (0, dirty_1.parseDirtyBits)(nodes, logger),
@@ -167,7 +160,7 @@ function createIncomingNodeRuntime(input) {
     };
 }
 function createPassiveTasksRuntime(input) {
-    const { queryWithContext, authClient, nodeOrchestrator, receiptQueue, getCurrentCredentials } = input;
+    const { queryWithContext, authClient, nodeOrchestrator, receiptQueue, getCurrentCredentials, abPropsCoordinator } = input;
     return {
         queryWithContext,
         getCurrentCredentials,
@@ -175,14 +168,18 @@ function createPassiveTasksRuntime(input) {
         sendNodeDirect: (node) => nodeOrchestrator.sendNode(node),
         takeDanglingReceipts: () => receiptQueue.take(),
         requeueDanglingReceipt: (node) => receiptQueue.enqueue(node),
-        shouldQueueDanglingReceipt: (node, error) => receiptQueue.shouldQueue(node, error)
+        shouldQueueDanglingReceipt: (node, error) => receiptQueue.shouldQueue(node, error),
+        syncAbProps: () => abPropsCoordinator.sync(),
+        sendPresenceAvailable: async () => {
+            const credentials = getCurrentCredentials();
+            await nodeOrchestrator.sendNode((0, presence_1.buildPresenceNode)({ name: credentials?.meDisplayName ?? undefined }), false);
+        }
     };
 }
 function buildWaClientDependencies(input) {
     const { base, runtime } = input;
     const { options, logger, sessionStore } = base;
     const receiptQueue = new WaReceiptQueue_1.WaReceiptQueue();
-    const keyShareCoordinator = new WaKeyShareCoordinator_1.WaKeyShareCoordinator();
     let connectionManager = null;
     let passiveTasks = null;
     let mediaConnCacheFallback = null;
@@ -192,23 +189,24 @@ function buildWaClientDependencies(input) {
         sendNode: async (node) => nodeTransport.sendNode(node),
         logger,
         defaultTimeoutMs: options.nodeQueryTimeoutMs,
-        hostDomain: constants_1.WA_DEFAULTS.HOST_DOMAIN
+        hostDomain: constants_1.WA_DEFAULTS.HOST_DOMAIN,
+        mobileIqIdFormat: options.mobileTransport !== undefined
     });
     const keepAlive = new WaKeepAlive_1.WaKeepAlive({
         logger,
         nodeOrchestrator,
         getComms: () => connectionManager?.getComms() ?? null,
         intervalMs: options.keepAliveIntervalMs,
+        getIntervalMs: () => abPropsCoordinator.getConfigValue('heartbeat_interval_s') * 1000,
         timeoutMs: options.deadSocketTimeoutMs,
         hostDomain: constants_1.WA_DEFAULTS.HOST_DOMAIN
     });
     const mediaTransfer = new WaMediaTransferClient_1.WaMediaTransferClient({
         logger,
         defaultTimeoutMs: options.mediaTimeoutMs,
-        defaultUploadDispatcher: (0, proxy_1.toProxyDispatcher)(options.proxy?.mediaUpload),
-        defaultDownloadDispatcher: (0, proxy_1.toProxyDispatcher)(options.proxy?.mediaDownload),
         defaultUploadAgent: (0, proxy_1.toProxyAgent)(options.proxy?.mediaUpload),
-        defaultDownloadAgent: (0, proxy_1.toProxyAgent)(options.proxy?.mediaDownload)
+        defaultDownloadAgent: (0, proxy_1.toProxyAgent)(options.proxy?.mediaDownload),
+        skipMacVerification: options.dangerous?.disableMediaMacVerification
     });
     const mediaMessageBuildOptions = {
         logger,
@@ -224,7 +222,8 @@ function buildWaClientDependencies(input) {
         setMediaConnCache: (mediaConn) => {
             mediaConnCacheFallback = mediaConn;
             connectionManager?.setMediaConnCache(mediaConn);
-        }
+        },
+        media: options.media
     };
     const messageClient = new WaMessageClient_1.WaMessageClient({
         logger,
@@ -234,12 +233,22 @@ function buildWaClientDependencies(input) {
         defaultMaxAttempts: options.messageMaxAttempts,
         defaultRetryDelayMs: options.messageRetryDelayMs
     });
-    const senderKeyManager = new SenderKeyManager_1.SenderKeyManager(sessionStore.senderKey);
-    const signalProtocol = new SignalProtocol_1.SignalProtocol(sessionStore.signal, logger);
+    const senderKeyManager = new SenderKeyManager_1.SenderKeyManager(sessionStore.senderKey, {
+        getFutureMessagesMax: () => abPropsCoordinator.getConfigValue('web_signal_future_messages_max'),
+        skipSignatureVerification: options.dangerous?.disableSenderKeySignatureVerification
+    });
+    const signalProtocol = new SignalProtocol_1.SignalProtocol({
+        signal: sessionStore.signal,
+        preKey: sessionStore.preKey,
+        session: sessionStore.session,
+        identity: sessionStore.identity
+    }, logger);
+    const signalSystemQuery = (node, timeoutMs) => runtime.query(node, timeoutMs, { useSystemId: true });
     const signalDigestSync = new SignalDigestSyncApi_1.SignalDigestSyncApi({
         logger,
-        query: runtime.query,
+        query: signalSystemQuery,
         signalStore: sessionStore.signal,
+        preKeyStore: sessionStore.preKey,
         defaultTimeoutMs: options.signalFetchKeyBundlesTimeoutMs
     });
     const generateUsyncSid = (0, usync_1.createUsyncSidGenerator)();
@@ -252,35 +261,39 @@ function buildWaClientDependencies(input) {
     });
     const signalIdentitySync = new SignalIdentitySyncApi_1.SignalIdentitySyncApi({
         logger,
-        query: runtime.query,
-        signalStore: sessionStore.signal,
+        query: signalSystemQuery,
+        identityStore: sessionStore.identity,
         defaultTimeoutMs: options.signalFetchKeyBundlesTimeoutMs
     });
     const signalMissingPreKeysSync = new SignalMissingPreKeysSyncApi_1.SignalMissingPreKeysSyncApi({
         logger,
-        query: runtime.query,
+        query: signalSystemQuery,
         defaultTimeoutMs: options.signalFetchKeyBundlesTimeoutMs
     });
     const signalRotateKey = new SignalRotateKeyApi_1.SignalRotateKeyApi({
         logger,
-        query: runtime.query,
+        query: signalSystemQuery,
         signalStore: sessionStore.signal,
         defaultTimeoutMs: options.signalFetchKeyBundlesTimeoutMs
     });
     const signalSessionSync = new SignalSessionSyncApi_1.SignalSessionSyncApi({
         logger,
-        query: runtime.query,
+        query: signalSystemQuery,
         defaultTimeoutMs: options.signalFetchKeyBundlesTimeoutMs
     });
     const authClient = new WaAuthClient_1.WaAuthClient({
         deviceBrowser: options.deviceBrowser,
         deviceOsDisplayName: options.deviceOsDisplayName,
         devicePlatform: options.devicePlatform,
-        requireFullSync: options.requireFullSync
+        requireFullSync: options.requireFullSync,
+        version: options.version,
+        dangerous: options.dangerous,
+        mobileTransport: options.mobileTransport
     }, {
         logger,
         authStore: sessionStore.auth,
         signalStore: sessionStore.signal,
+        preKeyStore: sessionStore.preKey,
         socket: {
             sendNode: runtime.sendNode,
             query: runtime.query
@@ -303,13 +316,27 @@ function buildWaClientDependencies(input) {
     const groupCoordinator = (0, WaGroupCoordinator_1.createGroupCoordinator)({
         queryWithContext: runtime.queryWithContext
     });
+    const privacyCoordinator = (0, WaPrivacyCoordinator_1.createPrivacyCoordinator)({
+        queryWithContext: runtime.queryWithContext
+    });
+    const profileCoordinator = (0, WaProfileCoordinator_1.createProfileCoordinator)({
+        queryWithContext: runtime.queryWithContext,
+        generateSid: generateUsyncSid
+    });
+    const businessCoordinator = (0, WaBusinessCoordinator_1.createBusinessCoordinator)({
+        queryWithContext: runtime.queryWithContext
+    });
+    const emailCoordinator = (0, WaEmailCoordinator_1.createEmailCoordinator)({
+        queryWithContext: runtime.queryWithContext
+    });
     const retryTracker = (0, tracker_1.createOutboundRetryTracker)({
         retryStore: sessionStore.retry,
         logger
     });
     const sessionResolver = (0, resolver_1.createSignalSessionResolver)({
         signalProtocol,
-        signalStore: sessionStore.signal,
+        sessionStore: sessionStore.session,
+        identityStore: sessionStore.identity,
         signalIdentitySync,
         signalSessionSync,
         logger
@@ -322,9 +349,42 @@ function buildWaClientDependencies(input) {
     });
     const participantsCache = (0, participants_1.createGroupParticipantsCache)({
         participantsStore: sessionStore.participants,
-        queryGroupParticipantJids: async (groupJid) => (await groupCoordinator.queryGroupMetadata(groupJid)).participants.map((participant) => participant.jid),
+        queryGroupParticipantJids: async (groupJid) => {
+            const metadata = await groupCoordinator.queryGroupMetadata(groupJid);
+            const participantJids = new Array(metadata.participants.length);
+            for (let index = 0; index < metadata.participants.length; index += 1) {
+                participantJids[index] = metadata.participants[index].jid;
+            }
+            return participantJids;
+        },
         logger
     });
+    const trustedContactToken = new WaTrustedContactTokenCoordinator_1.WaTrustedContactTokenCoordinator({
+        logger,
+        store: sessionStore.privacyToken,
+        runtime: {
+            queryWithContext: runtime.queryWithContext,
+            emitEvent: runtime.emitEvent,
+            getCurrentMeLid: () => getCurrentMeLid() ?? null
+        },
+        durationS: options.privacyToken?.tcTokenDurationS,
+        numBuckets: options.privacyToken?.tcTokenNumBuckets,
+        senderDurationS: options.privacyToken?.tcTokenSenderDurationS,
+        senderNumBuckets: options.privacyToken?.tcTokenSenderNumBuckets,
+        maxDurationS: options.privacyToken?.tcTokenMaxDurationS,
+        getConfigOverrides: () => ({
+            durationS: abPropsCoordinator.getConfigValue('tctoken_duration'),
+            numBuckets: abPropsCoordinator.getConfigValue('tctoken_num_buckets'),
+            senderDurationS: abPropsCoordinator.getConfigValue('tctoken_duration_sender'),
+            senderNumBuckets: abPropsCoordinator.getConfigValue('tctoken_num_buckets_sender')
+        })
+    });
+    const abPropsCoordinator = new WaAbPropsCoordinator_1.WaAbPropsCoordinator({
+        logger,
+        runtime: {
+            queryWithContext: runtime.queryWithContext
+        }
+    });
     let messageDispatch;
     const appStateSyncKeyProtocol = (0, key_protocol_1.createAppStateSyncKeyProtocol)({
         publishSignalMessage: (signalInput, publishOptions) => messageDispatch.publishSignalMessage(signalInput, publishOptions),
@@ -344,14 +404,30 @@ function buildWaClientDependencies(input) {
         buildMessageContent: async (content) => (0, messages_1.buildMediaMessageContent)(mediaMessageBuildOptions, content),
         senderKeyManager,
         signalProtocol,
+        signalStore: sessionStore.signal,
+        sessionStore: sessionStore.session,
+        identityStore: sessionStore.identity,
+        deviceListStore: sessionStore.deviceList,
+        messageSecretStore: sessionStore.messageSecret,
         getCurrentMeJid,
         getCurrentMeLid,
-        getCurrentSignedIdentity
+        getCurrentSignedIdentity,
+        resolvePrivacyTokenNode: (recipientJid) => trustedContactToken.resolveTokenForMessage(recipientJid),
+        onDirectMessageSent: (recipientJid) => {
+            trustedContactToken.maybeIssueSenderToken(recipientJid).catch((err) => logger.warn('sender token issue failed', {
+                to: recipientJid,
+                message: (0, primitives_1.toError)(err).message
+            }));
+        },
+        getIcdcHashLength: () => abPropsCoordinator.getConfigValue('md_icdc_hash_length'),
+        mobileMessageIdFormat: options.mobileTransport !== undefined
     });
     const retryCoordinator = new WaRetryCoordinator_1.WaRetryCoordinator({
         logger,
         retryStore: sessionStore.retry,
         signalStore: sessionStore.signal,
+        preKeyStore: sessionStore.preKey,
+        sessionStore: sessionStore.session,
         senderKeyStore: sessionStore.senderKey,
         signalProtocol,
         signalDeviceSync,
@@ -370,7 +446,9 @@ function buildWaClientDependencies(input) {
         store: sessionStore.appState,
         onMissingKeys: async ({ keyIds }) => {
             await messageDispatch.requestAppStateSyncKeys(keyIds);
-        }
+        },
+        skipMacVerification: options.dangerous?.disableAppStateMacVerification,
+        mobilePrimary: options.mobileTransport !== undefined
     });
     const appStateMutations = new WaAppStateMutationCoordinator_1.WaAppStateMutationCoordinator({
         logger,
@@ -391,14 +469,28 @@ function buildWaClientDependencies(input) {
         connectionManager.setMediaConnCache(mediaConnCacheFallback);
     }
     scheduleReconnectAfterPairing = () => connectionManager?.scheduleReconnectAfterPairing();
-    const disconnectWithClientSideEffects = async () => {
-        keyShareCoordinator.notifyDisconnected();
+    const disconnectWithClientSideEffects = async (reason, isLogout, code) => {
+        abPropsCoordinator.reset();
+        offlineResume.reset();
         await connectionManager?.disconnect();
-        runtime.emitEvent('connection_close', {});
+        runtime.emitEvent('connection', {
+            status: 'close',
+            reason,
+            code,
+            isLogout,
+            isNewLogin: false
+        });
     };
-    const connectWithClientSideEffects = async () => {
+    const connectWithClientSideEffects = async (reason) => {
+        runtime.resumeIncomingEvents();
         await connectionManager?.connect(runtime.handleIncomingFrame);
-        runtime.emitEvent('connection_open', {});
+        runtime.emitEvent('connection', {
+            status: 'open',
+            reason,
+            code: null,
+            isLogout: false,
+            isNewLogin: connectionManager?.wasNewLogin() ?? false
+        });
     };
     const clearStoredCredentialsWithClientSideEffects = async () => {
         await connectionManager?.clearStoredCredentials();
@@ -415,26 +507,37 @@ function buildWaClientDependencies(input) {
         clearStoredCredentials: clearStoredCredentialsWithClientSideEffects,
         connect: connectWithClientSideEffects
     });
-    const incomingMessageAckOptions = createIncomingMessageAckOptions({
+    const incomingMessageAckOptions = {
         logger,
         sendNode: runtime.sendNode,
-        emitEvent: runtime.emitEvent,
-        handleIncomingMessageEvent: runtime.handleIncomingMessageEvent,
-        handleError: runtime.handleError,
-        getCurrentMeJid,
+        getMeJid: getCurrentMeJid,
         signalProtocol,
         senderKeyManager,
-        retryCoordinator
-    });
-    const handleClientDirtyBits = createHandleClientDirtyBits({
+        onDecryptFailure: (context, error) => retryCoordinator.onDecryptFailure(context, error),
+        emitIncomingMessage: (event) => {
+            void runtime
+                .handleIncomingMessageEvent(event)
+                .catch((err) => runtime.handleError((0, primitives_1.toError)(err)));
+        },
+        emitUnhandledStanza: (event) => runtime.emitEvent('stanza_unhandled', event)
+    };
+    const handleClientDirtyBits = (dirtyBits) => (0, dirty_1.handleDirtyBits)({
         logger,
         queryWithContext: runtime.queryWithContext,
-        syncAppState: runtime.syncAppState,
         getCurrentCredentials,
+        syncAppState: runtime.syncAppState,
         generateUsyncSid
+    }, dirtyBits);
+    const offlineResume = new WaOfflineResumeCoordinator_1.WaOfflineResumeCoordinator({
+        logger,
+        runtime: {
+            sendNode: (node) => nodeOrchestrator.sendNode(node, false),
+            emitOfflineResume: (event) => runtime.emitEvent('offline_resume', event)
+        }
     });
     const incomingNode = new WaIncomingNodeCoordinator_1.WaIncomingNodeCoordinator({
         logger,
+        offlineResume,
         runtime: createIncomingNodeRuntime({
             logger,
             emitEvent: runtime.emitEvent,
@@ -454,9 +557,231 @@ function buildWaClientDependencies(input) {
             incomingMessageAckOptions
         })
     });
+    incomingNode.registerIncomingHandler({
+        tag: constants_1.WA_NODE_TAGS.NOTIFICATION,
+        subtype: constants_1.WA_NOTIFICATION_TYPES.ENCRYPT,
+        prepend: true,
+        handler: async (node) => {
+            const firstChild = (0, helpers_1.getFirstNodeChild)(node);
+            if (!firstChild) {
+                return false;
+            }
+            const childTag = firstChild.tag;
+            // <count value="N"/> — server prekeys running low
+            if (childTag === 'count') {
+                const ackNode = (0, global_1.buildAckNode)({
+                    kind: 'notification',
+                    node,
+                    includeType: false
+                });
+                await runtime.sendNode(ackNode);
+                const tasks = passiveTasks;
+                if (!tasks) {
+                    logger.warn('encrypt-count: passive tasks not available');
+                    return true;
+                }
+                await tasks.handlePreKeyLowNotification().catch((error) => {
+                    logger.warn('encrypt-count: prekey upload failed', {
+                        message: (0, primitives_1.toError)(error).message
+                    });
+                });
+                return true;
+            }
+            // <digest/> — digest key sync
+            if (childTag === 'digest') {
+                const ackNode = (0, global_1.buildAckNode)({
+                    kind: 'notification',
+                    node,
+                    includeType: false
+                });
+                await runtime.sendNode(ackNode);
+                const tasks = passiveTasks;
+                if (!tasks) {
+                    logger.warn('encrypt-digest: passive tasks not available');
+                    return true;
+                }
+                await tasks.handleDigestNotification().catch((error) => {
+                    logger.warn('encrypt-digest: digest sync failed', {
+                        message: (0, primitives_1.toError)(error).message
+                    });
+                });
+                return true;
+            }
+            // <identity/> — contact identity key changed
+            if (childTag === 'identity') {
+                const parsed = (0, identity_1.parseIdentityChangeNotification)(node);
+                if (!parsed) {
+                    return false;
+                }
+                const ackNode = (0, global_1.buildAckNode)({
+                    kind: 'notification',
+                    node,
+                    includeType: false
+                });
+                await runtime.sendNode(ackNode);
+                const address = (0, jid_1.parseSignalAddressFromJid)(parsed.fromJid);
+                // ignore companion devices (non-primary)
+                if (address.device !== 0) {
+                    logger.debug('identity-change: ignoring companion device', {
+                        jid: parsed.fromJid
+                    });
+                    return true;
+                }
+                // self-primary identity change → must disconnect
+                const meJid = getCurrentMeJid();
+                if (meJid) {
+                    const meUser = (0, jid_1.toUserJid)(meJid);
+                    const fromUser = (0, jid_1.toUserJid)(parsed.fromJid);
+                    if (meUser === fromUser) {
+                        logger.error('self primary identity changed, disconnecting');
+                        void connectionManager?.getComms()?.stopComms();
+                        await disconnectWithClientSideEffects(constants_1.WA_DISCONNECT_REASONS.PRIMARY_IDENTITY_KEY_CHANGE, true, null);
+                        await clearStoredCredentialsWithClientSideEffects();
+                        return true;
+                    }
+                }
+                const oldIdentity = await sessionStore.identity.getRemoteIdentity(address);
+                if (oldIdentity) {
+                    logger.info('identity-change: clearing session', {
+                        jid: parsed.fromJid
+                    });
+                    await sessionStore.session.deleteSession(address);
+                    const userJid = (0, jid_1.toUserJid)(parsed.fromJid);
+                    await trustedContactToken.reissueOnIdentityChange(userJid).catch((error) => {
+                        logger.warn('identity-change: reissue tc token failed', {
+                            message: (0, primitives_1.toError)(error).message
+                        });
+                    });
+                }
+                runtime.emitEvent('notification', {
+                    rawNode: node,
+                    stanzaId: parsed.stanzaId,
+                    chatJid: parsed.fromJid,
+                    stanzaType: 'encrypt',
+                    notificationType: 'encrypt',
+                    classification: 'core',
+                    details: {
+                        kind: 'identity_change',
+                        displayName: parsed.displayName,
+                        lid: parsed.lid,
+                        hadPreviousIdentity: !!oldIdentity
+                    }
+                });
+                return true;
+            }
+            return false;
+        }
+    });
+    incomingNode.registerIncomingHandler({
+        tag: constants_1.WA_NODE_TAGS.NOTIFICATION,
+        subtype: constants_1.WA_NOTIFICATION_TYPES.DEVICES,
+        prepend: true,
+        handler: async (node) => {
+            const parsed = (0, devices_1.parseDeviceNotification)(node);
+            if (!parsed) {
+                return false;
+            }
+            const ackNode = (0, global_1.buildAckNode)({
+                kind: 'notification',
+                node,
+                includeType: false
+            });
+            await runtime.sendNode(ackNode);
+            const userJid = (0, jid_1.toUserJid)(parsed.fromJid);
+            if (parsed.action === devices_1.DEVICE_NOTIFICATION_ACTIONS.REMOVE) {
+                const baseAddress = (0, jid_1.parseSignalAddressFromJid)(parsed.fromJid);
+                for (const device of parsed.devices) {
+                    const address = {
+                        user: baseAddress.user,
+                        server: baseAddress.server,
+                        device: device.deviceId
+                    };
+                    await sessionStore.session.deleteSession(address).catch((error) => {
+                        logger.warn('devices-notification: delete session failed', {
+                            message: (0, primitives_1.toError)(error).message
+                        });
+                    });
+                }
+            }
+            // invalidate device list cache so next fanout fetches fresh list
+            if (sessionStore.deviceList) {
+                await sessionStore.deviceList.deleteUserDevices(userJid).catch((error) => {
+                    logger.warn('devices-notification: invalidate cache failed', {
+                        message: (0, primitives_1.toError)(error).message
+                    });
+                });
+            }
+            // for update notifications, re-sync immediately
+            if (parsed.action === devices_1.DEVICE_NOTIFICATION_ACTIONS.UPDATE) {
+                signalDeviceSync.syncDeviceList([userJid]).catch((error) => {
+                    logger.warn('devices-notification: sync device list failed', {
+                        message: (0, primitives_1.toError)(error).message
+                    });
+                });
+            }
+            runtime.emitEvent('notification', {
+                rawNode: node,
+                stanzaId: parsed.stanzaId,
+                chatJid: parsed.fromJid,
+                stanzaType: 'devices',
+                notificationType: 'devices',
+                classification: 'core',
+                details: {
+                    kind: 'device_list_change',
+                    action: parsed.action,
+                    devices: parsed.devices
+                }
+            });
+            return true;
+        }
+    });
+    incomingNode.registerIncomingHandler({
+        tag: constants_1.WA_NODE_TAGS.NOTIFICATION,
+        subtype: constants_1.WA_PRIVACY_TOKEN_NOTIFICATION_TYPE,
+        prepend: true,
+        handler: async (node) => {
+            const fromJid = node.attrs.from ?? node.attrs.sender_lid;
+            if (!fromJid) {
+                return false;
+            }
+            const tokens = (0, privacy_token_1.parsePrivacyTokenNotification)(node);
+            if (tokens.length === 0) {
+                return false;
+            }
+            await trustedContactToken.handleIncomingToken(fromJid, tokens);
+            const ackNode = (0, global_1.buildAckNode)({
+                kind: 'notification',
+                node,
+                typeOverride: constants_1.WA_PRIVACY_TOKEN_NOTIFICATION_TYPE
+            });
+            await runtime.sendNode(ackNode);
+            return true;
+        }
+    });
+    // AB Props: sync after successful login and on server notification
+    incomingNode.registerIncomingHandler({
+        tag: constants_1.WA_NODE_TAGS.NOTIFICATION,
+        subtype: constants_1.WA_NOTIFICATION_TYPES.SERVER,
+        prepend: true,
+        handler: async (node) => {
+            const firstChild = (0, helpers_1.getFirstNodeChild)(node);
+            if (!firstChild || firstChild.tag !== constants_1.WA_NODE_TAGS.ABPROPS) {
+                return false;
+            }
+            const ackNode = (0, global_1.buildAckNode)({
+                kind: 'notification',
+                node,
+                includeType: false
+            });
+            await runtime.sendNode(ackNode);
+            abPropsCoordinator.sync();
+            return true;
+        }
+    });
     passiveTasks = new WaPassiveTasksCoordinator_1.WaPassiveTasksCoordinator({
         logger,
         signalStore: sessionStore.signal,
+        preKeyStore: sessionStore.preKey,
         signalDigestSync,
         signalRotateKey,
         runtime: createPassiveTasksRuntime({
@@ -464,8 +789,11 @@ function buildWaClientDependencies(input) {
             authClient,
             nodeOrchestrator,
             receiptQueue,
-            getCurrentCredentials
-        })
+            getCurrentCredentials,
+            abPropsCoordinator
+        }),
+        mobilePrimary: options.mobileTransport !== undefined,
+        appStateSync
     });
     return {
         nodeTransport,
@@ -486,13 +814,18 @@ function buildWaClientDependencies(input) {
         messageDispatch,
         retryCoordinator,
         appStateSync,
-        appStateMutations,
+        chatCoordinator: appStateMutations,
         streamControl,
         incomingNode,
         passiveTasks,
         groupCoordinator,
+        privacyCoordinator,
+        profileCoordinator,
+        businessCoordinator,
+        emailCoordinator,
         receiptQueue,
-        keyShareCoordinator,
-        connectionManager
+        connectionManager,
+        trustedContactToken,
+        abPropsCoordinator
     };
 }