zapo-js 0.1.2 → 0.3.0

package/dist/esm/client/connection/WaConnectionManager.js

@@ -2,6 +2,7 @@ import { WaComms } from '../../transport/WaComms.js';
 import { toError } from '../../util/primitives.js';
 export class WaConnectionManager {
     constructor(options) {
+        this.lastConnectWasNewLogin = false;
         this.logger = options.logger;
         this.options = options.options;
         this.authClient = options.authClient;
@@ -30,11 +31,12 @@ export 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() {
@@ -64,6 +66,9 @@ export class WaConnectionManager {
     isConnected() {
         return !!(this.comms && this.comms.getCommsState().connected);
     }
+    wasNewLogin() {
+        return this.lastConnectWasNewLogin;
+    }
     getComms() {
         return this.comms;
     }
@@ -93,6 +98,7 @@ export 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);
@@ -127,11 +133,12 @@ export 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() {
@@ -176,12 +183,14 @@ export 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');
         }
@@ -191,7 +200,10 @@ export 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(commsConfig, this.logger);
         this.pendingComms = comms;
         this.mediaConnCache = null;

package/dist/esm/client/coordinators/WaAbPropsCoordinator.js

@@ -0,0 +1,137 @@
+import { parseAbPropsIqResult } from '../events/abprops.js';
+import { AB_PROP_CONFIGS, resolveAbPropNameByCode, WA_ABPROPS_REFRESH_BOUNDS } from '../../protocol/abprops.js';
+import { WA_DEFAULTS } from '../../protocol/constants.js';
+import { buildGetAbPropsIq } from '../../transport/node/builders/abprops.js';
+import { toError } from '../../util/primitives.js';
+export 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 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: 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: toError(error).message
+                });
+            }
+        }
+    }
+    async executeSync(epoch) {
+        const iqNode = buildGetAbPropsIq({
+            hash: this.syncState.hash,
+            refreshId: this.syncState.refreshId
+        });
+        const response = await this.runtime.queryWithContext('abprops.sync', iqNode, WA_DEFAULTS.IQ_TIMEOUT_MS);
+        if (this.syncEpoch !== epoch) {
+            return;
+        }
+        const result = 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 = resolveAbPropNameByCode(entry.configCode);
+            if (!name) {
+                continue;
+            }
+            const config = 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
+        });
+    }
+}
+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(WA_ABPROPS_REFRESH_BOUNDS.MIN_S, Math.min(WA_ABPROPS_REFRESH_BOUNDS.MAX_S, seconds));
+}

package/dist/esm/client/coordinators/WaBusinessCoordinator.js

