zapo-js 0.1.1 → 0.1.2

package/dist/client/WaClientFactory.js

@@ -4,6 +4,10 @@ exports.resolveWaClientBase = resolveWaClientBase;
 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 WaAppStateMutationCoordinator_1 = require("./coordinators/WaAppStateMutationCoordinator");
 const WaGroupCoordinator_1 = require("./coordinators/WaGroupCoordinator");
 const WaIncomingNodeCoordinator_1 = require("./coordinators/WaIncomingNodeCoordinator");
 const WaMessageDispatchCoordinator_1 = require("./coordinators/WaMessageDispatchCoordinator");
@@ -12,10 +16,14 @@ const WaRetryCoordinator_1 = require("./coordinators/WaRetryCoordinator");
 const WaStreamControlCoordinator_1 = require("./coordinators/WaStreamControlCoordinator");
 const dirty_1 = require("./dirty");
 const messages_1 = require("./messages");
+const fanout_1 = require("./messaging/fanout");
+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 WaMessageClient_1 = require("../message/WaMessageClient");
 const constants_1 = require("../protocol/constants");
+const tracker_1 = require("../retry/tracker");
 const SignalDeviceSyncApi_1 = require("../signal/api/SignalDeviceSyncApi");
 const SignalDigestSyncApi_1 = require("../signal/api/SignalDigestSyncApi");
 const SignalIdentitySyncApi_1 = require("../signal/api/SignalIdentitySyncApi");
