zapo-js 0.1.2 → 0.3.0

package/dist/esm/store/providers/memory/retry.store.js

@@ -1,20 +1,92 @@
-import { resolveCleanupIntervalMs } from '../../../util/collections.js';
-const DEFAULT_RETRY_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+import { resolvePositive } from '../../../util/coercion.js';
+import { resolveCleanupIntervalMs, setBoundedMapEntry } from '../../../util/collections.js';
+const DEFAULTS = Object.freeze({
+    ttlMs: 60 * 1000,
+    maxOutboundMessages: 10000,
+    maxInboundCounters: 20000
+});
 export class WaRetryMemoryStore {
-    constructor(ttlMs = DEFAULT_RETRY_TTL_MS) {
+    constructor(ttlMs = DEFAULTS.ttlMs, options = {}) {
+        if (!Number.isFinite(ttlMs) || ttlMs <= 0) {
+            throw new Error('retry ttlMs must be a positive finite number');
+        }
         this.outboundMessages = new Map();
+        this.eligibleSets = new Map();
         this.inboundCounters = new Map();
         this.ttlMs = ttlMs;
+        this.maxOutboundMessages = resolvePositive(options.maxOutboundMessages, DEFAULTS.maxOutboundMessages, 'WaRetryMemoryStoreOptions.maxOutboundMessages');
+        this.maxInboundCounters = resolvePositive(options.maxInboundCounters, DEFAULTS.maxInboundCounters, 'WaRetryMemoryStoreOptions.maxInboundCounters');
         this.cleanupTimer = setInterval(() => {
             void this.cleanupExpired(Date.now());
-        }, resolveCleanupIntervalMs(ttlMs));
+        }, resolveCleanupIntervalMs(this.ttlMs));
         this.cleanupTimer.unref();
     }
     getTtlMs() {
         return this.ttlMs;
     }
