zapo-js 0.2.0 → 0.3.0

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

@@ -200,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

@@ -1,17 +1,8 @@
 import { proto } from '../../proto.js';
 import { buildDeleteCoverPhotoIq, buildEditBusinessProfileIq, buildGetBusinessProfileIq, buildGetVerifiedNameIq, buildUpdateCoverPhotoIq } from '../../transport/node/builders/business.js';
-import { findNodeChild, getNodeChildren } from '../../transport/node/helpers.js';
+import { findNodeChild, getNodeChildren, getNodeTextContent } from '../../transport/node/helpers.js';
 import { assertIqResult } from '../../transport/node/query.js';
-import { TEXT_DECODER } from '../../util/bytes.js';
 import { longToNumber } from '../../util/primitives.js';
-function readTextContent(node) {
-    const content = node.content;
-    if (content instanceof Uint8Array)
-        return TEXT_DECODER.decode(content);
-    if (typeof content === 'string')
-        return content;
-    return undefined;
-}
 function parseBusinessProfiles(result) {
     const bizNode = findNodeChild(result, 'business_profile');
     if (!bizNode) {
@@ -40,7 +31,7 @@ function parseBusinessProfiles(result) {
         const websites = [];
         for (let j = 0; j < children.length; j += 1) {
             const child = children[j];
-            const text = readTextContent(child);
+            const text = getNodeTextContent(child);
             switch (child.tag) {
                 case 'description':
                     if (text !== undefined)
@@ -102,7 +93,7 @@ function parseBusinessCategories(node) {
         const id = child.attrs.id;
         if (!id)
             continue;
-        categories[count] = { id, name: readTextContent(child) ?? '' };
+        categories[count] = { id, name: getNodeTextContent(child) ?? '' };
         count += 1;
     }
     categories.length = count;
@@ -139,7 +130,7 @@ function parseProfileOptions(node) {
     const options = {};
     for (let i = 0; i < children.length; i += 1) {
         const child = children[i];
-        const text = readTextContent(child);
+        const text = getNodeTextContent(child);
         if (text !== undefined) {
             options[child.tag] = text;
         }

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/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({
@@ -263,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) {

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

@@ -1,7 +1,8 @@
 import { randomBytesAsync, sha256 } from '../../crypto/index.js';
+import { md5Bytes } from '../../crypto/core/primitives.js';
 import { PromiseDedup } from '../../infra/perf/PromiseDedup.js';
 import { ensureMessageSecret } from '../../message/index.js';
-import { resolveEditAttr, resolveEncMediaType, resolveMessageTypeAttr, resolveMetaAttrs } from '../../message/content.js';
+import { needsSecretPersistence, resolveEditAttr, resolveEncMediaType, resolveMessageTypeAttr, resolveMetaAttrs } from '../../message/content.js';
 import { wrapDeviceSentMessage } from '../../message/device-sent.js';
 import { injectDeviceListMetadata, resolveIcdcMeta } from '../../message/icdc.js';
 import { writeRandomPadMax16 } from '../../message/padding.js';
@@ -9,8 +10,7 @@ import { computePhashV2 } from '../../message/phash.js';
 import { buildReportingTokenArtifacts } from '../../message/reporting-token.js';
 import { proto } from '../../proto.js';
 import { WA_DEFAULTS } from '../../protocol/constants.js';
-import { isGroupJid, normalizeDeviceJid, normalizeRecipientJid, parseJidFull, parseSignalAddressFromJid, splitJid, toUserJid } from '../../protocol/jid.js';
-import { signalAddressKey } from '../../protocol/jid.js';
+import { isGroupJid, isLidJid, normalizeDeviceJid, normalizeRecipientJid, parseJidFull, parseSignalAddressFromJid, signalAddressKey, toUserJid } from '../../protocol/jid.js';
 import { encodeBinaryNode } from '../../transport/binary/index.js';
 import { buildDirectMessageFanoutNode, buildGroupSenderKeyMessageNode, buildMetaNode } from '../../transport/node/builders/message.js';
 import { bytesToHex, concatBytes, TEXT_ENCODER } from '../../util/bytes.js';
@@ -31,12 +31,17 @@ export class WaMessageDispatchCoordinator {
         this.senderKeyManager = options.senderKeyManager;
         this.signalProtocol = options.signalProtocol;
         this.signalStore = options.signalStore;
+        this.sessionStore = options.sessionStore;
+        this.identityStore = options.identityStore;
         this.deviceListStore = options.deviceListStore;
+        this.messageSecretStore = options.messageSecretStore;
         this.getCurrentMeJid = options.getCurrentMeJid;
         this.getCurrentMeLid = options.getCurrentMeLid;
         this.getCurrentSignedIdentity = options.getCurrentSignedIdentity;
         this.resolvePrivacyTokenNode = options.resolvePrivacyTokenNode;
         this.onDirectMessageSent = options.onDirectMessageSent;
+        this.getIcdcHashLength = options.getIcdcHashLength;
+        this.mobileMessageIdFormat = options.mobileMessageIdFormat ?? false;
     }
     async publishMessageNode(node, options = {}) {
         this.logger.debug('wa client publish message node', {
@@ -129,6 +134,21 @@ export class WaMessageDispatchCoordinator {
             this.withResolvedMessageId(options)
         ]);
         const messageWithSecret = await ensureMessageSecret(message);
+        const rawSecret = messageWithSecret.messageContextInfo?.messageSecret;
+        if (rawSecret &&
+            rawSecret.length > 0 &&
+            sendOptions.id &&
+            needsSecretPersistence(messageWithSecret)) {
+            const meJid = this.getCurrentMeJid() ?? '';
+            void this.messageSecretStore
+                .set(sendOptions.id, { secret: rawSecret, senderJid: meJid })
+                .catch((error) => {
+                this.logger.warn('failed to persist outgoing message secret', {
+                    id: sendOptions.id,
+                    message: toError(error).message
+                });
+            });
+        }
         const meJid = this.getCurrentMeJid();
         const regInfo = meJid ? await this.signalStore.getRegistrationInfo() : null;
         const localPubKey = regInfo?.identityKeyPair.pubKey;
@@ -408,14 +428,8 @@ export class WaMessageDispatchCoordinator {
     }
     resolveGroupAddressingMode(participantUserJids, groupJid) {
         for (let index = 0; index < participantUserJids.length; index += 1) {
-            const participantJid = participantUserJids[index];
-            try {
-                if (splitJid(participantJid).server === 'lid') {
-                    return 'lid';
-                }
-            }
-            catch (error) {
-                this.logger.trace('ignoring malformed participant jid in addressing mode resolution', { participantJid, message: toError(error).message });
+            if (isLidJid(participantUserJids[index])) {
+                return 'lid';
             }
         }
         this.logger.trace('group addressing mode resolved to pn (default)', {
@@ -511,7 +525,7 @@ export class WaMessageDispatchCoordinator {
             for (let index = 0; index < pendingTargets.length; index += 1) {
                 pendingTargetAddresses[index] = pendingTargets[index].address;
             }
-            const hasPendingSessions = await this.signalStore.hasSessions(pendingTargetAddresses);
+            const hasPendingSessions = await this.sessionStore.hasSessions(pendingTargetAddresses);
             const nextAvailableTargets = [];
             for (let index = 0; index < pendingTargets.length; index += 1) {
                 if (hasPendingSessions[index]) {
@@ -719,9 +733,20 @@ export class WaMessageDispatchCoordinator {
     async generateOutgoingMessageId() {
         try {
             const meUserJid = toUserJid(this.requireCurrentMeJid('sendMessage'));
-            const timestampSeconds = Math.floor(Date.now() / 1000);
             const timestampBytes = new Uint8Array(8);
-            new DataView(timestampBytes.buffer, timestampBytes.byteOffset, timestampBytes.byteLength).setBigUint64(0, BigInt(timestampSeconds), false);
+            const dv = new DataView(timestampBytes.buffer, timestampBytes.byteOffset, timestampBytes.byteLength);
+            if (this.mobileMessageIdFormat) {
+                dv.setBigUint64(0, BigInt(Date.now()), false);
+                const entropy = concatBytes([
+                    timestampBytes,
+                    TEXT_ENCODER.encode(meUserJid),
+                    await randomBytesAsync(16)
+                ]);
+                const digest = md5Bytes(entropy);
+                digest[0] = 0xac;
+                return bytesToHex(digest).toUpperCase();
+            }
+            dv.setBigUint64(0, BigInt(Math.floor(Date.now() / 1000)), false);
             const entropy = concatBytes([
                 timestampBytes,
                 TEXT_ENCODER.encode(meUserJid),
@@ -731,9 +756,14 @@ export class WaMessageDispatchCoordinator {
             return `3EB0${bytesToHex(digest.subarray(0, 9)).toUpperCase()}`;
         }
         catch (error) {
-            this.logger.warn('failed to generate sha256 message id, falling back to random id', {
+            this.logger.warn('failed to generate message id, falling back to random', {
                 message: toError(error).message
             });
+            if (this.mobileMessageIdFormat) {
+                const bytes = await randomBytesAsync(16);
+                bytes[0] = 0xac;
+                return bytesToHex(bytes).toUpperCase();
+            }
             return `3EB0${bytesToHex(await randomBytesAsync(8)).toUpperCase()}`;
         }
     }
@@ -762,7 +792,7 @@ export class WaMessageDispatchCoordinator {
     getEncodedSignedDeviceIdentity() {
         const signedIdentity = this.getCurrentSignedIdentity();
         if (!signedIdentity) {
-            throw new Error('missing signed identity for pkmsg fanout');
+            return undefined;
         }
         return proto.ADVSignedDeviceIdentity.encode(signedIdentity).finish();
     }
@@ -774,7 +804,7 @@ export class WaMessageDispatchCoordinator {
                 if (!snapshot || snapshot.deviceJids.length === 0) {
                     return null;
                 }
-                return resolveIcdcMeta(snapshot.deviceJids, this.signalStore, snapshot.updatedAtMs, localIdentity);
+                return resolveIcdcMeta(snapshot.deviceJids, this.identityStore, snapshot.updatedAtMs, localIdentity, this.getIcdcHashLength?.());
             }
             catch (error) {
                 this.logger.trace('icdc resolution failed', {

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

@@ -0,0 +1,110 @@
+import { buildOfflineBatchNode } from '../../transport/node/builders/offline.js';
+import { toError } from '../../util/primitives.js';
+const WA_OFFLINE_RESUME = Object.freeze({
+    BATCH_SIZE: 200,
+    STANZA_TIMEOUT_MS: 60000
+});
+const WA_OFFLINE_RESUME_STATE = Object.freeze({
+    INIT: 'init',
+    RESUMING: 'resuming',
+    COMPLETE: 'complete'
+});
+export class WaOfflineResumeCoordinator {
+    constructor(options) {
+        this.logger = options.logger;
+        this.runtime = options.runtime;
+        this.state = WA_OFFLINE_RESUME_STATE.INIT;
+        this.totalStanzas = 0;
+        this.pendingStanzas = 0;
+        this.stanzaTimeout = null;
+    }
+    get isComplete() {
+        return this.state === WA_OFFLINE_RESUME_STATE.COMPLETE;
+    }
+    get isResuming() {
+        return this.state === WA_OFFLINE_RESUME_STATE.RESUMING;
+    }
+    handleOfflinePreview(stanzaCount) {
+        this.clearTimers();
+        this.state = WA_OFFLINE_RESUME_STATE.RESUMING;
+        this.totalStanzas = stanzaCount;
+        this.pendingStanzas = stanzaCount;
+        this.logger.info('offline resume started', {
+            totalStanzas: stanzaCount
+        });
+        this.runtime.emitOfflineResume({
+            status: 'resuming',
+            totalStanzas: stanzaCount,
+            remainingStanzas: stanzaCount,
+            forced: false
+        });
+        void this.sendOfflineBatch();
+        this.resetStanzaTimeout();
+    }
+    handleOfflineComplete(serverStanzaCount) {
+        if (this.state !== WA_OFFLINE_RESUME_STATE.RESUMING) {
+            return;
+        }
+        this.completeResume(false, serverStanzaCount);
+    }
+    trackOfflineStanza() {
+        if (this.state !== WA_OFFLINE_RESUME_STATE.RESUMING) {
+            return;
+        }
+        this.pendingStanzas = Math.max(0, this.pendingStanzas - 1);
+        this.resetStanzaTimeout();
+    }
+    reset() {
+        this.clearTimers();
+        this.state = WA_OFFLINE_RESUME_STATE.INIT;
+        this.totalStanzas = 0;
+        this.pendingStanzas = 0;
+    }
+    completeResume(forced, serverStanzaCount) {
+        this.clearTimers();
+        this.state = WA_OFFLINE_RESUME_STATE.COMPLETE;
+        this.logger.info('offline resume complete', {
+            totalStanzas: this.totalStanzas,
+            remainingStanzas: this.pendingStanzas,
+            serverStanzaCount,
+            forced
+        });
+        this.runtime.emitOfflineResume({
+            status: 'complete',
+            totalStanzas: this.totalStanzas,
+            remainingStanzas: this.pendingStanzas,
+            forced
+        });
+    }
+    async sendOfflineBatch() {
+        try {
+            await this.runtime.sendNode(buildOfflineBatchNode(WA_OFFLINE_RESUME.BATCH_SIZE));
+        }
+        catch (err) {
+            this.logger.warn('offline batch request failed', {
+                message: toError(err).message
+            });
+        }
+    }
+    resetStanzaTimeout() {
+        if (this.stanzaTimeout !== null) {
+            clearTimeout(this.stanzaTimeout);
+        }
+        this.stanzaTimeout = setTimeout(() => {
+            this.stanzaTimeout = null;
+            if (this.state === WA_OFFLINE_RESUME_STATE.RESUMING) {
+                this.logger.warn('offline resume forced complete due to stanza timeout', {
+                    totalStanzas: this.totalStanzas,
+                    remainingStanzas: this.pendingStanzas
+                });
+                this.completeResume(true);
+            }
+        }, WA_OFFLINE_RESUME.STANZA_TIMEOUT_MS);
+    }
+    clearTimers() {
+        if (this.stanzaTimeout !== null) {
+            clearTimeout(this.stanzaTimeout);
+            this.stanzaTimeout = null;
+        }
+    }
+}