zapo-js 0.2.0 → 1.0.0

package/dist/esm/client/events/business.js

@@ -0,0 +1,370 @@
+import { createUnhandledIncomingNodeEvent } from '../events/incoming.js';
+import { proto } from '../../proto.js';
+import { WA_BUSINESS_NOTIFICATION_TAGS, WA_NOTIFICATION_TYPES } from '../../protocol/constants.js';
+import { WA_NODE_TAGS } from '../../protocol/nodes.js';
+import { findNodeChild, getNodeChildren, getNodeChildrenByTag, getNodeTextContent } from '../../transport/node/helpers.js';
+import { parseOptionalInt } from '../../util/primitives.js';
+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
+                ? details.serial.toString()
+                : undefined,
+            isApi: details.issuer === VN_ISSUER_API,
+            isSmb: details.issuer === VN_ISSUER_SMB
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function parseVerifiedNameNode(node) {
+    if (node.tag !== WA_BUSINESS_NOTIFICATION_TAGS.VERIFIED_NAME)
+        return null;
+    const level = node.attrs.verified_level;
+    const attrSerial = node.attrs.serial;
+    const contentBytes = node.content instanceof Uint8Array ? node.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 = node.attrs.actual_actors;
+    const hostStorage = node.attrs.host_storage;
+    const privacyModeTs = node.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 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;
+}
+export function parseBusinessProfileNode(node) {
+    if (node.tag !== WA_BUSINESS_NOTIFICATION_TAGS.PROFILE)
+        return null;
+    const jid = node.attrs.jid;
+    if (!jid)
+        return null;
+    const entry = { jid };
+    const tag = node.attrs.tag;
+    if (tag)
+        entry.tag = tag;
+    const children = node.content;
+    if (!Array.isArray(children)) {
+        return entry;
+    }
+    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;
+    return entry;
+}
+function parseSubscriptionsList(node) {
+    const subs = [];
+    for (const sub of getNodeChildrenByTag(node, 'subscription')) {
+        const id = sub.attrs.id;
+        const status = sub.attrs.status;
+        if (!id || !status)
+            continue;
+        subs.push({
+            id,
+            status,
+            tier: parseOptionalInt(sub.attrs.subscription_tier),
+            source: sub.attrs.source,
+            startTime: parseOptionalInt(sub.attrs.subscription_start_time),
+            creationTime: parseOptionalInt(sub.attrs.subscription_creation_time),
+            expirationDate: parseOptionalInt(sub.attrs.subscription_end_time)
+        });
+    }
+    return subs;
+}
+function parseFeatureFlagsList(node) {
+    const flags = [];
+    for (const flag of getNodeChildrenByTag(node, 'feature_flag')) {
+        const name = flag.attrs.name;
+        if (!name)
+            continue;
+        const enabled = (flag.attrs.enabled ?? '').toLowerCase() === 'true';
+        flags.push({
+            name,
+            enabled,
+            expirationTime: parseOptionalInt(flag.attrs.expiration_time),
+            limit: parseOptionalInt(flag.attrs.limit)
+        });
+    }
+    return flags;
+}
+function parseProductIds(catalogNode) {
+    const ids = [];
+    for (const product of getNodeChildrenByTag(catalogNode, 'product')) {
+        const idNode = findNodeChild(product, WA_NODE_TAGS.ID);
+        if (!idNode)
+            continue;
+        const text = getNodeTextContent(idNode);
+        if (text)
+            ids.push(text);
+    }
+    return ids;
+}
+function parseCollectionUpdates(catalogNode) {
+    const collections = [];
+    for (const collection of getNodeChildrenByTag(catalogNode, 'collection')) {
+        const id = collection.attrs.id;
+        if (!id)
+            continue;
+        const entry = { id };
+        const statusInfo = findNodeChild(collection, 'status_info');
+        if (statusInfo) {
+            const statusNode = findNodeChild(statusInfo, WA_NODE_TAGS.STATUS);
+            if (statusNode) {
+                const text = getNodeTextContent(statusNode);
+                if (text)
+                    entry.reviewStatus = text;
+            }
+            const rejectNode = findNodeChild(statusInfo, 'reject_reason');
+            if (rejectNode) {
+                const text = getNodeTextContent(rejectNode);
+                if (text)
+                    entry.rejectReason = text;
+            }
+            const commerceNode = findNodeChild(statusInfo, 'commerce_url');
+            if (commerceNode) {
+                const text = getNodeTextContent(commerceNode);
+                if (text)
+                    entry.commerceUrl = text;
+            }
+        }
+        collections.push(entry);
+    }
+    return collections;
+}
+function createBaseBusinessEvent(notificationNode) {
+    return {
+        rawNode: notificationNode,
+        stanzaId: notificationNode.attrs.id,
+        chatJid: notificationNode.attrs.from,
+        stanzaType: notificationNode.attrs.type,
+        offline: notificationNode.attrs.offline !== undefined,
+        timestampSeconds: parseOptionalInt(notificationNode.attrs.t)
+    };
+}
+function parseSingleBusinessEvent(notificationNode) {
+    const base = createBaseBusinessEvent(notificationNode);
+    const verifiedName = findNodeChild(notificationNode, WA_BUSINESS_NOTIFICATION_TAGS.VERIFIED_NAME);
+    if (verifiedName) {
+        const vnJid = verifiedName.attrs.jid;
+        if (vnJid) {
+            const parsed = parseVerifiedNameNode(verifiedName);
+            if (!parsed)
+                return null;
+            return {
+                ...base,
+                action: 'verified_name_update',
+                bizJid: vnJid,
+                verifiedName: parsed
+            };
+        }
+        const vnHash = verifiedName.attrs.hash;
+        if (vnHash) {
+            return {
+                ...base,
+                action: 'verified_name_stale',
+                bizHash: vnHash
+            };
+        }
+        return null;
+    }
+    const remove = findNodeChild(notificationNode, WA_BUSINESS_NOTIFICATION_TAGS.REMOVE);
+    if (remove) {
+        const rmJid = remove.attrs.jid;
+        if (rmJid) {
+            return { ...base, action: 'business_removed', bizJid: rmJid };
+        }
+        const rmHash = remove.attrs.hash;
+        if (rmHash) {
+            return { ...base, action: 'business_removed', bizHash: rmHash };
+        }
+        return null;
+    }
+    const profile = findNodeChild(notificationNode, WA_BUSINESS_NOTIFICATION_TAGS.PROFILE);
+    if (profile) {
+        const hash = profile.attrs.hash;
+        if (hash) {
+            return { ...base, action: 'profile_update', bizHash: hash };
+        }
+        const fromJid = notificationNode.attrs.from;
+        return { ...base, action: 'profile_update', bizJid: fromJid };
+    }
+    const catalog = findNodeChild(notificationNode, WA_BUSINESS_NOTIFICATION_TAGS.PRODUCT_CATALOG);
+    if (catalog) {
+        const fromJid = notificationNode.attrs.from;
+        if (findNodeChild(catalog, 'product')) {
+            return {
+                ...base,
+                action: 'product_update',
+                bizJid: fromJid,
+                productIds: parseProductIds(catalog)
+            };
+        }
+        if (findNodeChild(catalog, 'collection')) {
+            return {
+                ...base,
+                action: 'collection_update',
+                bizJid: fromJid,
+                collections: parseCollectionUpdates(catalog)
+            };
+        }
+        return null;
+    }
+    const subscriptions = findNodeChild(notificationNode, WA_BUSINESS_NOTIFICATION_TAGS.SUBSCRIPTIONS);
+    const featureFlags = findNodeChild(notificationNode, WA_BUSINESS_NOTIFICATION_TAGS.FEATURE_FLAGS);
+    if (subscriptions || featureFlags) {
+        return {
+            ...base,
+            action: 'subscriptions_update',
+            bizJid: notificationNode.attrs.from,
+            subscriptions: subscriptions ? parseSubscriptionsList(subscriptions) : [],
+            featureFlags: featureFlags ? parseFeatureFlagsList(featureFlags) : []
+        };
+    }
+    return null;
+}
+export function parseBusinessNotificationEvents(notificationNode) {
+    if (notificationNode.tag !== WA_NODE_TAGS.NOTIFICATION ||
+        notificationNode.attrs.type !== WA_NOTIFICATION_TYPES.BUSINESS) {
+        return { events: [], unhandled: [] };
+    }
+    try {
+        const event = parseSingleBusinessEvent(notificationNode);
+        if (event) {
+            return { events: [event], unhandled: [] };
+        }
+        const firstChild = getNodeChildren(notificationNode)[0];
+        const childTag = firstChild?.tag ?? 'empty';
+        return {
+            events: [],
+            unhandled: [
+                createUnhandledIncomingNodeEvent(notificationNode, `notification.${WA_NOTIFICATION_TYPES.BUSINESS}.${childTag}.not_supported`)
+            ]
+        };
+    }
+    catch {
+        return {
+            events: [],
+            unhandled: [
+                createUnhandledIncomingNodeEvent(notificationNode, `notification.${WA_NOTIFICATION_TYPES.BUSINESS}.parse_failed`)
+            ]
+        };
+    }
+}