+    supportsRawReplayPayload() {
+        return true;
+    }
+    async getOutboundRequesterStatus(messageId, requesterDeviceJid) {
+        const current = this.outboundMessages.get(messageId);
+        if (!current) {
+            return null;
+        }
+        const eligible = current.eligibleRequesterDeviceJids;
+        if (!eligible || eligible.length === 0) {
+            return null;
+        }
+        const eligibleSet = this.eligibleSets.get(current.messageId);
+        let isEligible = false;
+        if (eligibleSet) {
+            isEligible = eligibleSet.has(requesterDeviceJid);
+        }
+        else {
+            for (let index = 0; index < eligible.length; index += 1) {
+                if (eligible[index] === requesterDeviceJid) {
+                    isEligible = true;
+                    break;
+                }
+            }
+        }
+        if (!isEligible) {
+            return { eligible: false, delivered: false };
+        }
+        const delivered = current.deliveredRequesterDeviceJids;
+        if (!delivered || delivered.length === 0) {
+            return { eligible: true, delivered: false };
+        }
+        for (let index = 0; index < delivered.length; index += 1) {
+            if (delivered[index] === requesterDeviceJid) {
+                return { eligible: true, delivered: true };
+            }
+        }
+        return { eligible: true, delivered: false };
+    }
     async upsertOutboundMessage(record) {
-        this.outboundMessages.set(record.messageId, record);
+        const storedRecord = {
+            ...record,
+            eligibleRequesterDeviceJids: record.eligibleRequesterDeviceJids
+                ? [...record.eligibleRequesterDeviceJids]
+                : undefined,
+            deliveredRequesterDeviceJids: record.deliveredRequesterDeviceJids
+                ? [...record.deliveredRequesterDeviceJids]
+                : undefined
+        };
+        setBoundedMapEntry(this.outboundMessages, record.messageId, storedRecord, this.maxOutboundMessages, (messageId) => {
+            this.eligibleSets.delete(messageId);
+        });
+        if (record.eligibleRequesterDeviceJids && record.eligibleRequesterDeviceJids.length > 0) {
+            this.eligibleSets.set(record.messageId, new Set(record.eligibleRequesterDeviceJids));
+        }
+        else {
+            this.eligibleSets.delete(record.messageId);
+        }
+    }
+    async deleteOutboundMessage(messageId) {
+        const existed = this.outboundMessages.delete(messageId);
+        this.eligibleSets.delete(messageId);
+        return existed ? 1 : 0;
     }
     async getOutboundMessage(messageId) {
         return this.outboundMessages.get(messageId) ?? null;
@@ -24,21 +96,36 @@ export class WaRetryMemoryStore {
         if (!current) {
             return;
         }
-        this.outboundMessages.set(messageId, {
+        setBoundedMapEntry(this.outboundMessages, messageId, {
             ...current,
             state,
             updatedAtMs,
             expiresAtMs
+        }, this.maxOutboundMessages, (evictedMessageId) => {
+            this.eligibleSets.delete(evictedMessageId);
+        });
+    }
+    async markOutboundRequesterDelivered(messageId, requesterDeviceJid, updatedAtMs, expiresAtMs) {
+        const current = this.outboundMessages.get(messageId);
+        if (!current) {
+            return;
+        }
+        const delivered = new Set(current.deliveredRequesterDeviceJids ?? []);
+        delivered.add(requesterDeviceJid);
+        setBoundedMapEntry(this.outboundMessages, messageId, {
+            ...current,
+            deliveredRequesterDeviceJids: Array.from(delivered),
+            updatedAtMs,
+            expiresAtMs
+        }, this.maxOutboundMessages, (evictedMessageId) => {
+            this.eligibleSets.delete(evictedMessageId);
         });
     }
     async incrementInboundCounter(messageId, requesterJid, _updatedAtMs, expiresAtMs) {
         const key = this.counterKey(messageId, requesterJid);
         const current = this.inboundCounters.get(key);
         const count = current ? current.count + 1 : 1;
-        this.inboundCounters.set(key, {
-            count,
-            expiresAtMs
-        });
+        setBoundedMapEntry(this.inboundCounters, key, { count, expiresAtMs }, this.maxInboundCounters);
         return count;
     }
     async cleanupExpired(nowMs) {
@@ -47,6 +134,7 @@ export class WaRetryMemoryStore {
             if (record.expiresAtMs > nowMs)
                 continue;
             this.outboundMessages.delete(messageId);
+            this.eligibleSets.delete(messageId);
             removed += 1;
         }
         for (const [key, record] of this.inboundCounters) {
@@ -59,6 +147,7 @@ export class WaRetryMemoryStore {
     }
     async clear() {
         this.outboundMessages.clear();
+        this.eligibleSets.clear();
         this.inboundCounters.clear();
     }
     async destroy() {

package/dist/esm/store/providers/memory/sender-key.store.js

@@ -46,7 +46,12 @@ export class SenderKeyMemoryStore {
         return record ?? null;
     }
     async getDeviceSenderKeyDistributions(groupId, senders) {
-        return senders.map((sender) => this.senderDistributions.get(this.makeKey(groupId, sender)) ?? null);
+        const records = new Array(senders.length);
+        for (let index = 0; index < senders.length; index += 1) {
+            records[index] =
+                this.senderDistributions.get(this.makeKey(groupId, senders[index])) ?? null;
+        }
+        return records;
     }
     async deleteDeviceSenderKey(target, groupId) {
         let deleted = 0;

package/dist/esm/store/providers/memory/session.store.js

@@ -0,0 +1,45 @@
+import { signalAddressKey } from '../../../protocol/jid.js';
+import { resolvePositive } from '../../../util/coercion.js';
+import { setBoundedMapEntry } from '../../../util/collections.js';
+const DEFAULT_MAX_SESSIONS = 8192;
+export class WaSessionMemoryStore {
+    constructor(options = {}) {
+        this.signalSessions = new Map();
+        this.maxSessions = resolvePositive(options.maxSessions, DEFAULT_MAX_SESSIONS, 'WaSessionMemoryStoreOptions.maxSessions');
+    }
+    async hasSession(address) {
+        return this.signalSessions.has(signalAddressKey(address));
+    }
+    async hasSessions(addresses) {
+        const result = new Array(addresses.length);
+        for (let i = 0; i < addresses.length; i += 1) {
+            result[i] = this.signalSessions.has(signalAddressKey(addresses[i]));
+        }
+        return result;
+    }
+    async getSession(address) {
+        return this.signalSessions.get(signalAddressKey(address)) ?? null;
+    }
+    async getSessionsBatch(addresses) {
+        const result = new Array(addresses.length);
+        for (let i = 0; i < addresses.length; i += 1) {
+            result[i] = this.signalSessions.get(signalAddressKey(addresses[i])) ?? null;
+        }
+        return result;
+    }
+    async setSession(address, session) {
+        setBoundedMapEntry(this.signalSessions, signalAddressKey(address), session, this.maxSessions);
+    }
+    async setSessionsBatch(entries) {
+        for (let index = 0; index < entries.length; index += 1) {
+            const entry = entries[index];
+            setBoundedMapEntry(this.signalSessions, signalAddressKey(entry.address), entry.session, this.maxSessions);
+        }
+    }
+    async deleteSession(address) {
+        this.signalSessions.delete(signalAddressKey(address));
+    }
+    async clear() {
+        this.signalSessions.clear();
+    }
+}

package/dist/esm/store/providers/memory/signal.store.js

@@ -1,25 +1,8 @@
-import { signalAddressKey } from '../../../protocol/jid.js';
-import { resolvePositive } from '../../../util/coercion.js';
-import { setBoundedMapEntry } from '../../../util/collections.js';
-const DEFAULT_SIGNAL_STORE_LIMITS = Object.freeze({
-    preKeys: 4096,
-    sessions: 8192,
-    remoteIdentities: 8192
-});
 export class WaSignalMemoryStore {
-    constructor(options = {}) {
+    constructor() {
         this.registrationInfo = null;
         this.signedPreKey = null;
         this.signedPreKeyRotationTs = null;
-        this.preKeys = new Map();
-        this.uploadedPreKeys = new Set();
-        this.serverHasPreKeys = false;
-        this.signalSessions = new Map();
-        this.remoteIdentities = new Map();
-        this.nextPreKeyId = 1;
-        this.maxPreKeys = resolvePositive(options.maxPreKeys, DEFAULT_SIGNAL_STORE_LIMITS.preKeys, 'WaSignalMemoryStoreOptions.maxPreKeys');
-        this.maxSessions = resolvePositive(options.maxSessions, DEFAULT_SIGNAL_STORE_LIMITS.sessions, 'WaSignalMemoryStoreOptions.maxSessions');
-        this.maxRemoteIdentities = resolvePositive(options.maxRemoteIdentities, DEFAULT_SIGNAL_STORE_LIMITS.remoteIdentities, 'WaSignalMemoryStoreOptions.maxRemoteIdentities');
     }
     async getRegistrationInfo() {
         return this.registrationInfo;
@@ -45,138 +28,9 @@ export class WaSignalMemoryStore {
     async getSignedPreKeyRotationTs() {
         return this.signedPreKeyRotationTs;
     }
-    async putPreKey(record) {
-        setBoundedMapEntry(this.preKeys, record.keyId, record, this.maxPreKeys, (keyId) => {
-            this.uploadedPreKeys.delete(keyId);
-        });
-        if (record.keyId >= this.nextPreKeyId) {
-            this.nextPreKeyId = record.keyId + 1;
-        }
-    }
-    async getOrGenPreKeys(count, generator) {
-        if (!Number.isSafeInteger(count) || count <= 0) {
-            throw new Error(`invalid prekey count: ${count}`);
-        }
-        const available = [];
-        const sortedIds = [...this.preKeys.keys()].sort((left, right) => left - right);
-        for (let index = 0; index < sortedIds.length; index += 1) {
-            const keyId = sortedIds[index];
-            if (this.uploadedPreKeys.has(keyId)) {
-                continue;
-            }
-            const record = this.preKeys.get(keyId);
-            if (!record) {
-                continue;
-            }
-            available.push(record);
-            if (available.length >= count) {
-                return available;
-            }
-        }
-        while (available.length < count) {
-            const record = await generator(this.nextPreKeyId++);
-            setBoundedMapEntry(this.preKeys, record.keyId, record, this.maxPreKeys, (keyId) => {
-                this.uploadedPreKeys.delete(keyId);
-            });
-            available.push(record);
-        }
-        return available;
-    }
-    async getPreKeyById(keyId) {
-        return this.preKeys.get(keyId) ?? null;
-    }
-    async getPreKeysById(keyIds) {
-        return keyIds.map((keyId) => this.preKeys.get(keyId) ?? null);
-    }
-    async consumePreKeyById(keyId) {
-        const record = this.preKeys.get(keyId) ?? null;
-        if (!record) {
-            return null;
-        }
-        this.preKeys.delete(keyId);
-        this.uploadedPreKeys.delete(keyId);
-        return record;
-    }
-    async getOrGenSinglePreKey(generator) {
-        const preKeys = await this.getOrGenPreKeys(1, generator);
-        return preKeys[0];
-    }
-    async markKeyAsUploaded(keyId) {
-        if (keyId < 0 || keyId >= this.nextPreKeyId) {
-            throw new Error(`prekey ${keyId} is out of boundary`);
-        }
-        for (const candidate of this.preKeys.keys()) {
-            if (candidate <= keyId) {
-                this.addUploadedPreKey(candidate);
-            }
-        }
-    }
-    async setServerHasPreKeys(value) {
-        this.serverHasPreKeys = value;
-    }
-    async getServerHasPreKeys() {
-        return this.serverHasPreKeys;
-    }
-    async hasSession(address) {
-        return this.signalSessions.has(signalAddressKey(address));
-    }
-    async hasSessions(addresses) {
-        return addresses.map((address) => this.signalSessions.has(signalAddressKey(address)));
-    }
-    async getSession(address) {
-        return this.signalSessions.get(signalAddressKey(address)) ?? null;
-    }
-    async getSessionsBatch(addresses) {
-        return addresses.map((address) => this.signalSessions.get(signalAddressKey(address)) ?? null);
-    }
-    async setSession(address, session) {
-        setBoundedMapEntry(this.signalSessions, signalAddressKey(address), session, this.maxSessions);
-    }
-    async setSessionsBatch(entries) {
-        for (let index = 0; index < entries.length; index += 1) {
-            const entry = entries[index];
-            setBoundedMapEntry(this.signalSessions, signalAddressKey(entry.address), entry.session, this.maxSessions);
-        }
-    }
-    async deleteSession(address) {
-        this.signalSessions.delete(signalAddressKey(address));
-    }
-    async getRemoteIdentity(address) {
-        return this.remoteIdentities.get(signalAddressKey(address)) ?? null;
-    }
-    async getRemoteIdentities(addresses) {
-        return addresses.map((address) => this.remoteIdentities.get(signalAddressKey(address)) ?? null);
-    }
-    async setRemoteIdentity(address, identityKey) {
-        setBoundedMapEntry(this.remoteIdentities, signalAddressKey(address), identityKey, this.maxRemoteIdentities);
-    }
-    async setRemoteIdentities(entries) {
-        for (const entry of entries) {
-            setBoundedMapEntry(this.remoteIdentities, signalAddressKey(entry.address), entry.identityKey, this.maxRemoteIdentities);
-        }
-    }
     async clear() {
         this.registrationInfo = null;
         this.signedPreKey = null;
         this.signedPreKeyRotationTs = null;
-        this.preKeys.clear();
-        this.uploadedPreKeys.clear();
-        this.serverHasPreKeys = false;
-        this.signalSessions.clear();
-        this.remoteIdentities.clear();
-        this.nextPreKeyId = 1;
-    }
-    addUploadedPreKey(keyId) {
-        if (this.uploadedPreKeys.has(keyId)) {
-            this.uploadedPreKeys.delete(keyId);
-        }
-        this.uploadedPreKeys.add(keyId);
-        while (this.uploadedPreKeys.size > this.maxPreKeys) {
-            const oldest = this.uploadedPreKeys.values().next().value;
-            if (oldest === undefined) {
-                break;
-            }
-            this.uploadedPreKeys.delete(oldest);
-        }
     }
 }

package/dist/esm/transport/WaComms.js

@@ -3,8 +3,7 @@ import { BoundedTaskQueue, BoundedTaskQueueFullError } from '../infra/perf/Bound
 import { WA_DEFAULTS } from '../protocol/constants.js';
 import { WaNoiseSession } from './noise/WaNoiseSession.js';
 import { WaWebSocket } from './WaWebSocket.js';
-import { bytesToBase64UrlSafe } from '../util/bytes.js';
-import { EMPTY_BYTES } from '../util/bytes.js';
+import { bytesToBase64UrlSafe, EMPTY_BYTES } from '../util/bytes.js';
 import { toError } from '../util/primitives.js';
 const WA_FRAME_HANDLER_QUEUE_MAX_SIZE = 4096;
 const WA_FRAME_HANDLER_MAX_CONCURRENCY = 8;
@@ -29,7 +28,9 @@ export class WaComms {
             protocols: this.config.protocols,
             dispatcher: this.config.dispatcher,
             agent: this.config.agent,
-            timeoutIntervalMs: this.config.timeoutIntervalMs
+            headers: this.config.headers,
+            timeoutIntervalMs: this.config.timeoutIntervalMs,
+            rawWebSocketConstructor: this.config.rawWebSocketConstructor
         }, logger);
         this.socket.setHandlers({
             onOpen: async () => {
@@ -399,7 +400,9 @@ export class WaComms {
             this.schedulePendingFramesOverflowClose();
             return false;
         }
-        this.pendingFrames.push(...frames);
+        for (let i = 0; i < frames.length; i += 1) {
+            this.pendingFrames.push(frames[i]);
+        }
         this.pendingFramesByteLength = nextBytes;
         return true;
     }

package/dist/esm/transport/WaWebSocket.js

@@ -75,7 +75,8 @@ export class WaWebSocket {
         });
         this.socketUrls = resolveSocketUrls(config);
         this.logger = logger;
-        this.webSocketCtor = resolveWebSocketConstructor();
+        this.webSocketCtor = config.rawWebSocketConstructor ?? resolveWebSocketConstructor();
+        this.customWebSocketCtor = Boolean(config.rawWebSocketConstructor);
         this.socketRuntime = resolveSocketRuntime();
         this.connectingSockets = new Set();
         this.handlers = {};
@@ -93,12 +94,6 @@ export class WaWebSocket {
         return (this.socket?.readyState === WA_READY_STATES.CONNECTING ||
             this.connectingSockets.size > 0);
     }
-    getReadyState() {
-        if (this.connectingSockets.size > 0) {
-            return WA_READY_STATES.CONNECTING;
-        }
-        return this.socket?.readyState ?? WA_READY_STATES.CLOSED;
-    }
     async open() {
         if (this.isOpen()) {
             this.logger.trace('socket open skipped: already open');
@@ -417,6 +412,13 @@ export class WaWebSocket {
         const headers = this.config.headers;
         const dispatcher = this.config.dispatcher;
         const agent = this.config.agent;
+        if (this.customWebSocketCtor) {
+            return new this.webSocketCtor(url, this.config.protocols, {
+                headers,
+                dispatcher,
+                agent
+            });
+        }
         let hasHeaders = false;
         if (headers) {
             for (const key in headers) {

package/dist/esm/transport/binary/constants.js

@@ -64,33 +64,3 @@ export const DICTIONARY_TOKEN_MAPS = DICTIONARIES.map((dictionary) => {
     }
     return map;
 });
-export const WAP_ENCODE_CONSTANTS = Object.freeze({
-    LIST_EMPTY,
-    LIST_8,
-    LIST_16,
-    JID_PAIR,
-    HEX_8,
-    BINARY_8,
-    BINARY_20,
-    BINARY_32,
-    NIBBLE_8,
-    DICTIONARY_0,
-    DICTIONARY_3
-});
-export const WAP_DECODE_CONSTANTS = Object.freeze({
-    LIST_EMPTY,
-    LIST_8,
-    LIST_16,
-    JID_PAIR,
-    JID_FB,
-    JID_INTEROP,
-    JID_U,
-    HEX_8,
-    BINARY_8,
-    BINARY_20,
-    BINARY_32,
-    NIBBLE_8,
-    DICTIONARY_0,
-    DICTIONARY_3,
-    STREAM_END
-});

package/dist/esm/transport/binary/decoder.js

@@ -59,22 +59,22 @@ function parsePacked(reader, alphabet) {
     const odd = (lengthByte & 0x80) !== 0;
     const byteCount = lengthByte & 0x7f;
     const outLength = byteCount * 2 - (odd ? 1 : 0);
-    const chars = new Array(outLength);
+    const buf = new Uint8Array(outLength);
     let outIndex = 0;
     for (let i = 0; i < byteCount; i += 1) {
         const packed = reader.readUint8();
         const high = (packed >>> 4) & 0x0f;
         const low = packed & 0x0f;
         if (outIndex < outLength) {
-            chars[outIndex] = alphabet[high];
+            buf[outIndex] = alphabet[high].charCodeAt(0);
             outIndex += 1;
         }
         if (outIndex < outLength) {
-            chars[outIndex] = alphabet[low];
+            buf[outIndex] = alphabet[low].charCodeAt(0);
             outIndex += 1;
         }
     }
-    return chars.join('');
+    return TEXT_DECODER.decode(buf);
 }
 function readBinary(reader, token) {
     if (token === BINARY_8) {

package/dist/esm/transport/binary/encoder.js

@@ -167,20 +167,14 @@ function writeListSize(size, writer) {
     writer.writeUint16(size);
 }
 function writeNodeInternal(node, writer) {
-    let attrsLen = 0;
-    for (const key in node.attrs) {
-        if (Object.prototype.hasOwnProperty.call(node.attrs, key)) {
-            attrsLen += 1;
-        }
-    }
+    const keys = Object.keys(node.attrs);
+    const attrsLen = keys.length;
     const hasContent = node.content !== null && node.content !== undefined;
     const listSize = 1 + attrsLen * 2 + (hasContent ? 1 : 0);
     writeListSize(listSize, writer);
     writeString(node.tag, writer);
-    for (const key in node.attrs) {
-        if (!Object.prototype.hasOwnProperty.call(node.attrs, key)) {
-            continue;
-        }
+    for (let i = 0; i < keys.length; i += 1) {
+        const key = keys[i];
         writeString(key, writer);
         writeString(node.attrs[key], writer);
     }
@@ -210,9 +204,8 @@ export function encodeBinaryNode(node) {
     return writer.toUint8Array();
 }
 export function encodeBinaryNodeStanza(node) {
-    const encoded = encodeBinaryNode(node);
-    const out = new Uint8Array(1 + encoded.length);
-    out[0] = 0;
-    out.set(encoded, 1);
-    return out;
+    const writer = new ByteWriter();
+    writer.writeUint8(0x00);
+    writeNodeInternal(node, writer);
+    return writer.toUint8Array();
 }

package/dist/esm/transport/binary/index.js

@@ -1,4 +1,3 @@
 export * from '../binary/tokens.js';
 export * from '../binary/encoder.js';
 export * from '../binary/decoder.js';
-export { WAP_DECODE_CONSTANTS as WapDecodeConstants, WAP_ENCODE_CONSTANTS as WapEncodeConstants } from '../binary/constants.js';

package/dist/esm/transport/index.js

@@ -1,7 +1,13 @@
+export { decodeBinaryNode, decodeBinaryNodeStanza, encodeBinaryNode, encodeBinaryNodeStanza } from './binary/index.js';
 export { isProxyAgent, isProxyDispatcher, isProxyTransport, toProxyAgent, toProxyDispatcher } from './proxy.js';
 export { WaComms } from './WaComms.js';
+export { verifyNoiseCertificateChain } from './noise/WaNoiseCert.js';
+export { WaNoiseHandshake } from './noise/WaNoiseHandshake.js';
+export { WaNoiseSocket } from './noise/WaNoiseSocket.js';
 export { WaWebSocket } from './WaWebSocket.js';
 export { WaKeepAlive } from './keepalive/WaKeepAlive.js';
 export { WaNodeOrchestrator } from './node/WaNodeOrchestrator.js';
 export { WaNodeTransport } from './node/WaNodeTransport.js';
+export { WaMobileTcpSocket, WaMobileTcpSocketCtor } from './node/WaMobileTcpSocket.js';
+export { buildMobileLoginPayload } from './noise/WaMobileClientPayload.js';
 export { assertIqResult, buildIqNode, parseIqError, queryWithContext } from './node/query.js';

package/dist/esm/transport/keepalive/WaKeepAlive.js

@@ -8,7 +8,8 @@ export class WaKeepAlive {
         this.logger = options.logger;
         this.nodeOrchestrator = options.nodeOrchestrator;
         this.getCommsFn = options.getComms;
-        this.intervalMs = options.intervalMs ?? WA_DEFAULTS.HEALTH_CHECK_INTERVAL_MS;
+        this.baseIntervalMs = options.intervalMs ?? WA_DEFAULTS.HEALTH_CHECK_INTERVAL_MS;
+        this.getIntervalMs = options.getIntervalMs;
         this.timeoutMs = options.timeoutMs ?? WA_DEFAULTS.DEAD_SOCKET_TIMEOUT_MS;
         this.hostDomain = options.hostDomain ?? WA_DEFAULTS.HOST_DOMAIN;
         this.jitterRatio = this.normalizeJitterRatio(options.jitterRatio);
@@ -19,7 +20,7 @@ export class WaKeepAlive {
     }
     start() {
         this.logger.info('keepalive start', {
-            intervalMs: this.intervalMs,
+            intervalMs: this.resolveIntervalMs(),
             timeoutMs: this.timeoutMs,
             jitterRatio: this.jitterRatio,
             minJitterMs: this.minJitterMs
@@ -48,7 +49,7 @@ export class WaKeepAlive {
         this.logger.trace('keepalive scheduled', {
             generation,
             inMs: nextDelayMs,
-            baseIntervalMs: this.intervalMs
+            baseIntervalMs: this.resolveIntervalMs()
         });
     }
     async run(generation) {
@@ -110,20 +111,28 @@ export class WaKeepAlive {
         const normalized = value;
         return Math.min(Math.max(normalized, 0), KEEPALIVE_MAX_JITTER_RATIO);
     }
+    resolveIntervalMs() {
+        const candidate = this.getIntervalMs?.() ?? this.baseIntervalMs;
+        if (!Number.isFinite(candidate) || candidate <= 0) {
+            return this.baseIntervalMs;
+        }
+        return candidate;
+    }
     computeNextDelayMs() {
-        if (this.intervalMs <= 0) {
+        const intervalMs = this.resolveIntervalMs();
+        if (intervalMs <= 0) {
             return 0;
         }
         if (this.jitterRatio <= 0 && this.minJitterMs <= 0) {
-            return this.intervalMs;
+            return intervalMs;
         }
-        const ratioJitterMs = Math.floor(this.intervalMs * this.jitterRatio);
+        const ratioJitterMs = Math.floor(intervalMs * this.jitterRatio);
         const jitterWindowMs = Math.max(this.minJitterMs, ratioJitterMs);
         if (jitterWindowMs <= 0) {
-            return this.intervalMs;
+            return intervalMs;
         }
         const offsetMs = Math.floor(Math.random() * (jitterWindowMs * 2 + 1) - jitterWindowMs);
-        return Math.max(1, this.intervalMs + offsetMs);
+        return Math.max(1, intervalMs + offsetMs);
     }
     clearTimer() {
         if (!this.timer) {