@@ -0,0 +1,229 @@
+import { proto } from '../../proto.js';
+import { buildDeleteCoverPhotoIq, buildEditBusinessProfileIq, buildGetBusinessProfileIq, buildGetVerifiedNameIq, buildUpdateCoverPhotoIq } from '../../transport/node/builders/business.js';
+import { findNodeChild, getNodeChildren, getNodeTextContent } from '../../transport/node/helpers.js';
+import { assertIqResult } from '../../transport/node/query.js';
+import { longToNumber } from '../../util/primitives.js';
+function parseBusinessProfiles(result) {
+    const bizNode = findNodeChild(result, 'business_profile');
+    if (!bizNode) {
+        return [];
+    }
+    const profileNodes = 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 = 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 = 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: getNodeTextContent(child) ?? '' };
+        count += 1;
+    }
+    categories.length = count;
+    return categories;
+}
+function parseBusinessHoursNode(node) {
+    const timezone = node.attrs.timezone;
+    const children = 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 = getNodeChildren(node);
+    const options = {};
+    for (let i = 0; i < children.length; i += 1) {
+        const child = children[i];
+        const text = 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.VerifiedNameCertificate.decode(contentBytes);
+        if (!cert.details)
+            return null;
+        const details = proto.VerifiedNameCertificate.Details.decode(cert.details);
+        return {
+            name: details.verifiedName ?? undefined,
+            serial: details.serial !== null && details.serial !== undefined
+                ? String(longToNumber(details.serial))
+                : undefined,
+            isApi: details.issuer === VN_ISSUER_API,
+            isSmb: details.issuer === VN_ISSUER_SMB
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function parseVerifiedName(result) {
+    const vnNode = 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;
+}
+export function createBusinessCoordinator(options) {
+    const { queryWithContext } = options;
+    return {
+        getBusinessProfile: async (jids) => {
+            if (jids.length === 0)
+                return [];
+            const node = buildGetBusinessProfileIq(jids);
+            const result = await queryWithContext('business.getProfile', node, undefined, {
+                count: jids.length
+            });
+            assertIqResult(result, 'business.getProfile');
+            return parseBusinessProfiles(result);
+        },
+        editBusinessProfile: async (input) => {
+            const node = buildEditBusinessProfileIq(input);
+            const result = await queryWithContext('business.editProfile', node);
+            assertIqResult(result, 'business.editProfile');
+        },
+        getVerifiedName: async (jid) => {
+            const node = buildGetVerifiedNameIq(jid);
+            const result = await queryWithContext('business.getVerifiedName', node, undefined, {
+                jid
+            });
+            assertIqResult(result, 'business.getVerifiedName');
+            return parseVerifiedName(result);
+        },
+        updateCoverPhoto: async (id, timestamp, token) => {
+            const node = buildUpdateCoverPhotoIq(id, timestamp, token);
+            const result = await queryWithContext('business.updateCoverPhoto', node, undefined, {
+                id
+            });
+            assertIqResult(result, 'business.updateCoverPhoto');
+        },
+        deleteCoverPhoto: async (id) => {
+            const node = buildDeleteCoverPhotoIq(id);
+            const result = await queryWithContext('business.deleteCoverPhoto', node, undefined, {
+                id
+            });
+            assertIqResult(result, 'business.deleteCoverPhoto');
+        }
+    };
+}

package/dist/esm/client/coordinators/WaEmailCoordinator.js

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

package/dist/esm/client/coordinators/WaGroupCoordinator.js

@@ -7,20 +7,24 @@ import { findNodeChild, getNodeChildrenByTagFromChildren, hasNodeChild } from '.
 import { assertIqResult, buildIqNode } from '../../transport/node/query.js';
 function parseGroupParticipants(node) {
     const parsed = parseGroupEventParticipants(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 ?? WA_GROUP_PARTICIPANT_TYPES.REGULAR;
-        participants.push({
+        participants[participantsCount] = {
             jid: participant.jid,
             type,
             isAdmin: type === WA_GROUP_PARTICIPANT_TYPES.ADMIN ||
                 type === WA_GROUP_PARTICIPANT_TYPES.SUPERADMIN,
             isSuperAdmin: type === WA_GROUP_PARTICIPANT_TYPES.SUPERADMIN
-        });
+        };
+        participantsCount += 1;
     }
+    participants.length = participantsCount;
     return participants;
 }
 function parseGroupMetadata(node) {
@@ -101,9 +105,9 @@ export function createGroupCoordinator(options) {
             const result = await queryWithContext('group.list', node);
             assertIqResult(result, 'group.list');
             const groupNodes = getNodeChildrenByTagFromChildren(result, 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/esm/client/coordinators/WaIncomingNodeCoordinator.js

@@ -1,9 +1,9 @@
-import { createIncomingBaseEvent, createIncomingFailureHandler, createIncomingGroupNotificationHandler, createIncomingNotificationHandler, createIncomingReceiptHandler, createInfoBulletinNotificationEvent, createUnhandledIncomingNodeEvent } from '../incoming.js';
+import { createIncomingBaseEvent, createIncomingFailureHandler, createIncomingGroupNotificationHandler, createIncomingNotificationHandler, createIncomingReceiptHandler, createIncomingRegistrationNotificationHandler, createInfoBulletinNotificationEvent, createUnhandledIncomingNodeEvent } from '../incoming.js';
 import { WA_IQ_TYPES, WA_MESSAGE_TAGS, WA_NODE_TAGS, WA_NOTIFICATION_TYPES, WA_SIGNALING } from '../../protocol/constants.js';
-import { decodeNodeContentBase64OrBytes, findNodeChild, getNodeChildrenByTag } from '../../transport/node/helpers.js';
+import { decodeNodeContentBase64OrBytes, findNodeChild, getNodeChildren, getNodeChildrenByTag } from '../../transport/node/helpers.js';
 import { parseStreamControlNode, parseSuccessPersistAttributes } from '../../transport/stream/parse.js';
 import { parseOptionalInt, toError } from '../../util/primitives.js';
-const INFO_BULLETIN_NOTIFICATION_TYPES = new Set([
+const INFO_BULLETIN_CHILD_TAGS = new Set([
     'offline',
     'offline_preview',
     'priority_offline_complete',
@@ -15,6 +15,7 @@ export 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;
@@ -25,6 +26,9 @@ export class WaIncomingNodeCoordinator {
             id: node.attrs.id,
             type: node.attrs.type
         });
+        if (node.attrs.offline !== undefined) {
+            this.offlineResume.trackOfflineStanza();
+        }
         const streamControlResult = parseStreamControlNode(node);
         if (streamControlResult) {
             await this.runtime.handleStreamControlResult(streamControlResult);
@@ -144,6 +148,16 @@ export class WaIncomingNodeCoordinator {
                 emitUnhandledStanza: runtime.emitUnhandledIncomingNode
             })
         });
+        this.registerIncomingHandler({
+            tag: WA_NODE_TAGS.NOTIFICATION,
+            subtype: WA_NOTIFICATION_TYPES.REGISTRATION,
+            handler: createIncomingRegistrationNotificationHandler({
+                logger: this.logger,
+                sendNode: runtime.sendNode,
+                emitRegistrationCode: runtime.emitRegistrationCode,
+                emitAccountTakeoverNotice: runtime.emitAccountTakeoverNotice
+            })
+        });
         this.registerIncomingHandler({
             tag: WA_NODE_TAGS.NOTIFICATION,
             handler: createIncomingNotificationHandler({
@@ -197,6 +211,7 @@ export class WaIncomingNodeCoordinator {
             handler: createIncomingFailureHandler({
                 logger: this.logger,
                 emitIncomingFailure: runtime.emitIncomingFailure,
+                stopComms: runtime.stopComms,
                 disconnect: runtime.disconnect,
                 clearStoredCredentials: runtime.clearStoredCredentials
             })
@@ -262,13 +277,24 @@ export class WaIncomingNodeCoordinator {
             return false;
         }
         let handled = false;
-        const ibType = node.attrs.type;
-        if (ibType && INFO_BULLETIN_NOTIFICATION_TYPES.has(ibType)) {
-            this.runtime.emitIncomingNotification(createInfoBulletinNotificationEvent(node, ibType, {
-                count: parseOptionalInt(node.attrs.count),
-                t: parseOptionalInt(node.attrs.t)
-            }));
-            handled = true;
+        const children = getNodeChildren(node);
+        for (const child of children) {
+            if (INFO_BULLETIN_CHILD_TAGS.has(child.tag)) {
+                this.runtime.emitIncomingNotification(createInfoBulletinNotificationEvent(node, child.tag, {
+                    count: parseOptionalInt(child.attrs.count),
+                    message: parseOptionalInt(child.attrs.message),
+                    receipt: parseOptionalInt(child.attrs.receipt),
+                    notification: parseOptionalInt(child.attrs.notification),
+                    t: parseOptionalInt(child.attrs.t)
+                }));
+                if (child.tag === 'offline_preview') {
+                    this.offlineResume.handleOfflinePreview(parseOptionalInt(child.attrs.count) ?? 0);
+                }
+                if (child.tag === 'offline') {
+                    this.offlineResume.handleOfflineComplete(parseOptionalInt(child.attrs.count) ?? 0);
+                }
+                handled = true;
+            }
         }
         const edgeRoutingNode = findNodeChild(node, WA_NODE_TAGS.EDGE_ROUTING);
         if (edgeRoutingNode) {