zapo-js 0.1.2 → 0.3.0

package/dist/client/connection/WaConnectionManager.js

@@ -5,6 +5,7 @@ const WaComms_1 = require("../../transport/WaComms");
 const primitives_1 = require("../../util/primitives");
 class WaConnectionManager {
     constructor(options) {
+        this.lastConnectWasNewLogin = false;
         this.logger = options.logger;
         this.options = options.options;
         this.authClient = options.authClient;
@@ -33,11 +34,12 @@ class WaConnectionManager {
         const operation = this.runLifecycleOperation(async () => {
             await this.connectInternal(frameHandler, lifecycleGeneration);
         });
-        this.connectPromise = operation.finally(() => {
-            if (this.connectPromise === operation) {
+        const promise = operation.finally(() => {
+            if (this.connectPromise === promise) {
                 this.connectPromise = null;
             }
         });
+        this.connectPromise = promise;
         return this.connectPromise;
     }
     scheduleReconnectAfterPairing() {
@@ -67,6 +69,9 @@ class WaConnectionManager {
     isConnected() {
         return !!(this.comms && this.comms.getCommsState().connected);
     }
+    wasNewLogin() {
+        return this.lastConnectWasNewLogin;
+    }
     getComms() {
         return this.comms;
     }
@@ -96,6 +101,7 @@ class WaConnectionManager {
         }
         this.logger.info('wa client connect start');
         let credentials = await this.authClient.loadOrCreateCredentials();
+        this.lastConnectWasNewLogin = !credentials.meJid;
         this.assertLifecycleCurrent(lifecycleGeneration, 'connect');
         try {
             await this.startCommsWithCredentials(credentials, frameHandler, lifecycleGeneration);
@@ -130,11 +136,12 @@ class WaConnectionManager {
         const operation = this.runLifecycleOperation(async () => {
             await this.reconnectAsRegisteredAfterPairingInternal();
         });
-        this.pairingReconnectPromise = operation.finally(() => {
-            if (this.pairingReconnectPromise === operation) {
+        const promise = operation.finally(() => {
+            if (this.pairingReconnectPromise === promise) {
                 this.pairingReconnectPromise = null;
             }
         });
+        this.pairingReconnectPromise = promise;
         return this.pairingReconnectPromise;
     }
     async reconnectAsRegisteredAfterPairingInternal() {
@@ -179,12 +186,14 @@ class WaConnectionManager {
         this.pendingComms = null;
         this.clearCommsBinding(currentComms ?? undefined);
         await this.authClient.clearTransientState();
-        if (pendingComms) {
-            await this.stopCommsQuietly(pendingComms, 'failed to stop pending comms during disconnect');
-        }
-        if (currentComms) {
-            await this.stopCommsQuietly(currentComms, 'failed to stop comms during disconnect');
-        }
+        await Promise.all([
+            pendingComms && pendingComms !== currentComms
+                ? this.stopCommsQuietly(pendingComms, 'failed to stop pending comms during disconnect')
+                : Promise.resolve(),
+            currentComms
+                ? this.stopCommsQuietly(currentComms, 'failed to stop comms during disconnect')
+                : Promise.resolve()
+        ]);
         if (this.isLifecycleCurrent(lifecycleGeneration)) {
             this.logger.info('wa client disconnected');
         }
@@ -194,7 +203,10 @@ class WaConnectionManager {
         this.logger.debug('starting comms with credentials', {
             registered: credentials.meJid !== null && credentials.meJid !== undefined
         });
-        const commsConfig = this.authClient.buildCommsConfig(this.options);
+        const commsConfig = this.authClient.buildCommsConfig(this.options, {
+            noiseTrustedRootCa: this.options.testHooks?.noiseRootCa,
+            disableNoiseCertificateChainVerification: this.options.dangerous?.disableNoiseCertificateChainVerification
+        });
         const comms = new WaComms_1.WaComms(commsConfig, this.logger);
         this.pendingComms = comms;
         this.mediaConnCache = null;

package/dist/client/coordinators/WaAbPropsCoordinator.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaAbPropsCoordinator = void 0;
+const abprops_1 = require("../events/abprops");
+const abprops_2 = require("../../protocol/abprops");
+const constants_1 = require("../../protocol/constants");
+const abprops_3 = require("../../transport/node/builders/abprops");
+const primitives_1 = require("../../util/primitives");
+class WaAbPropsCoordinator {
+    constructor(options) {
+        this.logger = options.logger;
+        this.runtime = options.runtime;
+        this.cache = new Map();
+        this.syncState = { hash: null, abKey: null, refreshId: null };
+        this.syncPromise = null;
+        this.syncEpoch = 0;
+        this.pendingSync = false;
+    }
+    getConfigValue(name) {
+        const cached = this.cache.get(name);
+        if (cached !== undefined) {
+            return cached;
+        }
+        return abprops_2.AB_PROP_CONFIGS[name].defaultValue;
+    }
+    sync() {
+        if (this.syncPromise) {
+            this.pendingSync = true;
+            return;
+        }
+        this.startSync();
+    }
+    reset() {
+        this.cache.clear();
+        this.syncState.hash = null;
+        this.syncState.abKey = null;
+        this.syncState.refreshId = null;
+        this.syncPromise = null;
+        this.pendingSync = false;
+        this.syncEpoch += 1;
+    }
+    startSync() {
+        const epoch = this.syncEpoch;
+        this.pendingSync = false;
+        this.syncPromise = this.executeSyncWithRetry(epoch)
+            .catch((error) => {
+            this.logger.warn('ab props sync failed', {
+                message: (0, primitives_1.toError)(error).message
+            });
+        })
+            .finally(() => {
+            if (this.syncEpoch !== epoch) {
+                return;
+            }
+            this.syncPromise = null;
+            if (this.pendingSync) {
+                this.startSync();
+            }
+        });
+    }
+    async executeSyncWithRetry(epoch) {
+        const maxRetries = 3;
+        for (let attempt = 0; attempt < maxRetries; attempt += 1) {
+            if (this.syncEpoch !== epoch) {
+                return;
+            }
+            try {
+                await this.executeSync(epoch);
+                return;
+            }
+            catch (error) {
+                if (attempt === maxRetries - 1) {
+                    throw error;
+                }
+                this.logger.debug('ab props sync retrying', {
+                    attempt: attempt + 1,
+                    message: (0, primitives_1.toError)(error).message
+                });
+            }
+        }
+    }
+    async executeSync(epoch) {
+        const iqNode = (0, abprops_3.buildGetAbPropsIq)({
+            hash: this.syncState.hash,
+            refreshId: this.syncState.refreshId
+        });
+        const response = await this.runtime.queryWithContext('abprops.sync', iqNode, constants_1.WA_DEFAULTS.IQ_TIMEOUT_MS);
+        if (this.syncEpoch !== epoch) {
+            return;
+        }
+        const result = (0, abprops_1.parseAbPropsIqResult)(response);
+        if (result.abKey !== null) {
+            this.syncState.abKey = result.abKey;
+        }
+        if (result.hash !== null) {
+            this.syncState.hash = result.hash;
+        }
+        if (result.refreshId !== null) {
+            this.syncState.refreshId = result.refreshId;
+        }
+        if (!result.isDeltaUpdate) {
+            this.cache.clear();
+        }
+        let applied = 0;
+        for (let i = 0; i < result.props.length; i += 1) {
+            const entry = result.props[i];
+            const name = (0, abprops_2.resolveAbPropNameByCode)(entry.configCode);
+            if (!name) {
+                continue;
+            }
+            const config = abprops_2.AB_PROP_CONFIGS[name];
+            const parsed = parseConfigValue(entry.configValue, config.type, config.defaultValue);
+            this.cache.set(name, parsed);
+            applied += 1;
+        }
+        this.logger.info('ab props synced', {
+            received: result.props.length,
+            applied,
+            isDelta: result.isDeltaUpdate,
+            abKey: result.abKey,
+            refresh: result.refresh !== null ? clampRefresh(result.refresh) : null
+        });
+    }
+}
+exports.WaAbPropsCoordinator = WaAbPropsCoordinator;
+function parseConfigValue(value, type, defaultValue) {
+    if (value === null) {
+        return defaultValue;
+    }
+    if (type === 'bool') {
+        return value === '1' || value === 'true' || value === 'True';
+    }
+    if (type === 'int') {
+        const parsed = Number.parseInt(value, 10);
+        return Number.isSafeInteger(parsed) ? parsed : defaultValue;
+    }
+    return value;
+}
+function clampRefresh(seconds) {
+    return Math.max(abprops_2.WA_ABPROPS_REFRESH_BOUNDS.MIN_S, Math.min(abprops_2.WA_ABPROPS_REFRESH_BOUNDS.MAX_S, seconds));
+}

package/dist/client/coordinators/WaBusinessCoordinator.js

@@ -0,0 +1,232 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBusinessCoordinator = createBusinessCoordinator;
+const _proto_1 = require("../../proto.js");
+const business_1 = require("../../transport/node/builders/business");
+const helpers_1 = require("../../transport/node/helpers");
+const query_1 = require("../../transport/node/query");
+const primitives_1 = require("../../util/primitives");
+function parseBusinessProfiles(result) {
+    const bizNode = (0, helpers_1.findNodeChild)(result, 'business_profile');
+    if (!bizNode) {
+        return [];
+    }
+    const profileNodes = (0, helpers_1.getNodeChildren)(bizNode);
+    const results = new Array(profileNodes.length);
+    let count = 0;
+    for (let i = 0; i < profileNodes.length; i += 1) {
+        const profileNode = profileNodes[i];
+        if (profileNode.tag !== 'profile')
+            continue;
+        const jid = profileNode.attrs.jid;
+        if (!jid)
+            continue;
+        const entry = { jid };
+        const tag = profileNode.attrs.tag;
+        if (tag)
+            entry.tag = tag;
+        const children = profileNode.content;
+        if (!Array.isArray(children)) {
+            results[count] = entry;
+            count += 1;
+            continue;
+        }
+        const websites = [];
+        for (let j = 0; j < children.length; j += 1) {
+            const child = children[j];
+            const text = (0, helpers_1.getNodeTextContent)(child);
+            switch (child.tag) {
+                case 'description':
+                    if (text !== undefined)
+                        entry.description = text;
+                    break;
+                case 'address':
+                    if (text !== undefined)
+                        entry.address = text;
+                    break;
+                case 'email':
+                    if (text !== undefined)
+                        entry.email = text;
+                    break;
+                case 'website':
+                    if (text !== undefined)
+                        websites.push({ url: text });
+                    break;
+                case 'latitude':
+                    if (text !== undefined) {
+                        const val = Number.parseFloat(text);
+                        if (!Number.isNaN(val))
+                            entry.latitude = val;
+                    }
+                    break;
+                case 'longitude':
+                    if (text !== undefined) {
+                        const val = Number.parseFloat(text);
+                        if (!Number.isNaN(val))
+                            entry.longitude = val;
+                    }
+                    break;
+                case 'categories':
+                    entry.categories = parseBusinessCategories(child);
+                    break;
+                case 'business_hours':
+                    entry.businessHours = parseBusinessHoursNode(child);
+                    break;
+                case 'profile_options':
+                    entry.profileOptions = parseProfileOptions(child);
+                    break;
+            }
+        }
+        if (websites.length > 0)
+            entry.websites = websites;
+        results[count] = entry;
+        count += 1;
+    }
+    results.length = count;
+    return results;
+}
+function parseBusinessCategories(node) {
+    const children = (0, helpers_1.getNodeChildren)(node);
+    const categories = new Array(children.length);
+    let count = 0;
+    for (let i = 0; i < children.length; i += 1) {
+        const child = children[i];
+        if (child.tag !== 'category')
+            continue;
+        const id = child.attrs.id;
+        if (!id)
+            continue;
+        categories[count] = { id, name: (0, helpers_1.getNodeTextContent)(child) ?? '' };
+        count += 1;
+    }
+    categories.length = count;
+    return categories;
+}
+function parseBusinessHoursNode(node) {
+    const timezone = node.attrs.timezone;
+    const children = (0, helpers_1.getNodeChildren)(node);
+    const config = new Array(children.length);
+    let count = 0;
+    for (let i = 0; i < children.length; i += 1) {
+        const child = children[i];
+        if (child.tag !== 'business_hours_config')
+            continue;
+        const dayOfWeek = child.attrs.day_of_week;
+        const mode = child.attrs.mode;
+        if (!dayOfWeek || !mode)
+            continue;
+        const entry = { dayOfWeek, mode };
+        const openTime = child.attrs.open_time;
+        const closeTime = child.attrs.close_time;
+        if (openTime)
+            entry.openTime = Number.parseInt(openTime, 10);
+        if (closeTime)
+            entry.closeTime = Number.parseInt(closeTime, 10);
+        config[count] = entry;
+        count += 1;
+    }
+    config.length = count;
+    return { timezone, config };
+}
+function parseProfileOptions(node) {
+    const children = (0, helpers_1.getNodeChildren)(node);
+    const options = {};
+    for (let i = 0; i < children.length; i += 1) {
+        const child = children[i];
+        const text = (0, helpers_1.getNodeTextContent)(child);
+        if (text !== undefined) {
+            options[child.tag] = text;
+        }
+    }
+    return options;
+}
+const VN_ISSUER_API = 'ent:wa';
+const VN_ISSUER_SMB = 'smb:wa';
+function parseCertificateContent(contentBytes) {
+    try {
+        const cert = _proto_1.proto.VerifiedNameCertificate.decode(contentBytes);
+        if (!cert.details)
+            return null;
+        const details = _proto_1.proto.VerifiedNameCertificate.Details.decode(cert.details);
+        return {
+            name: details.verifiedName ?? undefined,
+            serial: details.serial !== null && details.serial !== undefined
+                ? String((0, primitives_1.longToNumber)(details.serial))
+                : undefined,
+            isApi: details.issuer === VN_ISSUER_API,
+            isSmb: details.issuer === VN_ISSUER_SMB
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function parseVerifiedName(result) {
+    const vnNode = (0, helpers_1.findNodeChild)(result, 'verified_name');
+    if (!vnNode)
+        return null;
+    const level = vnNode.attrs.verified_level;
+    const attrSerial = vnNode.attrs.serial;
+    const contentBytes = vnNode.content instanceof Uint8Array ? vnNode.content : undefined;
+    const certData = contentBytes !== undefined ? parseCertificateContent(contentBytes) : null;
+    const entry = {
+        name: certData?.name,
+        level,
+        serial: attrSerial ?? certData?.serial,
+        isApi: certData?.isApi === true,
+        isSmb: certData?.isSmb === true
+    };
+    const actualActors = vnNode.attrs.actual_actors;
+    const hostStorage = vnNode.attrs.host_storage;
+    const privacyModeTs = vnNode.attrs.privacy_mode_ts;
+    if (actualActors !== undefined && hostStorage !== undefined && privacyModeTs !== undefined) {
+        entry.privacyMode = {
+            actualActors: Number.parseInt(actualActors, 10),
+            hostStorage: Number.parseInt(hostStorage, 10),
+            privacyModeTs: Number.parseInt(privacyModeTs, 10)
+        };
+    }
+    return entry;
+}
+function createBusinessCoordinator(options) {
+    const { queryWithContext } = options;
+    return {
+        getBusinessProfile: async (jids) => {
+            if (jids.length === 0)
+                return [];
+            const node = (0, business_1.buildGetBusinessProfileIq)(jids);
+            const result = await queryWithContext('business.getProfile', node, undefined, {
+                count: jids.length
+            });
+            (0, query_1.assertIqResult)(result, 'business.getProfile');
+            return parseBusinessProfiles(result);
+        },
+        editBusinessProfile: async (input) => {
+            const node = (0, business_1.buildEditBusinessProfileIq)(input);
+            const result = await queryWithContext('business.editProfile', node);
+            (0, query_1.assertIqResult)(result, 'business.editProfile');
+        },
+        getVerifiedName: async (jid) => {
+            const node = (0, business_1.buildGetVerifiedNameIq)(jid);
+            const result = await queryWithContext('business.getVerifiedName', node, undefined, {
+                jid
+            });
+            (0, query_1.assertIqResult)(result, 'business.getVerifiedName');
+            return parseVerifiedName(result);
+        },
+        updateCoverPhoto: async (id, timestamp, token) => {
+            const node = (0, business_1.buildUpdateCoverPhotoIq)(id, timestamp, token);
+            const result = await queryWithContext('business.updateCoverPhoto', node, undefined, {
+                id
+            });
+            (0, query_1.assertIqResult)(result, 'business.updateCoverPhoto');
+        },
+        deleteCoverPhoto: async (id) => {
+            const node = (0, business_1.buildDeleteCoverPhotoIq)(id);
+            const result = await queryWithContext('business.deleteCoverPhoto', node, undefined, {
+                id
+            });
+            (0, query_1.assertIqResult)(result, 'business.deleteCoverPhoto');
+        }
+    };
+}

package/dist/client/coordinators/WaEmailCoordinator.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEmailCoordinator = createEmailCoordinator;
+const email_1 = require("../../protocol/email");
+const email_2 = require("../../transport/node/builders/email");
+const helpers_1 = require("../../transport/node/helpers");
+const query_1 = require("../../transport/node/query");
+function createEmailCoordinator(options) {
+    const { queryWithContext } = options;
+    return {
+        getStatus: async () => {
+            const result = await queryWithContext('email.getStatus', (0, email_2.buildGetEmailIq)());
+            (0, query_1.assertIqResult)(result, 'email.getStatus');
+            return parseEmailStatus(result);
+        },
+        setEmail: async (email, context) => {
+            const result = await queryWithContext('email.set', (0, email_2.buildSetEmailIq)(email, context), undefined, context !== undefined ? { context } : {});
+            (0, query_1.assertIqResult)(result, 'email.set');
+            return parseEmailStatus(result);
+        },
+        requestVerificationCode: async (input) => {
+            const result = await queryWithContext('email.requestCode', (0, email_2.buildRequestEmailVerificationCodeIq)(input), undefined, { languageCode: input.languageCode, localeCode: input.localeCode });
+            (0, query_1.assertIqResult)(result, 'email.requestCode');
+        },
+        verifyCode: async (code) => {
+            const result = await queryWithContext('email.verifyCode', (0, email_2.buildVerifyEmailCodeIq)(code));
+            (0, query_1.assertIqResult)(result, 'email.verifyCode');
+            return parseVerifyCodeResult(result);
+        },
+        confirm: async (context) => {
+            const result = await queryWithContext('email.confirm', (0, email_2.buildConfirmEmailIq)(context), undefined, context !== undefined ? { context } : {});
+            (0, query_1.assertIqResult)(result, 'email.confirm');
+        }
+    };
+}
+function parseEmailStatus(result) {
+    const emailNode = (0, helpers_1.findNodeChild)(result, email_1.WA_EMAIL_TAGS.EMAIL);
+    if (!emailNode) {
+        return { email: null, verified: false, confirmed: false };
+    }
+    const verifiedAttr = emailNode.attrs.verified;
+    const addressNode = (0, helpers_1.findNodeChild)(emailNode, email_1.WA_EMAIL_TAGS.EMAIL_ADDRESS);
+    const confirmedNode = (0, helpers_1.findNodeChild)(emailNode, email_1.WA_EMAIL_TAGS.CONFIRMED);
+    return {
+        email: addressNode ? ((0, helpers_1.getNodeTextContent)(addressNode) ?? null) : null,
+        verified: verifiedAttr === 'true',
+        confirmed: confirmedNode ? (0, helpers_1.getNodeTextContent)(confirmedNode) === 'true' : false
+    };
+}
+function parseVerifyCodeResult(result) {
+    const emailNode = (0, helpers_1.findNodeChild)(result, email_1.WA_EMAIL_TAGS.EMAIL);
+    if (!emailNode) {
+        return { verified: false, autoVerifyFailed: false, email: null };
+    }
+    const doVerify = emailNode.attrs.do_verify;
+    const autoVerifyNode = (0, helpers_1.findNodeChild)(emailNode, email_1.WA_EMAIL_TAGS.AUTO_VERIFY);
+    const addressNode = (0, helpers_1.findNodeChild)(emailNode, email_1.WA_EMAIL_TAGS.EMAIL_ADDRESS);
+    return {
+        verified: doVerify === 'true',
+        autoVerifyFailed: autoVerifyNode ? (0, helpers_1.getNodeTextContent)(autoVerifyNode) === 'fail' : false,
+        email: addressNode ? ((0, helpers_1.getNodeTextContent)(addressNode) ?? null) : null
+    };
+}

package/dist/client/coordinators/WaGroupCoordinator.js

@@ -10,20 +10,24 @@ const helpers_1 = require("../../transport/node/helpers");
 const query_1 = require("../../transport/node/query");
 function parseGroupParticipants(node) {
     const parsed = (0, group_1.parseParticipants)(node);
-    const participants = [];
-    for (const participant of parsed) {
+    const participants = new Array(parsed.length);
+    let participantsCount = 0;
+    for (let index = 0; index < parsed.length; index += 1) {
+        const participant = parsed[index];
         if (!participant.jid) {
             continue;
         }
         const type = participant.role ?? group_2.WA_GROUP_PARTICIPANT_TYPES.REGULAR;
-        participants.push({
+        participants[participantsCount] = {
             jid: participant.jid,
             type,
             isAdmin: type === group_2.WA_GROUP_PARTICIPANT_TYPES.ADMIN ||
                 type === group_2.WA_GROUP_PARTICIPANT_TYPES.SUPERADMIN,
             isSuperAdmin: type === group_2.WA_GROUP_PARTICIPANT_TYPES.SUPERADMIN
-        });
+        };
+        participantsCount += 1;
     }
+    participants.length = participantsCount;
     return participants;
 }
 function parseGroupMetadata(node) {
@@ -104,9 +108,9 @@ function createGroupCoordinator(options) {
             const result = await queryWithContext('group.list', node);
             (0, query_1.assertIqResult)(result, 'group.list');
             const groupNodes = (0, helpers_1.getNodeChildrenByTagFromChildren)(result, nodes_1.WA_NODE_TAGS.GROUP);
-            const metadata = [];
-            for (const groupNode of groupNodes) {
-                metadata.push(parseGroupMetadata(groupNode));
+            const metadata = new Array(groupNodes.length);
+            for (let index = 0; index < groupNodes.length; index += 1) {
+                metadata[index] = parseGroupMetadata(groupNodes[index]);
             }
             return metadata;
         },

package/dist/client/coordinators/WaIncomingNodeCoordinator.js

@@ -6,7 +6,7 @@ const constants_1 = require("../../protocol/constants");
 const helpers_1 = require("../../transport/node/helpers");
 const parse_1 = require("../../transport/stream/parse");
 const primitives_1 = require("../../util/primitives");
-const INFO_BULLETIN_NOTIFICATION_TYPES = new Set([
+const INFO_BULLETIN_CHILD_TAGS = new Set([
     'offline',
     'offline_preview',
     'priority_offline_complete',
@@ -18,6 +18,7 @@ class WaIncomingNodeCoordinator {
     constructor(options) {
         this.logger = options.logger;
         this.runtime = options.runtime;
+        this.offlineResume = options.offlineResume;
         this.nodeHandlerRegistry = new Map();
         this.registerDefaultIncomingHandlers();
         this.mediaConnWarmupPromise = null;
@@ -28,6 +29,9 @@ class WaIncomingNodeCoordinator {
             id: node.attrs.id,
             type: node.attrs.type
         });
+        if (node.attrs.offline !== undefined) {
+            this.offlineResume.trackOfflineStanza();
+        }
         const streamControlResult = (0, parse_1.parseStreamControlNode)(node);
         if (streamControlResult) {
             await this.runtime.handleStreamControlResult(streamControlResult);
@@ -147,6 +151,16 @@ class WaIncomingNodeCoordinator {
                 emitUnhandledStanza: runtime.emitUnhandledIncomingNode
             })
         });
+        this.registerIncomingHandler({
+            tag: constants_1.WA_NODE_TAGS.NOTIFICATION,
+            subtype: constants_1.WA_NOTIFICATION_TYPES.REGISTRATION,
+            handler: (0, incoming_1.createIncomingRegistrationNotificationHandler)({
+                logger: this.logger,
+                sendNode: runtime.sendNode,
+                emitRegistrationCode: runtime.emitRegistrationCode,
+                emitAccountTakeoverNotice: runtime.emitAccountTakeoverNotice
+            })
+        });
         this.registerIncomingHandler({
             tag: constants_1.WA_NODE_TAGS.NOTIFICATION,
             handler: (0, incoming_1.createIncomingNotificationHandler)({
@@ -200,6 +214,7 @@ class WaIncomingNodeCoordinator {
             handler: (0, incoming_1.createIncomingFailureHandler)({
                 logger: this.logger,
                 emitIncomingFailure: runtime.emitIncomingFailure,
+                stopComms: runtime.stopComms,
                 disconnect: runtime.disconnect,
                 clearStoredCredentials: runtime.clearStoredCredentials
             })
@@ -265,13 +280,24 @@ class WaIncomingNodeCoordinator {
             return false;
         }
         let handled = false;
-        const ibType = node.attrs.type;
-        if (ibType && INFO_BULLETIN_NOTIFICATION_TYPES.has(ibType)) {
-            this.runtime.emitIncomingNotification((0, incoming_1.createInfoBulletinNotificationEvent)(node, ibType, {
-                count: (0, primitives_1.parseOptionalInt)(node.attrs.count),
-                t: (0, primitives_1.parseOptionalInt)(node.attrs.t)
-            }));
-            handled = true;
+        const children = (0, helpers_1.getNodeChildren)(node);
+        for (const child of children) {
+            if (INFO_BULLETIN_CHILD_TAGS.has(child.tag)) {
+                this.runtime.emitIncomingNotification((0, incoming_1.createInfoBulletinNotificationEvent)(node, child.tag, {
+                    count: (0, primitives_1.parseOptionalInt)(child.attrs.count),
+                    message: (0, primitives_1.parseOptionalInt)(child.attrs.message),
+                    receipt: (0, primitives_1.parseOptionalInt)(child.attrs.receipt),
+                    notification: (0, primitives_1.parseOptionalInt)(child.attrs.notification),
+                    t: (0, primitives_1.parseOptionalInt)(child.attrs.t)
+                }));
+                if (child.tag === 'offline_preview') {
+                    this.offlineResume.handleOfflinePreview((0, primitives_1.parseOptionalInt)(child.attrs.count) ?? 0);
+                }
+                if (child.tag === 'offline') {
+                    this.offlineResume.handleOfflineComplete((0, primitives_1.parseOptionalInt)(child.attrs.count) ?? 0);
+                }
+                handled = true;
+            }
         }
         const edgeRoutingNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.EDGE_ROUTING);
         if (edgeRoutingNode) {