zapo-js 0.2.0 → 0.3.0

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

@@ -1,14 +1,24 @@
-import { resolveCleanupIntervalMs } from '../../../util/collections.js';
-const DEFAULT_RETRY_TTL_MS = 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() {
@@ -54,7 +64,7 @@ export class WaRetryMemoryStore {
         return { eligible: true, delivered: false };
     }
     async upsertOutboundMessage(record) {
-        this.outboundMessages.set(record.messageId, {
+        const storedRecord = {
             ...record,
             eligibleRequesterDeviceJids: record.eligibleRequesterDeviceJids
                 ? [...record.eligibleRequesterDeviceJids]
@@ -62,6 +72,9 @@ export class WaRetryMemoryStore {
             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));
@@ -83,11 +96,13 @@ 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) {
@@ -97,21 +112,20 @@ export class WaRetryMemoryStore {
         }
         const delivered = new Set(current.deliveredRequesterDeviceJids ?? []);
         delivered.add(requesterDeviceJid);
-        this.outboundMessages.set(messageId, {
+        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) {

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,155 +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 availableKeyIds = [];
-        for (const keyId of this.preKeys.keys()) {
-            if (!this.uploadedPreKeys.has(keyId)) {
-                availableKeyIds.push(keyId);
-            }
-        }
-        availableKeyIds.sort((left, right) => left - right);
-        for (let index = 0; index < availableKeyIds.length; index += 1) {
-            const keyId = availableKeyIds[index];
-            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) {
-        const result = new Array(keyIds.length);
-        for (let i = 0; i < keyIds.length; i += 1) {
-            result[i] = this.preKeys.get(keyIds[i]) ?? null;
-        }
-        return result;
-    }
-    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 getSignalMeta() {
-        return {
-            serverHasPreKeys: this.serverHasPreKeys,
-            signedPreKeyRotationTs: this.signedPreKeyRotationTs,
-            registrationInfo: this.registrationInfo,
-            signedPreKey: this.signedPreKey
-        };
-    }
-    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 getRemoteIdentity(address) {
-        return this.remoteIdentities.get(signalAddressKey(address)) ?? null;
-    }
-    async getRemoteIdentities(addresses) {
-        const result = new Array(addresses.length);
-        for (let i = 0; i < addresses.length; i += 1) {
-            result[i] = this.remoteIdentities.get(signalAddressKey(addresses[i])) ?? null;
-        }
-        return result;
-    }
-    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) {
-        this.uploadedPreKeys.add(keyId);
     }
 }

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 () => {

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 = {};
@@ -411,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/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) {

package/dist/esm/transport/node/WaMobileTcpSocket.js

@@ -0,0 +1,114 @@
+import { connect as netConnect } from 'node:net';
+import { WA_READY_STATES } from '../../protocol/constants.js';
+import { TEXT_ENCODER } from '../../util/bytes.js';
+export class WaMobileTcpSocket {
+    constructor(url, _protocols, _options) {
+        this.binaryType = 'arraybuffer';
+        this.readyState = WA_READY_STATES.CONNECTING;
+        this.onopen = null;
+        this.onclose = null;
+        this.onerror = null;
+        this.onmessage = null;
+        this.closedCode = 1000;
+        this.closedReason = '';
+        this.closedClean = true;
+        this.forceCloseTimer = null;
+        const { host, port } = parseTcpUrl(url);
+        this.socket = netConnect({ host, port });
+        this.socket.on('connect', () => {
+            if (this.readyState !== WA_READY_STATES.CONNECTING)
+                return;
+            this.readyState = WA_READY_STATES.OPEN;
+            this.onopen?.({});
+        });
+        this.socket.on('data', (chunk) => {
+            if (!this.onmessage || this.readyState !== WA_READY_STATES.OPEN)
+                return;
+            const copy = new Uint8Array(chunk.byteLength);
+            copy.set(chunk);
+            this.onmessage({ data: copy });
+        });
+        this.socket.on('error', (err) => {
+            this.closedClean = false;
+            this.closedReason = err.message;
+            this.onerror?.({ reason: err.message });
+        });
+        this.socket.on('close', (hadError) => {
+            this.readyState = WA_READY_STATES.CLOSED;
+            if (this.forceCloseTimer) {
+                clearTimeout(this.forceCloseTimer);
+                this.forceCloseTimer = null;
+            }
+            if (hadError)
+                this.closedClean = false;
+            this.onclose?.({
+                code: this.closedCode,
+                reason: this.closedReason,
+                wasClean: this.closedClean
+            });
+        });
+    }
+    send(data) {
+        if (this.readyState !== WA_READY_STATES.OPEN) {
+            throw new Error('WaMobileTcpSocket: send() called on non-OPEN socket');
+        }
+        let bytes;
+        if (typeof data === 'string') {
+            bytes = TEXT_ENCODER.encode(data);
+        }
+        else if (data instanceof Uint8Array) {
+            bytes = data;
+        }
+        else {
+            bytes = new Uint8Array(data);
+        }
+        this.socket.write(bytes);
+    }
+    close(code, reason) {
+        if (this.readyState === WA_READY_STATES.CLOSED)
+            return;
+        this.readyState = WA_READY_STATES.CLOSING;
+        this.closedCode = code ?? 1000;
+        this.closedReason = reason ?? '';
+        this.socket.end();
+        this.forceCloseTimer = setTimeout(() => {
+            this.forceCloseTimer = null;
+            if (this.readyState !== WA_READY_STATES.CLOSED) {
+                this.socket.destroy();
+            }
+        }, 5000);
+        this.forceCloseTimer.unref();
+    }
+}
+function parseTcpUrl(url) {
+    let work = url;
+    if (work.startsWith('tcp://')) {
+        work = work.slice('tcp://'.length);
+    }
+    const queryIdx = work.indexOf('?');
+    if (queryIdx >= 0) {
+        work = work.slice(0, queryIdx);
+    }
+    const slash = work.indexOf('/');
+    if (slash >= 0) {
+        work = work.slice(0, slash);
+    }
+    const colon = work.lastIndexOf(':');
+    const host = colon === -1 ? work : work.slice(0, colon);
+    if (host.length === 0) {
+        throw new Error(`WaMobileTcpSocket: invalid host in ${JSON.stringify(url)}`);
+    }
+    if (colon === -1) {
+        return { host, port: 443 };
+    }
+    const portText = work.slice(colon + 1);
+    if (!/^\d+$/.test(portText)) {
+        throw new Error(`WaMobileTcpSocket: invalid port in ${JSON.stringify(url)}`);
+    }
+    const port = Number(portText);
+    if (port < 1 || port > 65535) {
+        throw new Error(`WaMobileTcpSocket: port out of range in ${JSON.stringify(url)}`);
+    }
+    return { host, port };
+}
+export const WaMobileTcpSocketCtor = WaMobileTcpSocket;

package/dist/esm/transport/node/WaNodeOrchestrator.js

@@ -1,12 +1,13 @@
 import { WA_DEFAULTS, WA_IQ_TYPES, WA_NODE_TAGS, WA_XMLNS } from '../../protocol/constants.js';
 import { toError } from '../../util/primitives.js';
-import { createNodeIdGenerator } from './helpers.js';
+import { createMobileNodeIdGenerator, createNodeIdGenerator } from './helpers.js';
 export class WaNodeOrchestrator {
     constructor(options) {
         this.logger = options.logger;
         this.sendNodeFn = options.sendNode;
         this.defaultTimeoutMs = options.defaultTimeoutMs ?? WA_DEFAULTS.NODE_QUERY_TIMEOUT_MS;
         this.hostDomain = options.hostDomain ?? WA_DEFAULTS.HOST_DOMAIN;
+        this.mobileIqIdFormat = options.mobileIqIdFormat === true;
         this.idGenerator = null;
         this.idGeneratorReady = null;
         this.pendingQueries = new Map();
@@ -69,12 +70,12 @@ export class WaNodeOrchestrator {
         this.logger.debug('auto-responded to ping iq', { id: node.attrs.id, xmlns });
         return true;
     }
-    async sendNode(node) {
-        const outbound = await this.withAutoId(node);
+    async sendNode(node, autoId = true) {
+        const outbound = autoId ? await this.withAutoId(node) : node;
         await this.sendNodeFn(outbound);
     }
-    async query(node, timeoutMs = this.defaultTimeoutMs) {
-        const outbound = await this.withAutoId(node);
+    async query(node, timeoutMs = this.defaultTimeoutMs, options = {}) {
+        const outbound = await this.withAutoId(node, options.useSystemId === true);
         const id = outbound.attrs.id;
         if (!id) {
             throw new Error('query node id is required');
@@ -110,12 +111,13 @@ export class WaNodeOrchestrator {
             });
         });
     }
-    async withAutoId(node) {
+    async withAutoId(node, useSystemId = false) {
         if (node.attrs.id) {
             return node;
         }
-        const generatedId = (await this.getIdGenerator()).next();
-        this.logger.trace('generated stanza id', { id: generatedId });
+        const generator = await this.getIdGenerator();
+        const generatedId = useSystemId && generator.nextSystem ? generator.nextSystem() : generator.next();
+        this.logger.trace('generated stanza id', { id: generatedId, system: useSystemId });
         return {
             ...node,
             attrs: {
@@ -128,6 +130,13 @@ export class WaNodeOrchestrator {
         if (this.idGenerator) {
             return this.idGenerator;
         }
+        if (this.mobileIqIdFormat) {
+            this.idGenerator = createMobileNodeIdGenerator();
+            this.logger.debug('generated stanza prefix (mobile)', {
+                prefix: this.idGenerator.prefix
+            });
+            return this.idGenerator;
+        }
         if (!this.idGeneratorReady) {
             this.idGeneratorReady = createNodeIdGenerator();
         }

package/dist/esm/transport/node/builders/abprops.js

@@ -0,0 +1,20 @@
+import { WA_ABPROPS_PROTOCOL_VERSION } from '../../../protocol/abprops.js';
+import { WA_DEFAULTS, WA_XMLNS } from '../../../protocol/constants.js';
+import { buildIqNode } from '../../node/query.js';
+export function buildGetAbPropsIq(options) {
+    const propsAttrs = {
+        protocol: WA_ABPROPS_PROTOCOL_VERSION
+    };
+    if (options?.hash) {
+        propsAttrs.hash = options.hash;
+    }
+    if (options?.refreshId !== undefined && options.refreshId !== null) {
+        propsAttrs.refresh_id = `${options.refreshId}`;
+    }
+    return buildIqNode('get', WA_DEFAULTS.HOST_DOMAIN, WA_XMLNS.ABPROPS, [
+        {
+            tag: 'props',
+            attrs: propsAttrs
+        }
+    ]);
+}

package/dist/esm/transport/node/builders/device.js

@@ -0,0 +1,11 @@
+import { WA_DEFAULTS } from '../../../protocol/defaults.js';
+import { WA_XMLNS } from '../../../protocol/nodes.js';
+import { buildIqNode } from '../../node/query.js';
+export function buildRemoveCompanionDeviceIq(deviceJid, reason) {
+    return buildIqNode('set', WA_DEFAULTS.HOST_DOMAIN, WA_XMLNS.MD, [
+        {
+            tag: 'remove-companion-device',
+            attrs: { jid: deviceJid, reason }
+        }
+    ]);
+}