@@ -23,13 +31,38 @@ const SignalMissingPreKeysSyncApi_1 = require("../signal/api/SignalMissingPreKey
 const SignalRotateKeyApi_1 = require("../signal/api/SignalRotateKeyApi");
 const SignalSessionSyncApi_1 = require("../signal/api/SignalSessionSyncApi");
 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 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 primitives_1 = require("../util/primitives");
 const runtime_1 = require("../util/runtime");
+function assertProxyTransport(value, path) {
+    if (value === undefined) {
+        return;
+    }
+    if (!(0, proxy_1.isProxyTransport)(value)) {
+        throw new Error(`${path} must be a proxy transport instance (dispatcher with dispatch(...) or agent with addRequest(...))`);
+    }
+}
+function validateProxyOptions(options) {
+    const rawProxy = options.proxy;
+    if (rawProxy === undefined) {
+        return;
+    }
+    if (typeof rawProxy !== 'object' || rawProxy === null || Array.isArray(rawProxy)) {
+        throw new Error('proxy must be an object with optional ws/mediaUpload/mediaDownload');
+    }
+    const proxy = rawProxy;
+    assertProxyTransport(proxy?.ws, 'proxy.ws');
+    assertProxyTransport(proxy?.mediaUpload, 'proxy.mediaUpload');
+    assertProxyTransport(proxy?.mediaDownload, 'proxy.mediaDownload');
+}
 function resolveWaClientBase(options, logger) {
+    validateProxyOptions(options);
     const deviceBrowser = options.deviceBrowser ?? constants_1.WA_DEFAULTS.DEVICE_BROWSER;
     const sessionId = options.sessionId.trim();
     if (sessionId.length === 0) {
@@ -61,79 +94,39 @@ function resolveWaClientBase(options, logger) {
         sessionStore
     };
 }
-function createAuthClient(input) {
-    const { options, logger, sessionStore, host } = input;
-    return new WaAuthClient_1.WaAuthClient({
-        deviceBrowser: options.deviceBrowser,
-        deviceOsDisplayName: options.deviceOsDisplayName,
-        devicePlatform: options.devicePlatform,
-        requireFullSync: options.requireFullSync
-    }, {
-        logger,
-        authStore: sessionStore.auth,
-        signalStore: sessionStore.signal,
-        socket: {
-            sendNode: host.sendNode,
-            query: host.query
-        },
-        callbacks: {
-            onQr: (qr, ttlMs) => host.emitEvent('auth_qr', { qr, ttlMs }),
-            onPairingCode: (code) => host.emitEvent('auth_pairing_code', { code }),
-            onPairingRefresh: (forceManual) => host.emitEvent('auth_pairing_refresh', { forceManual }),
-            onPaired: (credentials) => {
-                host.emitEvent('auth_paired', { credentials });
-                host.scheduleReconnectAfterPairing();
-            },
-            onError: (error) => host.handleError(error)
-        }
-    });
-}
-function createCurrentAuthGetters(authClient) {
-    const getCurrentCredentials = () => authClient.getCurrentCredentials();
-    return {
-        getCurrentCredentials,
-        getCurrentMeJid: () => getCurrentCredentials()?.meJid,
-        getCurrentMeLid: () => getCurrentCredentials()?.meLid,
-        getCurrentSignedIdentity: () => getCurrentCredentials()?.signedIdentity
-    };
-}
 function createIncomingMessageAckOptions(input) {
-    const { logger, host, getCurrentMeJid, signalProtocol, senderKeyManager, retryCoordinator } = input;
+    const { logger, sendNode, emitEvent, handleIncomingMessageEvent, handleError, getCurrentMeJid, signalProtocol, senderKeyManager, retryCoordinator } = input;
     return {
         logger,
-        sendNode: host.sendNode,
+        sendNode,
         getMeJid: getCurrentMeJid,
         signalProtocol,
         senderKeyManager,
         onDecryptFailure: (context, error) => retryCoordinator.onDecryptFailure(context, error),
         emitIncomingMessage: (event) => {
-            void host
-                .handleIncomingMessageEvent(event)
-                .catch((err) => host.handleError((0, primitives_1.toError)(err)));
+            void handleIncomingMessageEvent(event).catch((err) => handleError((0, primitives_1.toError)(err)));
         },
-        emitUnhandledStanza: (event) => host.emitEvent('stanza_unhandled', event)
+        emitUnhandledStanza: (event) => emitEvent('stanza_unhandled', event)
     };
 }
 function createHandleClientDirtyBits(input) {
-    const { logger, host, getCurrentCredentials } = input;
+    const { logger, queryWithContext, syncAppState, getCurrentCredentials, generateUsyncSid } = input;
     return (dirtyBits) => (0, dirty_1.handleDirtyBits)({
         logger,
-        queryWithContext: host.queryWithContext,
+        queryWithContext,
         getCurrentCredentials,
-        syncAppState: host.syncAppState
+        syncAppState,
+        generateUsyncSid
     }, dirtyBits);
 }
 function createIncomingNodeRuntime(input) {
-    const { logger, host, authClient, nodeOrchestrator, streamControl, mediaMessageBuildOptions, retryCoordinator, messageDispatch, getCurrentMeJid, handleClientDirtyBits, incomingMessageAckOptions } = input;
+    const { logger, emitEvent, authClient, connectionManager, nodeOrchestrator, streamControl, mediaMessageBuildOptions, retryCoordinator, messageDispatch, sendNode, syncAppState, disconnect, clearStoredCredentials, getCurrentMeJid, handleClientDirtyBits, incomingMessageAckOptions } = input;
     return {
         handleStreamControlResult: streamControl.handleStreamControlResult,
         persistSuccessAttributes: (attributes) => authClient.persistSuccessAttributes(attributes),
-        emitSuccessNode: (node) => host.emitEvent('connection_success', { node }),
-        updateClockSkewFromSuccess: host.updateClockSkewFromSuccess,
-        shouldWarmupMediaConn: () => {
-            const comms = host.getComms();
-            return !!(getCurrentMeJid() && comms && comms.getCommsState().connected);
-        },
+        emitSuccessNode: (node) => emitEvent('connection_success', { node }),
+        updateClockSkewFromSuccess: (serverUnixSeconds) => connectionManager.updateClockSkewFromSuccess(serverUnixSeconds),
+        shouldWarmupMediaConn: () => !!(getCurrentMeJid() && connectionManager.isConnected()),
         warmupMediaConn: async () => {
             await (0, messages_1.getMediaConn)(mediaMessageBuildOptions, true);
         },
@@ -144,18 +137,18 @@ function createIncomingNodeRuntime(input) {
         handleLinkCodeNotificationNode: (node) => authClient.handleLinkCodeNotification(node),
         handleCompanionRegRefreshNotificationNode: (node) => authClient.handleCompanionRegRefreshNotification(node),
         handleIncomingMessageNode: (node) => (0, incoming_1.handleIncomingMessageAck)(node, incomingMessageAckOptions),
-        sendNode: host.sendNode,
+        sendNode,
         handleIncomingRetryReceipt: (node) => retryCoordinator.handleIncomingRetryReceipt(node),
         trackOutboundReceipt: (node) => retryCoordinator.trackOutboundReceipt(node),
-        emitIncomingReceipt: (event) => host.emitEvent('message_receipt', event),
-        emitIncomingPresence: (event) => host.emitEvent('presence', event),
-        emitIncomingChatstate: (event) => host.emitEvent('chatstate', event),
-        emitIncomingCall: (event) => host.emitEvent('call', event),
-        emitIncomingFailure: (event) => host.emitEvent('failure', event),
-        emitIncomingErrorStanza: (event) => host.emitEvent('stanza_error', event),
-        emitIncomingNotification: (event) => host.emitEvent('notification', event),
+        emitIncomingReceipt: (event) => emitEvent('message_receipt', event),
+        emitIncomingPresence: (event) => emitEvent('presence', event),
+        emitIncomingChatstate: (event) => emitEvent('chatstate', event),
+        emitIncomingCall: (event) => emitEvent('call', event),
+        emitIncomingFailure: (event) => emitEvent('failure', event),
+        emitIncomingErrorStanza: (event) => emitEvent('stanza_error', event),
+        emitIncomingNotification: (event) => emitEvent('notification', event),
         emitGroupEvent: (event) => {
-            host.emitEvent('group_event', event);
+            emitEvent('group_event', event);
             void messageDispatch.mutateParticipantsCacheFromGroupEvent(event).catch((error) => {
                 logger.warn('failed to mutate participants cache from group event', {
                     action: event.action,
@@ -165,29 +158,35 @@ function createIncomingNodeRuntime(input) {
                 });
             });
         },
-        emitUnhandledIncomingNode: (event) => host.emitEvent('stanza_unhandled', event),
-        syncAppState: host.syncAppState,
-        disconnect: host.disconnect,
-        clearStoredCredentials: host.clearStoredState,
+        emitUnhandledIncomingNode: (event) => emitEvent('stanza_unhandled', event),
+        syncAppState,
+        disconnect,
+        clearStoredCredentials,
         parseDirtyBits: (nodes) => (0, dirty_1.parseDirtyBits)(nodes, logger),
         handleDirtyBits: (dirtyBits) => handleClientDirtyBits(dirtyBits)
     };
 }
 function createPassiveTasksRuntime(input) {
-    const { host, authClient, nodeOrchestrator, getCurrentCredentials } = input;
+    const { queryWithContext, authClient, nodeOrchestrator, receiptQueue, getCurrentCredentials } = input;
     return {
-        queryWithContext: host.queryWithContext,
+        queryWithContext,
         getCurrentCredentials,
         persistServerHasPreKeys: (serverHasPreKeys) => authClient.persistServerHasPreKeys(serverHasPreKeys),
         sendNodeDirect: (node) => nodeOrchestrator.sendNode(node),
-        takeDanglingReceipts: host.takeDanglingReceipts,
-        requeueDanglingReceipt: host.enqueueDanglingReceipt,
-        shouldQueueDanglingReceipt: host.shouldQueueDanglingReceipt
+        takeDanglingReceipts: () => receiptQueue.take(),
+        requeueDanglingReceipt: (node) => receiptQueue.enqueue(node),
+        shouldQueueDanglingReceipt: (node, error) => receiptQueue.shouldQueue(node, error)
     };
 }
 function buildWaClientDependencies(input) {
-    const { base, host } = 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 nodeTransport = new WaNodeTransport_1.WaNodeTransport(logger);
     const nodeOrchestrator = new WaNodeOrchestrator_1.WaNodeOrchestrator({
         sendNode: async (node) => nodeTransport.sendNode(node),
@@ -198,27 +197,39 @@ function buildWaClientDependencies(input) {
     const keepAlive = new WaKeepAlive_1.WaKeepAlive({
         logger,
         nodeOrchestrator,
-        getComms: host.getComms,
+        getComms: () => connectionManager?.getComms() ?? null,
         intervalMs: options.keepAliveIntervalMs,
         timeoutMs: options.deadSocketTimeoutMs,
         hostDomain: constants_1.WA_DEFAULTS.HOST_DOMAIN
     });
     const mediaTransfer = new WaMediaTransferClient_1.WaMediaTransferClient({
         logger,
-        defaultTimeoutMs: options.mediaTimeoutMs
+        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)
     });
     const mediaMessageBuildOptions = {
         logger,
         mediaTransfer,
         iqTimeoutMs: options.iqTimeoutMs,
-        queryWithContext: host.queryWithContext,
-        getMediaConnCache: host.getMediaConnCache,
-        setMediaConnCache: host.setMediaConnCache
+        queryWithContext: runtime.queryWithContext,
+        getMediaConnCache: () => {
+            if (connectionManager) {
+                return connectionManager.getMediaConnCache();
+            }
+            return mediaConnCacheFallback;
+        },
+        setMediaConnCache: (mediaConn) => {
+            mediaConnCacheFallback = mediaConn;
+            connectionManager?.setMediaConnCache(mediaConn);
+        }
     };
     const messageClient = new WaMessageClient_1.WaMessageClient({
         logger,
-        sendNode: host.sendNode,
-        query: host.query,
+        sendNode: runtime.sendNode,
+        query: runtime.query,
         defaultAckTimeoutMs: options.messageAckTimeoutMs,
         defaultMaxAttempts: options.messageMaxAttempts,
         defaultRetryDelayMs: options.messageRetryDelayMs
@@ -227,56 +238,112 @@ function buildWaClientDependencies(input) {
     const signalProtocol = new SignalProtocol_1.SignalProtocol(sessionStore.signal, logger);
     const signalDigestSync = new SignalDigestSyncApi_1.SignalDigestSyncApi({
         logger,
-        query: host.query,
+        query: runtime.query,
         signalStore: sessionStore.signal,
         defaultTimeoutMs: options.signalFetchKeyBundlesTimeoutMs
     });
+    const generateUsyncSid = (0, usync_1.createUsyncSidGenerator)();
     const signalDeviceSync = new SignalDeviceSyncApi_1.SignalDeviceSyncApi({
         logger,
-        query: host.query,
+        query: runtime.query,
         deviceListStore: sessionStore.deviceList,
-        defaultTimeoutMs: options.signalFetchKeyBundlesTimeoutMs
+        defaultTimeoutMs: options.signalFetchKeyBundlesTimeoutMs,
+        generateSid: generateUsyncSid
     });
     const signalIdentitySync = new SignalIdentitySyncApi_1.SignalIdentitySyncApi({
         logger,
-        query: host.query,
+        query: runtime.query,
         signalStore: sessionStore.signal,
         defaultTimeoutMs: options.signalFetchKeyBundlesTimeoutMs
     });
     const signalMissingPreKeysSync = new SignalMissingPreKeysSyncApi_1.SignalMissingPreKeysSyncApi({
         logger,
-        query: host.query,
+        query: runtime.query,
         defaultTimeoutMs: options.signalFetchKeyBundlesTimeoutMs
     });
     const signalRotateKey = new SignalRotateKeyApi_1.SignalRotateKeyApi({
         logger,
-        query: host.query,
+        query: runtime.query,
         signalStore: sessionStore.signal,
         defaultTimeoutMs: options.signalFetchKeyBundlesTimeoutMs
     });
     const signalSessionSync = new SignalSessionSyncApi_1.SignalSessionSyncApi({
         logger,
-        query: host.query,
+        query: runtime.query,
         defaultTimeoutMs: options.signalFetchKeyBundlesTimeoutMs
     });
-    const authClient = createAuthClient({ options, logger, sessionStore, host });
-    const { getCurrentCredentials, getCurrentMeJid, getCurrentMeLid, getCurrentSignedIdentity } = createCurrentAuthGetters(authClient);
+    const authClient = new WaAuthClient_1.WaAuthClient({
+        deviceBrowser: options.deviceBrowser,
+        deviceOsDisplayName: options.deviceOsDisplayName,
+        devicePlatform: options.devicePlatform,
+        requireFullSync: options.requireFullSync
+    }, {
+        logger,
+        authStore: sessionStore.auth,
+        signalStore: sessionStore.signal,
+        socket: {
+            sendNode: runtime.sendNode,
+            query: runtime.query
+        },
+        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 }),
+            onPaired: (credentials) => {
+                runtime.emitEvent('auth_paired', { credentials });
+                scheduleReconnectAfterPairing();
+            },
+            onError: (error) => runtime.handleError(error)
+        }
+    });
+    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: host.queryWithContext
+        queryWithContext: runtime.queryWithContext
     });
-    const messageDispatch = new WaMessageDispatchCoordinator_1.WaMessageDispatchCoordinator({
-        logger,
-        messageClient,
+    const retryTracker = (0, tracker_1.createOutboundRetryTracker)({
         retryStore: sessionStore.retry,
-        participantsStore: sessionStore.participants,
-        buildMessageContent: async (content) => (0, messages_1.buildMediaMessageContent)(mediaMessageBuildOptions, content),
-        queryGroupParticipantJids: async (groupJid) => (await groupCoordinator.queryGroupMetadata(groupJid)).participants.map((participant) => participant.jid),
-        senderKeyManager,
+        logger
+    });
+    const sessionResolver = (0, resolver_1.createSignalSessionResolver)({
         signalProtocol,
         signalStore: sessionStore.signal,
-        signalDeviceSync,
         signalIdentitySync,
         signalSessionSync,
+        logger
+    });
+    const fanoutResolver = (0, fanout_1.createDeviceFanoutResolver)({
+        signalDeviceSync,
+        getCurrentMeJid,
+        getCurrentMeLid,
+        logger
+    });
+    const participantsCache = (0, participants_1.createGroupParticipantsCache)({
+        participantsStore: sessionStore.participants,
+        queryGroupParticipantJids: async (groupJid) => (await groupCoordinator.queryGroupMetadata(groupJid)).participants.map((participant) => participant.jid),
+        logger
+    });
+    let messageDispatch;
+    const appStateSyncKeyProtocol = (0, key_protocol_1.createAppStateSyncKeyProtocol)({
+        publishSignalMessage: (signalInput, publishOptions) => messageDispatch.publishSignalMessage(signalInput, publishOptions),
+        fanoutResolver,
+        getCurrentMeJid,
+        getCurrentMeLid,
+        logger
+    });
+    messageDispatch = new WaMessageDispatchCoordinator_1.WaMessageDispatchCoordinator({
+        logger,
+        messageClient,
+        retryTracker,
+        sessionResolver,
+        fanoutResolver,
+        participantsCache,
+        appStateSyncKeyProtocol,
+        buildMessageContent: async (content) => (0, messages_1.buildMediaMessageContent)(mediaMessageBuildOptions, content),
+        senderKeyManager,
+        signalProtocol,
         getCurrentMeJid,
         getCurrentMeLid,
         getCurrentSignedIdentity
@@ -290,32 +357,70 @@ function buildWaClientDependencies(input) {
         signalDeviceSync,
         signalMissingPreKeysSync,
         messageClient,
-        sendNode: host.sendNode,
+        sendNode: runtime.sendNode,
         getCurrentMeJid,
         getCurrentMeLid,
         getCurrentSignedIdentity
     });
     const appStateSync = new WaAppStateSyncClient_1.WaAppStateSyncClient({
         logger,
-        query: host.query,
+        query: runtime.query,
+        getCurrentMeJid,
         defaultTimeoutMs: options.appStateSyncTimeoutMs,
         store: sessionStore.appState,
         onMissingKeys: async ({ keyIds }) => {
             await messageDispatch.requestAppStateSyncKeys(keyIds);
         }
     });
+    const appStateMutations = new WaAppStateMutationCoordinator_1.WaAppStateMutationCoordinator({
+        logger,
+        messageStore: sessionStore.messages,
+        syncAppState: runtime.syncAppStateWithOptions
+    });
+    connectionManager = new WaConnectionManager_1.WaConnectionManager({
+        logger,
+        options,
+        authClient,
+        keepAlive,
+        nodeOrchestrator,
+        nodeTransport,
+        getPassiveTasks: () => passiveTasks,
+        clearStoredCredentials: runtime.clearStoredState
+    });
+    if (mediaConnCacheFallback !== null) {
+        connectionManager.setMediaConnCache(mediaConnCacheFallback);
+    }
+    scheduleReconnectAfterPairing = () => connectionManager?.scheduleReconnectAfterPairing();
+    const disconnectWithClientSideEffects = async () => {
+        keyShareCoordinator.notifyDisconnected();
+        await connectionManager?.disconnect();
+        runtime.emitEvent('connection_close', {});
+    };
+    const connectWithClientSideEffects = async () => {
+        await connectionManager?.connect(runtime.handleIncomingFrame);
+        runtime.emitEvent('connection_open', {});
+    };
+    const clearStoredCredentialsWithClientSideEffects = async () => {
+        await connectionManager?.clearStoredCredentials();
+    };
     const streamControl = (0, WaStreamControlCoordinator_1.createStreamControlHandler)({
         logger,
-        getComms: host.getComms,
+        getComms: () => connectionManager?.getComms() ?? null,
         clearPendingQueries: (error) => nodeOrchestrator.clearPending(error),
-        clearMediaConnCache: () => host.setMediaConnCache(null),
-        disconnect: host.disconnect,
-        clearStoredCredentials: host.clearStoredState,
-        connect: host.connect
+        clearMediaConnCache: () => {
+            mediaConnCacheFallback = null;
+            connectionManager?.setMediaConnCache(null);
+        },
+        disconnect: disconnectWithClientSideEffects,
+        clearStoredCredentials: clearStoredCredentialsWithClientSideEffects,
+        connect: connectWithClientSideEffects
     });
     const incomingMessageAckOptions = createIncomingMessageAckOptions({
         logger,
-        host,
+        sendNode: runtime.sendNode,
+        emitEvent: runtime.emitEvent,
+        handleIncomingMessageEvent: runtime.handleIncomingMessageEvent,
+        handleError: runtime.handleError,
         getCurrentMeJid,
         signalProtocol,
         senderKeyManager,
@@ -323,34 +428,42 @@ function buildWaClientDependencies(input) {
     });
     const handleClientDirtyBits = createHandleClientDirtyBits({
         logger,
-        host,
-        getCurrentCredentials
+        queryWithContext: runtime.queryWithContext,
+        syncAppState: runtime.syncAppState,
+        getCurrentCredentials,
+        generateUsyncSid
     });
     const incomingNode = new WaIncomingNodeCoordinator_1.WaIncomingNodeCoordinator({
         logger,
         runtime: createIncomingNodeRuntime({
             logger,
-            host,
+            emitEvent: runtime.emitEvent,
             authClient,
+            connectionManager,
             nodeOrchestrator,
             streamControl,
             mediaMessageBuildOptions,
             retryCoordinator,
             messageDispatch,
+            sendNode: runtime.sendNode,
+            syncAppState: runtime.syncAppState,
+            disconnect: disconnectWithClientSideEffects,
+            clearStoredCredentials: clearStoredCredentialsWithClientSideEffects,
             getCurrentMeJid,
             handleClientDirtyBits,
             incomingMessageAckOptions
         })
     });
-    const passiveTasks = new WaPassiveTasksCoordinator_1.WaPassiveTasksCoordinator({
+    passiveTasks = new WaPassiveTasksCoordinator_1.WaPassiveTasksCoordinator({
         logger,
         signalStore: sessionStore.signal,
         signalDigestSync,
         signalRotateKey,
         runtime: createPassiveTasksRuntime({
-            host,
+            queryWithContext: runtime.queryWithContext,
             authClient,
             nodeOrchestrator,
+            receiptQueue,
             getCurrentCredentials
         })
     });
@@ -373,9 +486,13 @@ function buildWaClientDependencies(input) {
         messageDispatch,
         retryCoordinator,
         appStateSync,
+        appStateMutations,
         streamControl,
         incomingNode,
         passiveTasks,
-        groupCoordinator
+        groupCoordinator,
+        receiptQueue,
+        keyShareCoordinator,
+        connectionManager
     };
 }