zapo-js 0.2.0 → 1.0.0

package/dist/esm/store/noop.store.js

@@ -1,4 +1,12 @@
 const EMPTY_STORE_LIST = Object.freeze([]);
+export const NOOP_MESSAGE_SECRET_STORE = Object.freeze({
+    get: async (_messageId) => null,
+    getBatch: async (messageIds) => new Array(messageIds.length).fill(null),
+    set: async (_messageId, _entry) => { },
+    setBatch: async (_entries) => { },
+    cleanupExpired: async (_nowMs) => 0,
+    clear: async () => { }
+});
 export const NOOP_MESSAGE_STORE = Object.freeze({
     upsert: async (_record) => { },
     upsertBatch: async (_records) => { },
@@ -19,13 +27,26 @@ export const NOOP_CONTACT_STORE = Object.freeze({
     upsert: async (_record) => { },
     upsertBatch: async (_records) => { },
     getByJid: async (_jid) => null,
+    getByPhoneNumber: async (_pn) => null,
     deleteByJid: async (_jid) => 0,
     clear: async () => { }
 });
-export const NOOP_PARTICIPANTS_STORE = Object.freeze({
-    upsertGroupParticipants: async (_snapshot) => { },
-    getGroupParticipants: async (_groupJid, _nowMs) => null,
-    deleteGroupParticipants: async (_groupJid) => 0,
+export const NOOP_RETRY_STORE = Object.freeze({
+    getOutboundRequesterStatus: async () => null,
+    upsertOutboundMessage: async (_record) => { },
+    deleteOutboundMessage: async (_messageId) => 0,
+    getOutboundMessage: async (_messageId) => null,
+    updateOutboundMessageState: async () => { },
+    markOutboundRequesterDelivered: async () => { },
+    incrementInboundCounter: async () => 0,
+    cleanupExpired: async (_nowMs) => 0,
+    clear: async () => { },
+    destroy: async () => { }
+});
+export const NOOP_GROUP_METADATA_STORE = Object.freeze({
+    upsertGroupMetadata: async (_snapshot) => { },
+    getGroupMetadata: async (_groupJid, _nowMs) => null,
+    deleteGroupMetadata: async (_groupJid) => 0,
     cleanupExpired: async (_nowMs) => 0,
     clear: async () => { },
     destroy: async () => { }
@@ -33,6 +54,7 @@ export const NOOP_PARTICIPANTS_STORE = Object.freeze({
 export const NOOP_DEVICE_LIST_STORE = Object.freeze({
     upsertUserDevicesBatch: async (_snapshots) => { },
     getUserDevicesBatch: async (userJids, _nowMs) => new Array(userJids.length).fill(null),
+    findByAnyUserJid: async (_jid, _nowMs) => null,
     deleteUserDevices: async (_userJid) => 0,
     cleanupExpired: async (_nowMs) => 0,
     clear: async () => { },

package/dist/esm/transport/WaComms.js

@@ -3,13 +3,17 @@ 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;
 const WA_PENDING_FRAMES_MAX_COUNT = 2048;
 const WA_PENDING_FRAMES_MAX_BYTES = 16 * 1024 * 1024;
+/**
+ * Owns the WebSocket + Noise handshake lifecycle: opens the socket, drives
+ * the noise pairing/login exchange, persists routing-info/server-static
+ * updates, and delivers post-handshake binary frames to the caller.
+ */
 export class WaComms {
     constructor(config, logger = new ConsoleLogger('info')) {
         if (!config.noise) {
@@ -29,7 +33,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 () => {
@@ -45,6 +51,7 @@ export class WaComms {
             onClose: async (info) => {
                 await this.onSocketClosed(info);
             },
+            // eslint-disable-next-line @typescript-eslint/require-await
             onError: async (error) => {
                 this.logger.warn('socket runtime error', { message: error.message });
             },
@@ -109,7 +116,7 @@ export class WaComms {
         };
     }
     startComms(handleStanza, inflateFrame) {
-        this.logger.info('comms start requested');
+        this.logger.debug('comms start requested');
         this.stanzaHandler = handleStanza;
         this.inflateFrame = inflateFrame ?? null;
         this.clearPendingFrames();
@@ -149,7 +156,7 @@ export class WaComms {
         this.frameProcessingQueue = this.frameProcessingQueue.then(() => this.flushPendingFrames(), () => this.flushPendingFrames());
     }
     async stopComms() {
-        this.logger.info('comms stop requested');
+        this.logger.debug('comms stop requested');
         this.resetConnectionState({
             started: false,
             connected: false,
@@ -162,7 +169,7 @@ export class WaComms {
         await this.socket.close(1000, 'stop_comms');
     }
     async closeSocketAndResume() {
-        this.logger.info('comms close socket and resume requested');
+        this.logger.debug('comms close socket and resume requested');
         this.resetConnectionState({
             started: true,
             connected: false,
@@ -247,6 +254,7 @@ export class WaComms {
             this.logger.warn('socket open failed', { message: toError(error).message });
         }
     }
+    // eslint-disable-next-line @typescript-eslint/require-await
     async onSocketClosed(info) {
         this.connected = false;
         this.noiseSession?.onSocketClosed(new Error(`socket closed (${info.code}:${info.reason})`));
@@ -268,7 +276,8 @@ export class WaComms {
         this.logger.info('socket closed, scheduling reconnect', {
             code: info.code,
             reason: info.reason,
-            reconnectAfterMs: this.config.reconnectIntervalMs
+            reconnectAfterMs: this.config.reconnectIntervalMs,
+            reconnectAttempts: this.reconnectAttempts
         });
     }
     onSocketMessage(payload) {
@@ -343,9 +352,10 @@ export class WaComms {
         this.lastServerStaticKey = session.getServerStaticKey();
         this.connected = true;
         this.reconnectAttempts = 0;
-        this.logger.info('comms connected and noise session established');
+        this.logger.debug('comms connected and noise session established');
         this.drainWaiters((waiter) => waiter.resolve());
     }
+    // eslint-disable-next-line @typescript-eslint/require-await
     async flushPendingFrames() {
         if (!this.handlingRequests || !this.stanzaHandler || this.pendingFrames.length === 0) {
             return;

package/dist/esm/transport/WaWebSocket.js

@@ -67,6 +67,11 @@ function resolveSocketRuntime() {
     }
     return 'browser';
 }
+/**
+ * Thin wrapper around a `RawWebSocket` (or Node `ws` constructor) used by
+ * {@link WaComms}. Iterates the configured URL list on failure and applies a
+ * connect/idle timeout.
+ */
 export class WaWebSocket {
     constructor(config, logger = new ConsoleLogger('info')) {
         this.config = Object.freeze({
@@ -75,7 +80,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 = {};
@@ -171,6 +177,7 @@ export class WaWebSocket {
             }
         });
     }
+    // eslint-disable-next-line @typescript-eslint/require-await
     async send(data) {
         const socket = this.socket;
         if (!socket || socket.readyState !== WA_READY_STATES.OPEN) {
@@ -334,16 +341,30 @@ export class WaWebSocket {
             handlers.onOpen();
         };
         entry.socket.onerror = () => {
-            this.logger.warn('socket open error', { url: entry.url });
+            if (entry.settled) {
+                this.logger.trace('settled pending socket error', { url: entry.url });
+            }
+            else {
+                this.logger.warn('socket open error', { url: entry.url });
+            }
             handlers.onFail(new Error(`websocket connect error for ${entry.url}`));
         };
         entry.socket.onclose = (event) => {
             const info = this.toCloseInfo(event);
-            this.logger.warn('socket closed before open', {
-                url: entry.url,
-                code: info.code,
-                reason: info.reason
-            });
+            if (entry.settled) {
+                this.logger.trace('settled pending socket closed', {
+                    url: entry.url,
+                    code: info.code,
+                    reason: info.reason
+                });
+            }
+            else {
+                this.logger.warn('socket closed before open', {
+                    url: entry.url,
+                    code: info.code,
+                    reason: info.reason
+                });
+            }
             handlers.onFail(new Error(`websocket closed before open (${info.code}:${info.reason}) for ${entry.url}`));
         };
     }
@@ -403,14 +424,25 @@ export class WaWebSocket {
         try {
             socket.close(code, reason);
         }
-        catch {
-            // no-op
+        catch (error) {
+            this.logger.trace('socket close ignored', {
+                code,
+                reason,
+                message: toError(error).message
+            });
         }
     }
     async createRawSocket(url) {
         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

@@ -14,7 +14,13 @@ export const BINARY_8 = 252;
 export const BINARY_20 = 253;
 export const BINARY_32 = 254;
 export const NIBBLE_8 = 255;
-export const NIBBLE_ALPHABET = [
+export const JID_U_DOMAIN_TYPE_PN = 0x00;
+export const JID_U_DOMAIN_TYPE_LID = 0x01;
+export const JID_U_DOMAIN_TYPE_HOSTED = 0x80;
+export const JID_U_DOMAIN_TYPE_HOSTED_LID = 0x81;
+export const JID_U_DOMAIN_TYPE_HOSTED_MASK = 0x80;
+export const JID_U_DOMAIN_TYPE_LID_MASK = 0x01;
+export const NIBBLE_ALPHABET = Object.freeze([
     '0',
     '1',
     '2',
@@ -31,8 +37,8 @@ export const NIBBLE_ALPHABET = [
     '\uFFFD',
     '\uFFFD',
     '\uFFFD'
-];
-export const HEX_ALPHABET = [
+]);
+export const HEX_ALPHABET = Object.freeze([
     '0',
     '1',
     '2',
@@ -49,7 +55,7 @@ export const HEX_ALPHABET = [
     'D',
     'E',
     'F'
-];
+]);
 export const SINGLE_BYTE_TOKEN_MAP = (() => {
     const map = new Map();
     for (let i = 0; i < SINGLE_BYTE_TOKENS.length; i += 1) {

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

@@ -1,18 +1,11 @@
 import { promisify } from 'node:util';
 import { inflateRaw, unzip } from 'node:zlib';
 import { WA_DEFAULTS } from '../../protocol/constants.js';
-import { BINARY_20, BINARY_32, BINARY_8, DICTIONARY_0, DICTIONARY_3, HEX_8, HEX_ALPHABET, JID_FB, JID_INTEROP, JID_PAIR, JID_U, LIST_16, LIST_8, LIST_EMPTY, NIBBLE_8, NIBBLE_ALPHABET, STREAM_END } from '../binary/constants.js';
+import { BINARY_20, BINARY_32, BINARY_8, DICTIONARY_0, DICTIONARY_3, HEX_8, HEX_ALPHABET, JID_FB, JID_INTEROP, JID_PAIR, JID_U, JID_U_DOMAIN_TYPE_HOSTED_LID, JID_U_DOMAIN_TYPE_HOSTED_MASK, JID_U_DOMAIN_TYPE_LID, JID_U_DOMAIN_TYPE_LID_MASK, LIST_16, LIST_8, LIST_EMPTY, NIBBLE_8, NIBBLE_ALPHABET, STREAM_END } from '../binary/constants.js';
 import { DICTIONARIES, SINGLE_BYTE_TOKENS } from '../binary/tokens.js';
 import { TEXT_DECODER, TEXT_ENCODER, toBytesView } from '../../util/bytes.js';
 const unzipAsync = promisify(unzip);
 const inflateRawAsync = promisify(inflateRaw);
-const JID_U_DOMAIN_TYPE_LID = 0x01;
-const JID_U_DOMAIN_TYPE_HOSTED_LID = 0x81;
-const JID_U_DOMAIN_TYPE_HOSTED_MASK = 0x80;
-const JID_U_DOMAIN_TYPE_LID_MASK = 0x01;
-const JID_U_DOMAIN_LID = 'lid';
-const JID_U_DOMAIN_HOSTED = 'hosted';
-const JID_U_DOMAIN_HOSTED_LID = 'hosted.lid';
 class ByteReader {
     constructor(data) {
         this.data = data;
@@ -54,27 +47,35 @@ class ByteReader {
         }
     }
 }
+// Reusable scratch buffer for nibble/hex unpack. Max output is
+// `(0x7f) * 2 = 254` bytes (length byte holds the packed-byte count in
+// its low 7 bits, each byte unpacks to ≤2 chars). Single-threaded JS +
+// non-reentrant decoder makes module-level reuse safe – `TextDecoder`
+// copies into the returned string before we touch the buffer again.
+const PACKED_SCRATCH = new Uint8Array(256);
 function parsePacked(reader, alphabet) {
     const lengthByte = reader.readUint8();
     const odd = (lengthByte & 0x80) !== 0;
     const byteCount = lengthByte & 0x7f;
     const outLength = byteCount * 2 - (odd ? 1 : 0);
-    const buf = new Uint8Array(outLength);
+    if (outLength < 0) {
+        throw new Error(`invalid packed length byte 0x${lengthByte.toString(16)}`);
+    }
     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) {
-            buf[outIndex] = alphabet[high].charCodeAt(0);
+            PACKED_SCRATCH[outIndex] = alphabet[high].charCodeAt(0);
             outIndex += 1;
         }
         if (outIndex < outLength) {
-            buf[outIndex] = alphabet[low].charCodeAt(0);
+            PACKED_SCRATCH[outIndex] = alphabet[low].charCodeAt(0);
             outIndex += 1;
         }
     }
-    return TEXT_DECODER.decode(buf);
+    return TEXT_DECODER.decode(PACKED_SCRATCH.subarray(0, outLength));
 }
 function readBinary(reader, token) {
     if (token === BINARY_8) {
@@ -128,14 +129,14 @@ function decodeJidU(reader) {
     const user = decodeTokenString(reader.readUint8(), reader);
     let domain = WA_DEFAULTS.HOST_DOMAIN;
     if (domainType === JID_U_DOMAIN_TYPE_LID) {
-        domain = JID_U_DOMAIN_LID;
+        domain = WA_DEFAULTS.LID_SERVER;
     }
     else if (domainType === JID_U_DOMAIN_TYPE_HOSTED_LID) {
-        domain = JID_U_DOMAIN_HOSTED_LID;
+        domain = WA_DEFAULTS.HOSTED_LID_SERVER;
     }
     else if ((domainType & JID_U_DOMAIN_TYPE_HOSTED_MASK) !== 0 &&
         (domainType & JID_U_DOMAIN_TYPE_LID_MASK) === 0) {
-        domain = JID_U_DOMAIN_HOSTED;
+        domain = WA_DEFAULTS.HOSTED_SERVER;
     }
     if (device > 0) {
         return `${user}:${device}@${domain}`;
@@ -243,6 +244,7 @@ function decodeNodeInternal(reader) {
         : { tag: tagValue, attrs, content };
     return node;
 }
+/** Decodes raw WhatsApp binary node bytes into a {@link BinaryNode}. */
 export function decodeBinaryNode(data) {
     const reader = new ByteReader(data);
     return decodeNodeInternal(reader);
@@ -261,6 +263,10 @@ async function inflateCompressedStanza(data) {
         }
     }
 }
+/**
+ * Decodes a framed stanza: reads the 1-byte flag, inflates the body when the
+ * `0x02` compression bit is set, then parses the result as a {@link BinaryNode}.
+ */
 export async function decodeBinaryNodeStanza(stanza) {
     const reader = new ByteReader(stanza);
     const flag = reader.readUint8();

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

@@ -1,4 +1,5 @@
-import { BINARY_20, BINARY_32, BINARY_8, DICTIONARY_0, DICTIONARY_TOKEN_MAPS, HEX_8, LIST_16, LIST_8, NIBBLE_8, SINGLE_BYTE_TOKEN_MAP } from '../binary/constants.js';
+import { WA_DEFAULTS } from '../../protocol/constants.js';
+import { BINARY_20, BINARY_32, BINARY_8, DICTIONARY_0, DICTIONARY_TOKEN_MAPS, HEX_8, JID_PAIR, JID_U, JID_U_DOMAIN_TYPE_HOSTED, JID_U_DOMAIN_TYPE_HOSTED_LID, JID_U_DOMAIN_TYPE_LID, JID_U_DOMAIN_TYPE_PN, LIST_16, LIST_8, LIST_EMPTY, NIBBLE_8, SINGLE_BYTE_TOKEN_MAP } from '../binary/constants.js';
 import { TEXT_ENCODER } from '../../util/bytes.js';
 class ByteWriter {
     constructor(initialCapacity = 256) {
@@ -46,27 +47,34 @@ class ByteWriter {
         this.buffer = next;
     }
 }
-function isNibbleString(value) {
-    for (let i = 0; i < value.length; i += 1) {
+const PACKED_NONE = 0;
+const PACKED_NIBBLE = 1;
+const PACKED_HEX = 2;
+function classifyPackedString(value) {
+    const n = value.length;
+    if (n === 0 || n >= 128)
+        return PACKED_NONE;
+    let nibbleOk = true;
+    let hexOk = true;
+    for (let i = 0; i < n; i += 1) {
         const code = value.charCodeAt(i);
-        const isDigit = code >= 48 && code <= 57;
-        const isSpecial = code === 45 || code === 46;
-        if (!isDigit && !isSpecial) {
-            return false;
+        if (code >= 48 && code <= 57)
+            continue;
+        if (code === 45 || code === 46) {
+            hexOk = false;
+            if (!nibbleOk)
+                return PACKED_NONE;
+            continue;
         }
-    }
-    return value.length > 0;
-}
-function isHexString(value) {
-    for (let i = 0; i < value.length; i += 1) {
-        const code = value.charCodeAt(i);
-        const isDigit = code >= 48 && code <= 57;
-        const isHex = code >= 65 && code <= 70;
-        if (!isDigit && !isHex) {
-            return false;
+        if (code >= 65 && code <= 70) {
+            nibbleOk = false;
+            if (!hexOk)
+                return PACKED_NONE;
+            continue;
         }
+        return PACKED_NONE;
     }
-    return value.length > 0;
+    return nibbleOk ? PACKED_NIBBLE : PACKED_HEX;
 }
 function toNibble(value, index, packedType) {
     const code = value.charCodeAt(index);
@@ -139,11 +147,12 @@ function writeString(value, writer) {
             return;
         }
     }
-    if (value.length < 128 && isNibbleString(value)) {
+    const packed = classifyPackedString(value);
+    if (packed === PACKED_NIBBLE) {
         writePackedString(value, NIBBLE_8, writer);
         return;
     }
-    if (value.length < 128 && isHexString(value)) {
+    if (packed === PACKED_HEX) {
         writePackedString(value, HEX_8, writer);
         return;
     }
@@ -151,6 +160,64 @@ function writeString(value, writer) {
     writeBinaryLength(encoded.length, writer);
     writer.writeBytes(encoded);
 }
+function tryWriteJid(value, writer) {
+    const atIndex = value.indexOf('@');
+    if (atIndex <= 0 || atIndex === value.length - 1) {
+        return false;
+    }
+    if (value.indexOf('@', atIndex + 1) !== -1) {
+        return false;
+    }
+    let userEnd = atIndex;
+    let device = 0;
+    const colonIndex = value.indexOf(':');
+    if (colonIndex !== -1 && colonIndex < atIndex) {
+        if (colonIndex === atIndex - 1) {
+            return false;
+        }
+        for (let i = colonIndex + 1; i < atIndex; i += 1) {
+            const digit = value.charCodeAt(i) - 48;
+            if (digit < 0 || digit > 9) {
+                return false;
+            }
+            device = device * 10 + digit;
+            if (device > 255) {
+                return false;
+            }
+        }
+        userEnd = colonIndex;
+    }
+    const server = value.slice(atIndex + 1);
+    let domainType = -1;
+    if (server === WA_DEFAULTS.LID_SERVER) {
+        domainType = JID_U_DOMAIN_TYPE_LID;
+    }
+    else if (server === WA_DEFAULTS.HOSTED_LID_SERVER) {
+        domainType = JID_U_DOMAIN_TYPE_HOSTED_LID;
+    }
+    else if (server === WA_DEFAULTS.HOST_DOMAIN) {
+        domainType = JID_U_DOMAIN_TYPE_PN;
+    }
+    else if (server === WA_DEFAULTS.HOSTED_SERVER) {
+        domainType = JID_U_DOMAIN_TYPE_HOSTED;
+    }
+    if (domainType !== -1 && device !== 0 && userEnd > 0) {
+        writer.writeUint8(JID_U);
+        writer.writeUint8(domainType);
+        writer.writeUint8(device);
+        writeString(value.slice(0, userEnd), writer);
+        return true;
+    }
+    writer.writeUint8(JID_PAIR);
+    if (userEnd === 0) {
+        writer.writeUint8(LIST_EMPTY);
+    }
+    else {
+        writeString(value.slice(0, userEnd), writer);
+    }
+    writeString(server, writer);
+    return true;
+}
 function writeListSize(size, writer) {
     if (!Number.isSafeInteger(size) || size < 0) {
         throw new Error(`invalid list size ${size}`);
@@ -176,7 +243,10 @@ function writeNodeInternal(node, writer) {
     for (let i = 0; i < keys.length; i += 1) {
         const key = keys[i];
         writeString(key, writer);
-        writeString(node.attrs[key], writer);
+        const value = node.attrs[key];
+        if (!tryWriteJid(value, writer)) {
+            writeString(value, writer);
+        }
     }
     if (!hasContent) {
         return;
@@ -198,11 +268,16 @@ function writeNodeInternal(node, writer) {
         writeNodeInternal(child, writer);
     }
 }
+/** Encodes a {@link BinaryNode} into its raw WhatsApp binary representation. */
 export function encodeBinaryNode(node) {
     const writer = new ByteWriter();
     writeNodeInternal(node, writer);
     return writer.toUint8Array();
 }
+/**
+ * Encodes a {@link BinaryNode} as a transport stanza – prefixes the bytes
+ * with the 1-byte flag (`0x00`) the WebSocket framing expects.
+ */
 export function encodeBinaryNodeStanza(node) {
     const writer = new ByteWriter();
     writer.writeUint8(0x00);

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

@@ -3,7 +3,7 @@
  * Source: WAWeb deobfuscated WAWapDict.js
  */
 export const DICT_VERSION = 3;
-export const SINGLE_BYTE_TOKENS = [
+export const SINGLE_BYTE_TOKENS = Object.freeze([
     'xmlstreamstart',
     'xmlstreamend',
     's.whatsapp.net',
@@ -239,8 +239,8 @@ export const SINGLE_BYTE_TOKENS = [
     '1080',
     '03',
     'screen_height'
-];
-export const DICTIONARY_0_TOKENS = [
+]);
+export const DICTIONARY_0_TOKENS = Object.freeze([
     'read-self',
     'active',
     'fbns',
@@ -497,8 +497,8 @@ export const DICTIONARY_0_TOKENS = [
     'catalog_exists',
     '01f',
     'mute_v2'
-];
-export const DICTIONARY_1_TOKENS = [
+]);
+export const DICTIONARY_1_TOKENS = Object.freeze([
     'reject',
     'dirty',
     'announcement',
@@ -755,8 +755,8 @@ export const DICTIONARY_1_TOKENS = [
     'web_md_migration_experience',
     'ptt_conversation_waveform',
     'u_aud_limit_sil_restarts_test1'
-];
-export const DICTIONARY_2_TOKENS = [
+]);
+export const DICTIONARY_2_TOKENS = Object.freeze([
     '64',
     'ptt_playback_speed_enabled',
     'web_product_list_message_enabled',
@@ -1013,8 +1013,8 @@ export const DICTIONARY_2_TOKENS = [
     '1213',
     '1304',
     '1537'
-];
-export const DICTIONARY_3_TOKENS = [
+]);
+export const DICTIONARY_3_TOKENS = Object.freeze([
     '1724',
     'profile_picture',
     '1071',
@@ -1271,10 +1271,10 @@ export const DICTIONARY_3_TOKENS = [
     '1147',
     '1372',
     '1961'
-];
-export const DICTIONARIES = [
+]);
+export const DICTIONARIES = Object.freeze([
     DICTIONARY_0_TOKENS,
     DICTIONARY_1_TOKENS,
     DICTIONARY_2_TOKENS,
     DICTIONARY_3_TOKENS
-];
+]);

package/dist/esm/transport/index.js

@@ -1,7 +1,14 @@
+export { decodeBinaryNode, decodeBinaryNodeStanza, encodeBinaryNode, encodeBinaryNodeStanza } from './binary/index.js';
 export { isProxyAgent, isProxyDispatcher, isProxyTransport, toProxyAgent, toProxyDispatcher } from './proxy.js';
+export { fetchLatestWaWebVersion } from './wa-web-version-fetcher.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';