package/dist/esm/client/events/call.js

@@ -0,0 +1,55 @@
+import { WA_CALL_CHILD_TAGS, WA_CALL_NODE_ATTRS, WA_CALL_PAYLOAD_TAGS } from '../../protocol/call.js';
+import { findNodeChild, getFirstNodeChild, getNodeChildren, hasNodeChild } from '../../transport/node/helpers.js';
+import { parseOptionalInt } from '../../util/primitives.js';
+const KNOWN_CALL_PAYLOAD_TAGS = new Set(Object.values(WA_CALL_PAYLOAD_TAGS));
+function parseGroupInfo(node) {
+    const children = getNodeChildren(node);
+    if (children.length === 0) {
+        return undefined;
+    }
+    const out = [];
+    for (let i = 0; i < children.length; i += 1) {
+        const child = children[i];
+        const jid = child.attrs.jid;
+        if (!jid)
+            continue;
+        out.push({
+            jid,
+            userPnJid: child.attrs[WA_CALL_NODE_ATTRS.USER_PN],
+            username: child.attrs[WA_CALL_NODE_ATTRS.USERNAME],
+            guestName: child.attrs[WA_CALL_NODE_ATTRS.GUEST_NAME]
+        });
+    }
+    return out.length > 0 ? out : undefined;
+}
+export function parseCallNode(node) {
+    const payload = getFirstNodeChild(node);
+    if (!payload) {
+        return { type: 'unknown', isVideo: false };
+    }
+    const payloadTag = payload.tag;
+    const type = KNOWN_CALL_PAYLOAD_TAGS.has(payloadTag)
+        ? payloadTag
+        : 'unknown';
+    const groupInfoNode = findNodeChild(payload, WA_CALL_CHILD_TAGS.GROUP_INFO);
+    const silenceNode = findNodeChild(payload, WA_CALL_CHILD_TAGS.SILENCE);
+    return {
+        type,
+        payloadTag,
+        callId: payload.attrs[WA_CALL_NODE_ATTRS.CALL_ID],
+        callCreatorJid: payload.attrs[WA_CALL_NODE_ATTRS.CALL_CREATOR],
+        senderLidJid: node.attrs[WA_CALL_NODE_ATTRS.SENDER_LID],
+        callerPnJid: payload.attrs[WA_CALL_NODE_ATTRS.CALLER_PN],
+        groupJid: payload.attrs[WA_CALL_NODE_ATTRS.GROUP_JID],
+        isVideo: hasNodeChild(payload, WA_CALL_CHILD_TAGS.VIDEO),
+        callerUsername: payload.attrs[WA_CALL_NODE_ATTRS.USERNAME],
+        callerCountryCode: payload.attrs[WA_CALL_NODE_ATTRS.CALLER_COUNTRY_CODE],
+        callerPushName: payload.attrs[WA_CALL_NODE_ATTRS.NOTIFY],
+        peerPlatform: node.attrs[WA_CALL_NODE_ATTRS.PLATFORM],
+        peerAppVersion: node.attrs[WA_CALL_NODE_ATTRS.VERSION],
+        timestampSeconds: parseOptionalInt(node.attrs.t),
+        endTimestampSeconds: parseOptionalInt(node.attrs.e),
+        silenceReason: silenceNode?.attrs[WA_CALL_NODE_ATTRS.REASON],
+        groupInfo: groupInfoNode ? parseGroupInfo(groupInfoNode) : undefined
+    };
+}

