zapo-js 0.2.0 → 1.0.0

package/dist/client/WaClientFactory.js

@@ -2,35 +2,49 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveWaClientBase = resolveWaClientBase;
 exports.buildWaClientDependencies = buildWaClientDependencies;
-const WaAppStateSyncClient_1 = require("../appstate/WaAppStateSyncClient");
+const WaAppStateSyncClient_1 = require("../appstate/sync/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 WaBotCoordinator_1 = require("./coordinators/WaBotCoordinator");
+const WaBroadcastListCoordinator_1 = require("./coordinators/WaBroadcastListCoordinator");
 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 WaLowLevelCoordinator_1 = require("./coordinators/WaLowLevelCoordinator");
+const WaMessageCoordinator_1 = require("./coordinators/WaMessageCoordinator");
 const WaMessageDispatchCoordinator_1 = require("./coordinators/WaMessageDispatchCoordinator");
+const WaNewsletterCoordinator_1 = require("./coordinators/WaNewsletterCoordinator");
+const WaOfflineResumeCoordinator_1 = require("./coordinators/WaOfflineResumeCoordinator");
 const WaPassiveTasksCoordinator_1 = require("./coordinators/WaPassiveTasksCoordinator");
+const WaPresenceCoordinator_1 = require("./coordinators/WaPresenceCoordinator");
 const WaPrivacyCoordinator_1 = require("./coordinators/WaPrivacyCoordinator");
 const WaProfileCoordinator_1 = require("./coordinators/WaProfileCoordinator");
 const WaRetryCoordinator_1 = require("./coordinators/WaRetryCoordinator");
+const WaStatusCoordinator_1 = require("./coordinators/WaStatusCoordinator");
 const WaStreamControlCoordinator_1 = require("./coordinators/WaStreamControlCoordinator");
 const WaTrustedContactTokenCoordinator_1 = require("./coordinators/WaTrustedContactTokenCoordinator");
-const dirty_1 = require("./dirty");
 const devices_1 = require("./events/devices");
+const dirty_1 = require("./events/dirty");
 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 group_metadata_1 = require("./messaging/group-metadata");
 const key_protocol_1 = require("./messaging/key-protocol");
-const participants_1 = require("./messaging/participants");
-const WaMediaTransferClient_1 = require("../media/WaMediaTransferClient");
-const incoming_1 = require("../message/incoming");
+const link_preview_1 = require("./messaging/link-preview");
+const messages_1 = require("./messaging/messages");
+const WaMediaTransferClient_1 = require("../media/transfer/WaMediaTransferClient");
+const fetcher_1 = require("../message/addons/link-preview/fetcher");
+const newsletter_1 = require("../message/kinds/newsletter");
+const incoming_1 = require("../message/primitives/incoming");
+const peer_data_operation_1 = require("../message/primitives/peer-data-operation");
 const WaMessageClient_1 = require("../message/WaMessageClient");
 const constants_1 = require("../protocol/constants");
 const jid_1 = require("../protocol/jid");
+const presence_1 = require("../protocol/presence");
 const tracker_1 = require("../retry/tracker");
 const SignalDeviceSyncApi_1 = require("../signal/api/SignalDeviceSyncApi");
 const SignalDigestSyncApi_1 = require("../signal/api/SignalDigestSyncApi");
@@ -43,11 +57,13 @@ 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_2 = 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");
 const proxy_1 = require("../transport/proxy");
+const clock_1 = require("../util/clock");
 const primitives_1 = require("../util/primitives");
 const runtime_1 = require("../util/runtime");
 function assertProxyTransport(value, path) {
@@ -105,13 +121,13 @@ function resolveWaClientBase(options, logger) {
     };
 }
 function createIncomingNodeRuntime(input) {
-    const { logger, emitEvent, authClient, connectionManager, nodeOrchestrator, streamControl, mediaMessageBuildOptions, retryCoordinator, messageDispatch, sendNode, syncAppState, disconnect, clearStoredCredentials, getCurrentMeJid, handleClientDirtyBits, incomingMessageAckOptions } = input;
+    const { logger, emitEvent, authClient, connectionManager, nodeOrchestrator, streamControl, mediaMessageBuildOptions, retryCoordinator, messageDispatch, sendNode, syncAppState, disconnect, clearStoredCredentials, getCurrentCredentials, handleClientDirtyBits, incomingMessageAckOptions } = input;
     return {
         handleStreamControlResult: streamControl.handleStreamControlResult,
         persistSuccessAttributes: (attributes) => authClient.persistSuccessAttributes(attributes),
-        emitSuccessNode: (node) => emitEvent('connection_success', { node }),
+        emitSuccessNode: (node) => emitEvent('debug_connection_success', { node }),
         updateClockSkewFromSuccess: (serverUnixSeconds) => connectionManager.updateClockSkewFromSuccess(serverUnixSeconds),
-        shouldWarmupMediaConn: () => !!(getCurrentMeJid() && connectionManager.isConnected()),
+        shouldWarmupMediaConn: () => !!(getCurrentCredentials()?.meJid && connectionManager.isConnected()),
         warmupMediaConn: async () => {
             await (0, messages_1.getMediaConn)(mediaMessageBuildOptions, true);
         },
@@ -125,17 +141,21 @@ function createIncomingNodeRuntime(input) {
         sendNode,
         handleIncomingRetryReceipt: (node) => retryCoordinator.handleIncomingRetryReceipt(node),
         trackOutboundReceipt: (node) => retryCoordinator.trackOutboundReceipt(node),
-        emitIncomingReceipt: (event) => emitEvent('message_receipt', event),
+        emitIncomingReceipt: (event) => emitEvent('receipt', event),
         emitIncomingPresence: (event) => emitEvent('presence', event),
         emitIncomingChatstate: (event) => emitEvent('chatstate', event),
         emitIncomingCall: (event) => emitEvent('call', event),
-        emitIncomingFailure: (event) => emitEvent('failure', event),
+        getCurrentCredentials,
+        emitIncomingFailure: (event) => emitEvent('stream_failure', event),
         emitIncomingErrorStanza: (event) => emitEvent('stanza_error', event),
-        emitIncomingNotification: (event) => emitEvent('notification', event),
+        emitIncomingNotification: (event) => emitEvent('debug_notification', event),
+        emitMexNotification: (event) => emitEvent('mex_notification', event),
+        emitRegistrationCode: (event) => emitEvent('mobile_registration_code', event),
+        emitAccountTakeoverNotice: (event) => emitEvent('mobile_account_takeover_notice', event),
         emitGroupEvent: (event) => {
-            emitEvent('group_event', event);
-            void messageDispatch.mutateParticipantsCacheFromGroupEvent(event).catch((error) => {
-                logger.warn('failed to mutate participants cache from group event', {
+            emitEvent('group', event);
+            void messageDispatch.mutateGroupMetadataCacheFromGroupEvent(event).catch((error) => {
+                logger.warn('failed to mutate group metadata cache from group event', {
                     action: event.action,
                     groupJid: event.groupJid,
                     contextGroupJid: event.contextGroupJid,
@@ -143,7 +163,9 @@ function createIncomingNodeRuntime(input) {
                 });
             });
         },
-        emitUnhandledIncomingNode: (event) => emitEvent('stanza_unhandled', event),
+        emitBusinessEvent: (event) => emitEvent('business', event),
+        emitPictureEvent: (event) => emitEvent('picture', event),
+        emitUnhandledIncomingNode: (event) => emitEvent('debug_unhandled_stanza', event),
         syncAppState,
         stopComms: () => {
             void connectionManager.getComms()?.stopComms();
@@ -155,7 +177,7 @@ function createIncomingNodeRuntime(input) {
     };
 }
 function createPassiveTasksRuntime(input) {
-    const { queryWithContext, authClient, nodeOrchestrator, receiptQueue, getCurrentCredentials } = input;
+    const { queryWithContext, authClient, nodeOrchestrator, receiptQueue, getCurrentCredentials, abPropsCoordinator, markOnlineOnConnect } = input;
     return {
         queryWithContext,
         getCurrentCredentials,
@@ -163,41 +185,63 @@ 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(),
+        sendInitialPresence: async () => {
+            const credentials = getCurrentCredentials();
+            const name = credentials?.meDisplayName ?? undefined;
+            const node = markOnlineOnConnect
+                ? (0, presence_2.buildPresenceNode)({ name })
+                : (0, presence_2.buildPresenceNode)({ type: presence_1.WA_PRESENCE_TYPES.UNAVAILABLE, name });
+            await nodeOrchestrator.sendNode(node, 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;
     let scheduleReconnectAfterPairing = () => undefined;
+    const serverClock = (0, clock_1.createServerClock)(() => connectionManager?.getClockSkewMs() ?? null);
     const nodeTransport = new WaNodeTransport_1.WaNodeTransport(logger);
     const nodeOrchestrator = new WaNodeOrchestrator_1.WaNodeOrchestrator({
         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
+        hostDomain: constants_1.WA_DEFAULTS.HOST_DOMAIN,
+        onClockSkewMs: (clockSkewMs) => connectionManager?.setClockSkewMs(clockSkewMs, 'keepalive')
     });
     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 linkPreviewOptions = options.linkPreview ?? {};
+    const linkPreviewFetcher = linkPreviewOptions.fetcher ??
+        (0, fetcher_1.createDefaultLinkPreviewFetcher)({
+            mediaTransfer,
+            userAgent: linkPreviewOptions.userAgent,
+            fetchTimeoutMs: linkPreviewOptions.fetchTimeoutMs,
+            maxHtmlBytes: linkPreviewOptions.maxHtmlBytes,
+            maxThumbnailBytes: linkPreviewOptions.maxThumbnailBytes,
+            allowPrivateHosts: linkPreviewOptions.allowPrivateHosts,
+            proxy: linkPreviewOptions.proxy ?? options.proxy?.linkPreview
+        });
     const mediaMessageBuildOptions = {
         logger,
         mediaTransfer,
@@ -212,7 +256,17 @@ function buildWaClientDependencies(input) {
         setMediaConnCache: (mediaConn) => {
             mediaConnCacheFallback = mediaConn;
             connectionManager?.setMediaConnCache(mediaConn);
-        }
+        },
+        serverClock,
+        media: options.media,
+        linkPreviewResolver: (content) => (0, link_preview_1.resolveLinkPreview)(content.text, content.linkPreview, {
+            logger,
+            mediaTransfer,
+            getMediaConn: () => (0, messages_1.getMediaConn)(mediaMessageBuildOptions),
+            fetcher: linkPreviewFetcher,
+            options: linkPreviewOptions,
+            serverClock
+        })
     };
     const messageClient = new WaMessageClient_1.WaMessageClient({
         logger,
@@ -222,12 +276,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)();
@@ -240,24 +304,24 @@ 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({
@@ -265,19 +329,23 @@ function buildWaClientDependencies(input) {
         deviceOsDisplayName: options.deviceOsDisplayName,
         devicePlatform: options.devicePlatform,
         requireFullSync: options.requireFullSync,
-        version: options.version
+        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
         },
+        isConnected: () => connectionManager?.isConnected() ?? false,
         callbacks: {
             onQr: (qr, ttlMs) => runtime.emitEvent('auth_qr', { qr, ttlMs }),
             onPairingCode: (code) => runtime.emitEvent('auth_pairing_code', { code }),
-            onPairingRefresh: (forceManual) => runtime.emitEvent('auth_pairing_refresh', { forceManual }),
+            onPairingRefresh: (forceManual) => runtime.emitEvent('auth_pairing_required', { forceManual }),
             onPaired: (credentials) => {
                 runtime.emitEvent('auth_paired', { credentials });
                 scheduleReconnectAfterPairing();
@@ -286,20 +354,32 @@ function buildWaClientDependencies(input) {
         }
     });
     const getCurrentCredentials = authClient.getCurrentCredentials.bind(authClient);
-    const getCurrentMeJid = () => getCurrentCredentials()?.meJid;
-    const getCurrentMeLid = () => getCurrentCredentials()?.meLid;
-    const getCurrentSignedIdentity = () => getCurrentCredentials()?.signedIdentity;
     const groupCoordinator = (0, WaGroupCoordinator_1.createGroupCoordinator)({
-        queryWithContext: runtime.queryWithContext
+        queryWithContext: runtime.queryWithContext,
+        mexSocket: { query: runtime.query }
+    });
+    const newsletterCoordinator = (0, WaNewsletterCoordinator_1.createNewsletterCoordinator)({
+        mexSocket: { query: runtime.query },
+        sendNode: runtime.sendNode,
+        publishMessageNode: (node, opts) => messageDispatch.publishMessageNode(node, opts),
+        queryWithContext: runtime.queryWithContext,
+        generateStanzaId: () => messageDispatch.generateOutgoingMessageId(),
+        mediaTransfer,
+        getMediaConn: () => (0, messages_1.getMediaConn)(mediaMessageBuildOptions),
+        getAbPropString: (name) => abPropsCoordinator.getConfigValue(name),
+        logger
     });
     const privacyCoordinator = (0, WaPrivacyCoordinator_1.createPrivacyCoordinator)({
         queryWithContext: runtime.queryWithContext
     });
-    const profileCoordinator = (0, WaProfileCoordinator_1.createProfileCoordinator)({
+    const businessCoordinator = (0, WaBusinessCoordinator_1.createBusinessCoordinator)({
         queryWithContext: runtime.queryWithContext,
+        mediaTransfer,
+        getMediaConn: () => (0, messages_1.getMediaConn)(mediaMessageBuildOptions),
+        logger,
         generateSid: generateUsyncSid
     });
-    const businessCoordinator = (0, WaBusinessCoordinator_1.createBusinessCoordinator)({
+    const emailCoordinator = (0, WaEmailCoordinator_1.createEmailCoordinator)({
         queryWithContext: runtime.queryWithContext
     });
     const retryTracker = (0, tracker_1.createOutboundRetryTracker)({
@@ -308,26 +388,29 @@ function buildWaClientDependencies(input) {
     });
     const sessionResolver = (0, resolver_1.createSignalSessionResolver)({
         signalProtocol,
-        signalStore: sessionStore.signal,
+        sessionStore: sessionStore.session,
+        identityStore: sessionStore.identity,
         signalIdentitySync,
         signalSessionSync,
         logger
     });
     const fanoutResolver = (0, fanout_1.createDeviceFanoutResolver)({
         signalDeviceSync,
-        getCurrentMeJid,
-        getCurrentMeLid,
+        getCurrentCredentials,
         logger
     });
-    const participantsCache = (0, participants_1.createGroupParticipantsCache)({
-        participantsStore: sessionStore.participants,
-        queryGroupParticipantJids: async (groupJid) => {
+    const groupMetadataCache = (0, group_metadata_1.createGroupMetadataCache)({
+        groupMetadataStore: sessionStore.groupMetadata,
+        queryGroupMetadata: 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;
+            return {
+                participants: participantJids,
+                ephemeral: metadata.ephemeral
+            };
         },
         logger
     });
@@ -337,20 +420,32 @@ function buildWaClientDependencies(input) {
         runtime: {
             queryWithContext: runtime.queryWithContext,
             emitEvent: runtime.emitEvent,
-            getCurrentMeLid: () => getCurrentMeLid() ?? null
+            getCurrentCredentials
         },
+        serverClock,
         durationS: options.privacyToken?.tcTokenDurationS,
         numBuckets: options.privacyToken?.tcTokenNumBuckets,
         senderDurationS: options.privacyToken?.tcTokenSenderDurationS,
         senderNumBuckets: options.privacyToken?.tcTokenSenderNumBuckets,
-        maxDurationS: options.privacyToken?.tcTokenMaxDurationS
+        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),
+        publishProtocolMessageToDevice: (deviceJid, protocolMessage, opts) => messageDispatch.publishProtocolMessageToDevice(deviceJid, protocolMessage, opts),
         fanoutResolver,
-        getCurrentMeJid,
-        getCurrentMeLid,
+        getCurrentCredentials,
         logger
     });
     messageDispatch = new WaMessageDispatchCoordinator_1.WaMessageDispatchCoordinator({
@@ -359,52 +454,143 @@ function buildWaClientDependencies(input) {
         retryTracker,
         sessionResolver,
         fanoutResolver,
-        participantsCache,
+        groupMetadataCache,
         appStateSyncKeyProtocol,
-        buildMessageContent: async (content) => (0, messages_1.buildMediaMessageContent)(mediaMessageBuildOptions, content),
+        buildMessageContent: async (content, ctx) => (0, messages_1.buildMediaMessageContent)(mediaMessageBuildOptions, content, ctx),
         senderKeyManager,
         signalProtocol,
         signalStore: sessionStore.signal,
+        sessionStore: sessionStore.session,
+        identityStore: sessionStore.identity,
         deviceListStore: sessionStore.deviceList,
-        getCurrentMeJid,
-        getCurrentMeLid,
-        getCurrentSignedIdentity,
+        signalDeviceSync,
+        messageSecretStore: sessionStore.messageSecret,
+        getCurrentCredentials,
         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
             }));
-        }
+        },
+        sendNewsletterMessage: (newsletterJid, content, sendOptions, contextInfo) => newsletterCoordinator.send(newsletterJid, content, {
+            stanzaId: sendOptions.id,
+            contextInfo,
+            additionalAttributes: sendOptions.additionalAttributes
+        }),
+        getIcdcHashLength: () => abPropsCoordinator.getConfigValue('md_icdc_hash_length'),
+        mobileMessageIdFormat: options.mobileTransport !== undefined,
+        serverClock
+    });
+    const presenceCoordinator = (0, WaPresenceCoordinator_1.createPresenceCoordinator)({
+        sendNode: (node) => nodeOrchestrator.sendNode(node, false),
+        getCurrentCredentials
+    });
+    const peerDataOperation = (0, peer_data_operation_1.createPeerDataOperationRequester)({
+        logger,
+        publishProtocolMessageToDevice: (deviceJid, protocolMessage, opts) => messageDispatch.publishProtocolMessageToDevice(deviceJid, protocolMessage, opts),
+        getCurrentCredentials,
+        generateOutgoingMessageId: () => messageDispatch.generateOutgoingMessageId(),
+        subscribeToProtocolMessage: runtime.subscribeProtocolMessage
+    });
+    const messageCoordinator = new WaMessageCoordinator_1.WaMessageCoordinator({
+        messageDispatch,
+        mediaTransfer,
+        logger,
+        messageStore: sessionStore.messages,
+        messageSecretStore: sessionStore.messageSecret,
+        trustedContactToken,
+        emitAddon: (event) => runtime.emitEvent('message_addon', event),
+        mexSocket: { query: runtime.query },
+        peerDataOperation
     });
     const retryCoordinator = new WaRetryCoordinator_1.WaRetryCoordinator({
         logger,
         retryStore: sessionStore.retry,
         signalStore: sessionStore.signal,
+        preKeyStore: sessionStore.preKey,
+        sessionStore: sessionStore.session,
         senderKeyStore: sessionStore.senderKey,
         signalProtocol,
+        sessionResolver,
         signalDeviceSync,
         signalMissingPreKeysSync,
         messageClient,
         sendNode: runtime.sendNode,
-        getCurrentMeJid,
-        getCurrentMeLid,
-        getCurrentSignedIdentity
+        getCurrentCredentials,
+        resolveUserIcdc: (userJid) => messageDispatch.resolveUserIcdc(userJid),
+        peerDataOperation,
+        emitIncomingMessage: (event) => {
+            void runtime
+                .handleIncomingMessageEvent(event)
+                .catch((err) => runtime.handleError((0, primitives_1.toError)(err)));
+        }
+    });
+    const botCoordinator = (0, WaBotCoordinator_1.createBotCoordinator)({
+        logger,
+        queryWithContext: runtime.queryWithContext,
+        buildMessageContent: async (content) => (0, messages_1.buildMediaMessageContent)(mediaMessageBuildOptions, content),
+        sendMessage: (to, content, sendOptions) => messageDispatch.sendMessage(to, content, sendOptions ?? {}),
+        messageStore: sessionStore.messages,
+        messageSecretStore: sessionStore.messageSecret,
+        getCurrentCredentials,
+        emitBotChunk: (event) => runtime.emitEvent('message_bot_chunk', event),
+        generateSid: generateUsyncSid
     });
     const appStateSync = new WaAppStateSyncClient_1.WaAppStateSyncClient({
         logger,
         query: runtime.query,
-        getCurrentMeJid,
+        getCurrentMeJid: () => getCurrentCredentials()?.meJid,
         defaultTimeoutMs: options.appStateSyncTimeoutMs,
         store: sessionStore.appState,
+        serverClock,
         onMissingKeys: async ({ keyIds }) => {
             await messageDispatch.requestAppStateSyncKeys(keyIds);
+        },
+        skipMacVerification: options.dangerous?.disableAppStateMacVerification,
+        mobilePrimary: options.mobileTransport !== undefined,
+        isOwnAccountDevice: (deviceJid) => {
+            const credentials = getCurrentCredentials();
+            if (!credentials)
+                return false;
+            const candidateUser = (0, jid_1.toUserJid)(deviceJid);
+            return ((!!credentials.meJid && (0, jid_1.toUserJid)(credentials.meJid) === candidateUser) ||
+                (!!credentials.meLid && (0, jid_1.toUserJid)(credentials.meLid) === candidateUser));
+        },
+        sendKeyShare: (toDeviceJid, keys, missingKeyIds) => messageDispatch.sendAppStateSyncKeyShare(toDeviceJid, keys, missingKeyIds),
+        triggerSync: async () => {
+            await runtime.syncAppState();
         }
     });
     const appStateMutations = new WaAppStateMutationCoordinator_1.WaAppStateMutationCoordinator({
         logger,
         messageStore: sessionStore.messages,
-        syncAppState: runtime.syncAppStateWithOptions
+        appStateSync,
+        mediaTransfer,
+        isConnected: () => connectionManager?.isConnected() ?? false,
+        serverClock,
+        emitSnapshotMutations: options.chatEvents?.emitSnapshotMutations === true,
+        emitMutation: (event) => runtime.emitEvent('mutation', event),
+        nctSaltSink: (salt) => trustedContactToken.handleNctSaltSync(salt),
+        contactSink: runtime.persistContact
+    });
+    const profileCoordinator = (0, WaProfileCoordinator_1.createProfileCoordinator)({
+        queryWithContext: runtime.queryWithContext,
+        generateSid: generateUsyncSid,
+        mexSocket: { query: runtime.query },
+        queryLidsByPhoneJids: (phoneJids) => signalDeviceSync.queryLidsByPhoneJids(phoneJids),
+        mutations: appStateMutations,
+        logger
+    });
+    const statusCoordinator = (0, WaStatusCoordinator_1.createStatusCoordinator)({
+        appStateMutations,
+        buildMessageContent: async (content) => (0, messages_1.buildMediaMessageContent)(mediaMessageBuildOptions, content),
+        publishStatusMessage: (input) => messageDispatch.publishStatusMessage(input)
+    });
+    const broadcastListCoordinator = (0, WaBroadcastListCoordinator_1.createBroadcastListCoordinator)({
+        appStateMutations,
+        buildMessageContent: async (content) => (0, messages_1.buildMediaMessageContent)(mediaMessageBuildOptions, content),
+        publishBroadcastListMessage: (input) => messageDispatch.publishBroadcastListMessage(input)
     });
     connectionManager = new WaConnectionManager_1.WaConnectionManager({
         logger,
@@ -414,14 +600,24 @@ function buildWaClientDependencies(input) {
         nodeOrchestrator,
         nodeTransport,
         getPassiveTasks: () => passiveTasks,
-        clearStoredCredentials: runtime.clearStoredState
+        clearStoredCredentials: runtime.clearStoredState,
+        onPostPairReconnected: () => {
+            runtime.emitEvent('connection', {
+                status: 'open',
+                reason: 'connected',
+                code: null,
+                isLogout: false,
+                isNewLogin: true
+            });
+        }
     });
     if (mediaConnCacheFallback !== null) {
         connectionManager.setMediaConnCache(mediaConnCacheFallback);
     }
     scheduleReconnectAfterPairing = () => connectionManager?.scheduleReconnectAfterPairing();
     const disconnectWithClientSideEffects = async (reason, isLogout, code) => {
-        keyShareCoordinator.notifyDisconnected();
+        abPropsCoordinator.reset();
+        offlineResume.reset();
         await connectionManager?.disconnect();
         runtime.emitEvent('connection', {
             status: 'close',
@@ -434,12 +630,15 @@ function buildWaClientDependencies(input) {
     const connectWithClientSideEffects = async (reason) => {
         runtime.resumeIncomingEvents();
         await connectionManager?.connect(runtime.handleIncomingFrame);
+        if (!authClient.getCurrentCredentials()?.meJid) {
+            return;
+        }
         runtime.emitEvent('connection', {
             status: 'open',
             reason,
             code: null,
             isLogout: false,
-            isNewLogin: connectionManager?.wasNewLogin() ?? false
+            isNewLogin: false
         });
     };
     const clearStoredCredentialsWithClientSideEffects = async () => {
@@ -460,7 +659,7 @@ function buildWaClientDependencies(input) {
     const incomingMessageAckOptions = {
         logger,
         sendNode: runtime.sendNode,
-        getMeJid: getCurrentMeJid,
+        getMeJid: () => getCurrentCredentials()?.meJid,
         signalProtocol,
         senderKeyManager,
         onDecryptFailure: (context, error) => retryCoordinator.onDecryptFailure(context, error),
@@ -469,17 +668,27 @@ function buildWaClientDependencies(input) {
                 .handleIncomingMessageEvent(event)
                 .catch((err) => runtime.handleError((0, primitives_1.toError)(err)));
         },
-        emitUnhandledStanza: (event) => runtime.emitEvent('stanza_unhandled', event)
+        emitNewsletterMessageUpdate: (event) => runtime.emitEvent('newsletter_message_update', event),
+        emitUnhandledStanza: (event) => runtime.emitEvent('debug_unhandled_stanza', event)
     };
     const handleClientDirtyBits = (dirtyBits) => (0, dirty_1.handleDirtyBits)({
         logger,
         queryWithContext: runtime.queryWithContext,
         getCurrentCredentials,
         syncAppState: runtime.syncAppState,
-        generateUsyncSid
+        generateUsyncSid,
+        newsletterListSubscribed: () => newsletterCoordinator.listSubscribed()
     }, 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,
@@ -494,11 +703,47 @@ function buildWaClientDependencies(input) {
             syncAppState: runtime.syncAppState,
             disconnect: disconnectWithClientSideEffects,
             clearStoredCredentials: clearStoredCredentialsWithClientSideEffects,
-            getCurrentMeJid,
+            getCurrentCredentials,
             handleClientDirtyBits,
             incomingMessageAckOptions
         })
     });
+    incomingNode.registerIncomingHandler({
+        tag: constants_1.WA_NODE_TAGS.NOTIFICATION,
+        subtype: constants_1.WA_NOTIFICATION_TYPES.NEWSLETTER,
+        prepend: true,
+        // eslint-disable-next-line @typescript-eslint/require-await
+        handler: async (node) => {
+            const newsletterJid = node.attrs.from;
+            if (!newsletterJid || !(0, jid_1.isNewsletterJid)(newsletterJid)) {
+                return false;
+            }
+            const firstChild = (0, helpers_1.getFirstNodeChild)(node);
+            const childTag = firstChild?.tag;
+            const action = childTag === constants_1.WA_NEWSLETTER_NOTIFICATION_TAGS.LIVE_UPDATES
+                ? 'live_updates'
+                : 'unknown';
+            runtime.emitEvent('newsletter', {
+                rawNode: node,
+                stanzaId: node.attrs.id,
+                chatJid: newsletterJid,
+                stanzaType: node.attrs.type,
+                offline: node.attrs.offline !== undefined,
+                newsletterJid,
+                action,
+                subType: childTag
+            });
+            if (action === 'live_updates') {
+                (0, newsletter_1.processNewsletterLiveUpdates)(node, {
+                    logger,
+                    emitIncomingMessage: incomingMessageAckOptions.emitIncomingMessage,
+                    emitNewsletterMessageUpdate: incomingMessageAckOptions.emitNewsletterMessageUpdate,
+                    emitUnhandledStanza: incomingMessageAckOptions.emitUnhandledStanza
+                });
+            }
+            return false;
+        }
+    });
     incomingNode.registerIncomingHandler({
         tag: constants_1.WA_NODE_TAGS.NOTIFICATION,
         subtype: constants_1.WA_NOTIFICATION_TYPES.ENCRYPT,
@@ -509,7 +754,7 @@ function buildWaClientDependencies(input) {
                 return false;
             }
             const childTag = firstChild.tag;
-            // <count value="N"/> — server prekeys running low
+            // <count value="N"/> – server prekeys running low
             if (childTag === 'count') {
                 const ackNode = (0, global_1.buildAckNode)({
                     kind: 'notification',
@@ -529,7 +774,7 @@ function buildWaClientDependencies(input) {
                 });
                 return true;
             }
-            // <digest/> — digest key sync
+            // <digest/> – digest key sync
             if (childTag === 'digest') {
                 const ackNode = (0, global_1.buildAckNode)({
                     kind: 'notification',
@@ -549,7 +794,7 @@ function buildWaClientDependencies(input) {
                 });
                 return true;
             }
-            // <identity/> — contact identity key changed
+            // <identity/> – contact identity key changed
             if (childTag === 'identity') {
                 const parsed = (0, identity_1.parseIdentityChangeNotification)(node);
                 if (!parsed) {
@@ -562,15 +807,13 @@ function buildWaClientDependencies(input) {
                 });
                 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();
+                const meJid = getCurrentCredentials()?.meJid;
                 if (meJid) {
                     const meUser = (0, jid_1.toUserJid)(meJid);
                     const fromUser = (0, jid_1.toUserJid)(parsed.fromJid);
@@ -582,12 +825,12 @@ function buildWaClientDependencies(input) {
                         return true;
                     }
                 }
-                const oldIdentity = await sessionStore.signal.getRemoteIdentity(address);
+                const oldIdentity = await sessionStore.identity.getRemoteIdentity(address);
                 if (oldIdentity) {
                     logger.info('identity-change: clearing session', {
                         jid: parsed.fromJid
                     });
-                    await sessionStore.signal.deleteSession(address);
+                    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', {
@@ -595,12 +838,13 @@ function buildWaClientDependencies(input) {
                         });
                     });
                 }
-                runtime.emitEvent('notification', {
+                runtime.emitEvent('debug_notification', {
                     rawNode: node,
                     stanzaId: parsed.stanzaId,
                     chatJid: parsed.fromJid,
-                    stanzaType: 'encrypt',
-                    notificationType: 'encrypt',
+                    stanzaType: constants_1.WA_NOTIFICATION_TYPES.ENCRYPT,
+                    offline: node.attrs.offline !== undefined,
+                    notificationType: constants_1.WA_NOTIFICATION_TYPES.ENCRYPT,
                     classification: 'core',
                     details: {
                         kind: 'identity_change',
@@ -638,14 +882,13 @@ function buildWaClientDependencies(input) {
                         server: baseAddress.server,
                         device: device.deviceId
                     };
-                    await sessionStore.signal.deleteSession(address).catch((error) => {
+                    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', {
@@ -653,7 +896,6 @@ function buildWaClientDependencies(input) {
                     });
                 });
             }
-            // 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', {
@@ -661,12 +903,13 @@ function buildWaClientDependencies(input) {
                     });
                 });
             }
-            runtime.emitEvent('notification', {
+            runtime.emitEvent('debug_notification', {
                 rawNode: node,
                 stanzaId: parsed.stanzaId,
                 chatJid: parsed.fromJid,
-                stanzaType: 'devices',
-                notificationType: 'devices',
+                stanzaType: constants_1.WA_NOTIFICATION_TYPES.DEVICES,
+                offline: node.attrs.offline !== undefined,
+                notificationType: constants_1.WA_NOTIFICATION_TYPES.DEVICES,
                 classification: 'core',
                 details: {
                     kind: 'device_list_change',
@@ -700,9 +943,29 @@ function buildWaClientDependencies(input) {
             return true;
         }
     });
+    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({
@@ -710,8 +973,20 @@ function buildWaClientDependencies(input) {
             authClient,
             nodeOrchestrator,
             receiptQueue,
-            getCurrentCredentials
-        })
+            getCurrentCredentials,
+            abPropsCoordinator,
+            markOnlineOnConnect: options.markOnlineOnConnect ?? false
+        }),
+        mobilePrimary: options.mobileTransport !== undefined,
+        appStateSync
+    });
+    const lowLevelCoordinator = (0, WaLowLevelCoordinator_1.createLowLevelCoordinator)({
+        logger,
+        nodeOrchestrator,
+        incomingNode,
+        receiptQueue,
+        isConnected: () => connectionManager?.isConnected() ?? false,
+        defaultIqTimeoutMs: options.iqTimeoutMs
     });
     return {
         nodeTransport,
@@ -730,19 +1005,28 @@ function buildWaClientDependencies(input) {
         signalSessionSync,
         authClient,
         messageDispatch,
+        messageCoordinator,
+        presenceCoordinator,
         retryCoordinator,
         appStateSync,
         chatCoordinator: appStateMutations,
         streamControl,
         incomingNode,
+        lowLevelCoordinator,
         passiveTasks,
         groupCoordinator,
+        statusCoordinator,
+        broadcastListCoordinator,
+        newsletterCoordinator,
         privacyCoordinator,
         profileCoordinator,
         businessCoordinator,
+        botCoordinator,
+        emailCoordinator,
         receiptQueue,
-        keyShareCoordinator,
         connectionManager,
-        trustedContactToken
+        trustedContactToken,
+        abPropsCoordinator,
+        peerDataOperation
     };
 }