package/dist/esm/client/events/chatstate.js

@@ -0,0 +1,20 @@
+import { WA_NODE_TAGS } from '../../protocol/nodes.js';
+import { WA_CHATSTATE_MEDIA } from '../../protocol/presence.js';
+import { getFirstNodeChild } from '../../transport/node/helpers.js';
+export function parseChatstateNode(node) {
+    const child = getFirstNodeChild(node);
+    if (!child) {
+        return null;
+    }
+    if (child.tag !== WA_NODE_TAGS.COMPOSING && child.tag !== WA_NODE_TAGS.PAUSED) {
+        return null;
+    }
+    const result = { state: child.tag };
+    if (child.tag === WA_NODE_TAGS.COMPOSING && child.attrs.media === WA_CHATSTATE_MEDIA.AUDIO) {
+        result.media = WA_CHATSTATE_MEDIA.AUDIO;
+    }
+    if (node.attrs.participant !== undefined) {
+        result.participantJid = node.attrs.participant;
+    }
+    return result;
+}

package/dist/esm/client/events/devices.js

@@ -1,5 +1,7 @@
 import { parseSignalAddressFromJid } from '../../protocol/jid.js';
+import { WA_NODE_TAGS } from '../../protocol/nodes.js';
 import { findNodeChild, getNodeChildrenByTag } from '../../transport/node/helpers.js';
+import { parseOptionalInt } from '../../util/primitives.js';
 export const DEVICE_NOTIFICATION_ACTIONS = Object.freeze({
     ADD: 'add',
     REMOVE: 'remove',
@@ -13,24 +15,27 @@ export function parseDeviceNotification(node) {
     }
     let action;
     let actionNode;
-    if (findNodeChild(node, DEVICE_NOTIFICATION_ACTIONS.REMOVE)) {
+    const removeNode = findNodeChild(node, DEVICE_NOTIFICATION_ACTIONS.REMOVE);
+    const addNode = removeNode ? undefined : findNodeChild(node, DEVICE_NOTIFICATION_ACTIONS.ADD);
+    const updateNode = removeNode || addNode ? undefined : findNodeChild(node, DEVICE_NOTIFICATION_ACTIONS.UPDATE);
+    if (removeNode) {
         action = DEVICE_NOTIFICATION_ACTIONS.REMOVE;
-        actionNode = findNodeChild(node, DEVICE_NOTIFICATION_ACTIONS.REMOVE);
+        actionNode = removeNode;
     }
-    else if (findNodeChild(node, DEVICE_NOTIFICATION_ACTIONS.ADD)) {
+    else if (addNode) {
         action = DEVICE_NOTIFICATION_ACTIONS.ADD;
-        actionNode = findNodeChild(node, DEVICE_NOTIFICATION_ACTIONS.ADD);
+        actionNode = addNode;
     }
-    else if (findNodeChild(node, DEVICE_NOTIFICATION_ACTIONS.UPDATE)) {
+    else if (updateNode) {
         action = DEVICE_NOTIFICATION_ACTIONS.UPDATE;
-        actionNode = findNodeChild(node, DEVICE_NOTIFICATION_ACTIONS.UPDATE);
+        actionNode = updateNode;
     }
     else {
         return null;
     }
     const devices = [];
     if (action !== DEVICE_NOTIFICATION_ACTIONS.UPDATE && actionNode) {
-        const deviceNodes = getNodeChildrenByTag(actionNode, 'device');
+        const deviceNodes = getNodeChildrenByTag(actionNode, WA_NODE_TAGS.DEVICE);
         for (let index = 0; index < deviceNodes.length; index += 1) {
             const deviceNode = deviceNodes[index];
             const jidAttr = deviceNode.attrs.jid;
@@ -44,13 +49,7 @@ export function parseDeviceNotification(node) {
             catch {
                 continue;
             }
-            const keyIndexAttr = deviceNode.attrs['key-index'];
-            const parsedKeyIndex = keyIndexAttr === undefined ? null : Number.parseInt(keyIndexAttr, 10);
-            const keyIndex = parsedKeyIndex !== null &&
-                Number.isSafeInteger(parsedKeyIndex) &&
-                parsedKeyIndex >= 0
-                ? parsedKeyIndex
-                : null;
+            const keyIndex = parseOptionalInt(deviceNode.attrs['key-index']) ?? null;
             devices[devices.length] = {
                 deviceId,
                 keyIndex
@@ -61,8 +60,8 @@ export function parseDeviceNotification(node) {
         action,
         stanzaId,
         fromJid,
-        lid: node.attrs.lid,
-        hash: action === DEVICE_NOTIFICATION_ACTIONS.UPDATE ? actionNode?.attrs.hash : undefined,
+        lid: node.attrs.lid ?? null,
+        hash: action === DEVICE_NOTIFICATION_ACTIONS.UPDATE ? (actionNode?.attrs.hash ?? null) : null,
         devices
     };
 }

package/dist/esm/client/{dirty.js → events/dirty.js}

@@ -1,15 +1,18 @@
-import { WA_ACCOUNT_SYNC_PROTOCOLS, WA_DEFAULTS, WA_DIRTY_PROTOCOLS, WA_DIRTY_TYPES, WA_IQ_TYPES, WA_SUPPORTED_DIRTY_TYPES } from '../protocol/constants.js';
-import { toUserJid } from '../protocol/jid.js';
-import { buildAccountBlocklistSyncIq, buildAccountDevicesSyncIq, buildAccountPictureSyncIq, buildAccountPrivacySyncIq, buildClearDirtyBitsIq, buildGroupsDirtySyncIq, buildNewsletterMetadataSyncIq } from '../transport/node/builders/account-sync.js';
-import { getNodeChildrenTags } from '../transport/node/helpers.js';
-import { assertIqResult, parseIqError } from '../transport/node/query.js';
-import { toError } from '../util/primitives.js';
+import { WA_ACCOUNT_SYNC_PROTOCOLS, WA_DEFAULTS, WA_DIRTY_PROTOCOLS, WA_DIRTY_TYPES, WA_IQ_TYPES, WA_NODE_TAGS, WA_SUPPORTED_DIRTY_TYPES } from '../../protocol/constants.js';
+import { toUserJid } from '../../protocol/jid.js';
+import { buildAccountBlocklistSyncIq, buildAccountDevicesSyncIq, buildAccountPictureSyncIq, buildClearDirtyBitsIq, buildListParticipatingGroupsIq, buildNewsletterMetadataSyncIq } from '../../transport/node/builders/account-sync.js';
+import { buildGetPrivacySettingsIq } from '../../transport/node/builders/privacy.js';
+import { parseUsyncResultEnvelope } from '../../transport/node/builders/usync.js';
+import { getNodeChildrenTags } from '../../transport/node/helpers.js';
+import { assertIqResult, parseIqError } from '../../transport/node/query.js';
+import { logUsyncProtocolErrors } from '../../transport/node/usync.js';
+import { parseOptionalInt, toError } from '../../util/primitives.js';
 const SUPPORTED_DIRTY_TYPES = new Set(WA_SUPPORTED_DIRTY_TYPES);
 const ACCOUNT_SYNC_PROTOCOL_SET = new Set(WA_ACCOUNT_SYNC_PROTOCOLS);
 function parseDirtyBitNode(node, logger) {
     const type = node.attrs.type;
-    const timestamp = Number.parseInt(node.attrs.timestamp ?? '', 10);
-    if (!type || !Number.isFinite(timestamp)) {
+    const timestamp = parseOptionalInt(node.attrs.timestamp);
+    if (!type || timestamp === undefined) {
         logger.warn('received invalid dirty bit node', {
             type,
             timestamp: node.attrs.timestamp
@@ -115,7 +118,7 @@ async function handleDirtyBit(runtime, dirtyBit) {
 }
 async function handleAccountSyncDirtyBit(runtime, protocols) {
     const selectedProtocols = resolveAccountSyncProtocols(protocols);
-    runtime.logger.info('received account_sync dirty bit', {
+    runtime.logger.debug('received account_sync dirty bit', {
         protocols: selectedProtocols.join(',')
     });
     const failures = [];
@@ -155,7 +158,7 @@ async function runAccountSyncProtocol(runtime, protocol) {
             await syncAccountBlocklistDirtyBit(runtime);
             return;
         case WA_DIRTY_PROTOCOLS.NOTICE:
-            runtime.logger.info('account_sync notice protocol received (no GraphQL/MEX job configured)');
+            runtime.logger.debug('account_sync notice protocol received (no GraphQL/MEX job configured)');
             return;
         default:
             runtime.logger.debug('unsupported account_sync protocol', {
@@ -164,19 +167,19 @@ async function runAccountSyncProtocol(runtime, protocol) {
     }
 }
 async function handleSyncdAppStateDirtyBit(runtime) {
-    runtime.logger.info('received syncd_app_state dirty bit, starting sync');
+    runtime.logger.debug('received syncd_app_state dirty bit, starting sync');
     await runtime.syncAppState();
 }
 async function syncAccountDevicesDirtyBit(runtime) {
     const credentials = runtime.getCurrentCredentials();
     const meJid = credentials?.meJid ?? null;
     if (!meJid) {
-        runtime.logger.warn('account_sync devices skipped: meJid is missing');
+        runtime.logger.trace('account_sync devices skipped: meJid is missing');
         return;
     }
     const userJids = resolveAccountSyncDeviceTargets(credentials);
     if (userJids.length === 0) {
-        runtime.logger.warn('account_sync devices skipped: no valid account_sync targets');
+        runtime.logger.trace('account_sync devices skipped: no valid account_sync targets');
         return;
     }
     await runSyncQuery(runtime, {
@@ -189,12 +192,12 @@ async function syncAccountDevicesDirtyBit(runtime) {
 async function syncAccountPictureDirtyBit(runtime) {
     const meJid = runtime.getCurrentCredentials()?.meJid ?? null;
     if (!meJid) {
-        runtime.logger.warn('account_sync picture skipped: meJid is missing');
+        runtime.logger.trace('account_sync picture skipped: meJid is missing');
         return;
     }
     const targetJid = toUserJid(meJid);
     const response = await runtime.queryWithContext('account_sync.picture', buildAccountPictureSyncIq(targetJid), WA_DEFAULTS.IQ_TIMEOUT_MS, { meJid, target: targetJid });
-    if (response.tag !== 'iq') {
+    if (response.tag !== WA_NODE_TAGS.IQ) {
         throw new Error(`account_sync.picture returned non-iq node (${response.tag})`);
     }
     if (response.attrs.type === WA_IQ_TYPES.RESULT) {
@@ -219,7 +222,7 @@ async function syncAccountPictureDirtyBit(runtime) {
 async function syncAccountPrivacyDirtyBit(runtime) {
     await runSyncQuery(runtime, {
         queryContext: 'account_sync.privacy',
-        node: buildAccountPrivacySyncIq(),
+        node: buildGetPrivacySettingsIq(),
         logMessage: 'account_sync privacy synchronized'
     });
 }
@@ -234,13 +237,23 @@ async function syncGroupsDirtyBit(runtime) {
     await runSyncQuery(runtime, {
         queryContext: 'dirty.groups',
         assertContext: 'groups',
-        node: buildGroupsDirtySyncIq(),
+        node: buildListParticipatingGroupsIq(),
         logMessage: 'groups dirty sync completed'
     });
 }
 async function syncNewsletterMetadataDirtyBit(runtime) {
-    runtime.logger.info('newsletter_metadata dirty bit received (GraphQL/MEX sync intentionally disabled)');
     await runtime.queryWithContext('dirty.newsletter_metadata', buildNewsletterMetadataSyncIq(), WA_DEFAULTS.IQ_TIMEOUT_MS);
+    if (runtime.newsletterListSubscribed) {
+        try {
+            await runtime.newsletterListSubscribed();
+        }
+        catch (error) {
+            runtime.logger.warn('newsletter_metadata MEX sync failed', {
+                message: toError(error).message
+            });
+            throw error;
+        }
+    }
 }
 function resolveAccountSyncDeviceTargets(credentials) {
     if (!credentials?.meJid) {
@@ -256,14 +269,15 @@ function resolveAccountSyncDeviceTargets(credentials) {
 async function runSyncQuery(runtime, args) {
     const response = await runtime.queryWithContext(args.queryContext, args.node, WA_DEFAULTS.IQ_TIMEOUT_MS, args.contextData);
     assertIqResult(response, args.assertContext ?? args.queryContext);
+    logUsyncProtocolErrors(parseUsyncResultEnvelope(response), runtime.logger, args.queryContext);
     runtime.logger.debug(args.logMessage, args.contextData);
 }
 async function clearDirtyBits(runtime, dirtyBits) {
     try {
         await runtime.queryWithContext('dirty.clear', buildClearDirtyBitsIq(dirtyBits), WA_DEFAULTS.IQ_TIMEOUT_MS, {
             count: dirtyBits.length
-        });
-        runtime.logger.info('dirty bits cleared', {
+        }, { useSystemId: true });
+        runtime.logger.debug('dirty bits cleared', {
             count: dirtyBits.length
         });
     }