zapo-js 0.2.0 → 1.0.0

package/dist/store/noop.store.js

@@ -1,7 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NOOP_DEVICE_LIST_STORE = exports.NOOP_PARTICIPANTS_STORE = exports.NOOP_CONTACT_STORE = exports.NOOP_THREAD_STORE = exports.NOOP_MESSAGE_STORE = void 0;
+exports.NOOP_DEVICE_LIST_STORE = exports.NOOP_GROUP_METADATA_STORE = exports.NOOP_RETRY_STORE = exports.NOOP_CONTACT_STORE = exports.NOOP_THREAD_STORE = exports.NOOP_MESSAGE_STORE = exports.NOOP_MESSAGE_SECRET_STORE = void 0;
 const EMPTY_STORE_LIST = Object.freeze([]);
+exports.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 () => { }
+});
 exports.NOOP_MESSAGE_STORE = Object.freeze({
     upsert: async (_record) => { },
     upsertBatch: async (_records) => { },
@@ -22,13 +30,26 @@ exports.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 () => { }
 });
-exports.NOOP_PARTICIPANTS_STORE = Object.freeze({
-    upsertGroupParticipants: async (_snapshot) => { },
-    getGroupParticipants: async (_groupJid, _nowMs) => null,
-    deleteGroupParticipants: async (_groupJid) => 0,
+exports.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 () => { }
+});
+exports.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 () => { }
@@ -36,6 +57,7 @@ exports.NOOP_PARTICIPANTS_STORE = Object.freeze({
 exports.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/transport/WaComms.js

@@ -7,12 +7,16 @@ const constants_1 = require("../protocol/constants");
 const WaNoiseSession_1 = require("./noise/WaNoiseSession");
 const WaWebSocket_1 = require("./WaWebSocket");
 const bytes_1 = require("../util/bytes");
-const bytes_2 = require("../util/bytes");
 const primitives_1 = require("../util/primitives");
 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.
+ */
 class WaComms {
     constructor(config, logger = new ConsoleLogger_1.ConsoleLogger('info')) {
         if (!config.noise) {
@@ -32,7 +36,9 @@ 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 () => {
@@ -48,6 +54,7 @@ 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 });
             },
@@ -112,7 +119,7 @@ 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();
@@ -152,7 +159,7 @@ 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,
@@ -165,7 +172,7 @@ 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,
@@ -250,6 +257,7 @@ class WaComms {
             this.logger.warn('socket open failed', { message: (0, primitives_1.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})`));
@@ -271,7 +279,8 @@ 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) {
@@ -340,15 +349,16 @@ class WaComms {
             this.noiseSession = null;
             throw error;
         }
-        const buffered = await session.pushWireChunk(bytes_2.EMPTY_BYTES);
+        const buffered = await session.pushWireChunk(bytes_1.EMPTY_BYTES);
         this.routeDecodedFrames(buffered);
         this.resumeHandshakeFailures = 0;
         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/transport/WaWebSocket.js

@@ -103,6 +103,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.
+ */
 class WaWebSocket {
     constructor(config, logger = new ConsoleLogger_1.ConsoleLogger('info')) {
         this.config = Object.freeze({
@@ -111,7 +116,8 @@ 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 = {};
@@ -207,6 +213,7 @@ class WaWebSocket {
             }
         });
     }
+    // eslint-disable-next-line @typescript-eslint/require-await
     async send(data) {
         const socket = this.socket;
         if (!socket || socket.readyState !== constants_1.WA_READY_STATES.OPEN) {
@@ -370,16 +377,30 @@ 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}`));
         };
     }
@@ -439,14 +460,25 @@ class WaWebSocket {
         try {
             socket.close(code, reason);
         }
-        catch {
-            // no-op
+        catch (error) {
+            this.logger.trace('socket close ignored', {
+                code,
+                reason,
+                message: (0, primitives_1.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/transport/binary/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DICTIONARY_TOKEN_MAPS = exports.SINGLE_BYTE_TOKEN_MAP = exports.HEX_ALPHABET = exports.NIBBLE_ALPHABET = exports.NIBBLE_8 = exports.BINARY_32 = exports.BINARY_20 = exports.BINARY_8 = exports.HEX_8 = exports.JID_PAIR = exports.LIST_16 = exports.LIST_8 = exports.JID_U = exports.JID_FB = exports.JID_INTEROP = exports.DICTIONARY_3 = exports.DICTIONARY_0 = exports.STREAM_END = exports.LIST_EMPTY = void 0;
+exports.DICTIONARY_TOKEN_MAPS = exports.SINGLE_BYTE_TOKEN_MAP = exports.HEX_ALPHABET = exports.NIBBLE_ALPHABET = exports.JID_U_DOMAIN_TYPE_LID_MASK = exports.JID_U_DOMAIN_TYPE_HOSTED_MASK = exports.JID_U_DOMAIN_TYPE_HOSTED_LID = exports.JID_U_DOMAIN_TYPE_HOSTED = exports.JID_U_DOMAIN_TYPE_LID = exports.JID_U_DOMAIN_TYPE_PN = exports.NIBBLE_8 = exports.BINARY_32 = exports.BINARY_20 = exports.BINARY_8 = exports.HEX_8 = exports.JID_PAIR = exports.LIST_16 = exports.LIST_8 = exports.JID_U = exports.JID_FB = exports.JID_INTEROP = exports.DICTIONARY_3 = exports.DICTIONARY_0 = exports.STREAM_END = exports.LIST_EMPTY = void 0;
 const tokens_1 = require("../binary/tokens");
 exports.LIST_EMPTY = 0;
 exports.STREAM_END = 2;
@@ -17,7 +17,13 @@ exports.BINARY_8 = 252;
 exports.BINARY_20 = 253;
 exports.BINARY_32 = 254;
 exports.NIBBLE_8 = 255;
-exports.NIBBLE_ALPHABET = [
+exports.JID_U_DOMAIN_TYPE_PN = 0x00;
+exports.JID_U_DOMAIN_TYPE_LID = 0x01;
+exports.JID_U_DOMAIN_TYPE_HOSTED = 0x80;
+exports.JID_U_DOMAIN_TYPE_HOSTED_LID = 0x81;
+exports.JID_U_DOMAIN_TYPE_HOSTED_MASK = 0x80;
+exports.JID_U_DOMAIN_TYPE_LID_MASK = 0x01;
+exports.NIBBLE_ALPHABET = Object.freeze([
     '0',
     '1',
     '2',
@@ -34,8 +40,8 @@ exports.NIBBLE_ALPHABET = [
     '\uFFFD',
     '\uFFFD',
     '\uFFFD'
-];
-exports.HEX_ALPHABET = [
+]);
+exports.HEX_ALPHABET = Object.freeze([
     '0',
     '1',
     '2',
@@ -52,7 +58,7 @@ exports.HEX_ALPHABET = [
     'D',
     'E',
     'F'
-];
+]);
 exports.SINGLE_BYTE_TOKEN_MAP = (() => {
     const map = new Map();
     for (let i = 0; i < tokens_1.SINGLE_BYTE_TOKENS.length; i += 1) {

package/dist/transport/binary/decoder.js

@@ -10,13 +10,6 @@ const tokens_1 = require("../binary/tokens");
 const bytes_1 = require("../../util/bytes");
 const unzipAsync = (0, node_util_1.promisify)(node_zlib_1.unzip);
 const inflateRawAsync = (0, node_util_1.promisify)(node_zlib_1.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;
@@ -58,27 +51,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 bytes_1.TEXT_DECODER.decode(buf);
+    return bytes_1.TEXT_DECODER.decode(PACKED_SCRATCH.subarray(0, outLength));
 }
 function readBinary(reader, token) {
     if (token === constants_2.BINARY_8) {
@@ -131,15 +132,15 @@ function decodeJidU(reader) {
     const device = reader.readUint8();
     const user = decodeTokenString(reader.readUint8(), reader);
     let domain = constants_1.WA_DEFAULTS.HOST_DOMAIN;
-    if (domainType === JID_U_DOMAIN_TYPE_LID) {
-        domain = JID_U_DOMAIN_LID;
+    if (domainType === constants_2.JID_U_DOMAIN_TYPE_LID) {
+        domain = constants_1.WA_DEFAULTS.LID_SERVER;
     }
-    else if (domainType === JID_U_DOMAIN_TYPE_HOSTED_LID) {
-        domain = JID_U_DOMAIN_HOSTED_LID;
+    else if (domainType === constants_2.JID_U_DOMAIN_TYPE_HOSTED_LID) {
+        domain = constants_1.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;
+    else if ((domainType & constants_2.JID_U_DOMAIN_TYPE_HOSTED_MASK) !== 0 &&
+        (domainType & constants_2.JID_U_DOMAIN_TYPE_LID_MASK) === 0) {
+        domain = constants_1.WA_DEFAULTS.HOSTED_SERVER;
     }
     if (device > 0) {
         return `${user}:${device}@${domain}`;
@@ -247,6 +248,7 @@ function decodeNodeInternal(reader) {
         : { tag: tagValue, attrs, content };
     return node;
 }
+/** Decodes raw WhatsApp binary node bytes into a {@link BinaryNode}. */
 function decodeBinaryNode(data) {
     const reader = new ByteReader(data);
     return decodeNodeInternal(reader);
@@ -265,6 +267,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}.
+ */
 async function decodeBinaryNodeStanza(stanza) {
     const reader = new ByteReader(stanza);
     const flag = reader.readUint8();

package/dist/transport/binary/encoder.js

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.encodeBinaryNode = encodeBinaryNode;
 exports.encodeBinaryNodeStanza = encodeBinaryNodeStanza;
-const constants_1 = require("../binary/constants");
+const constants_1 = require("../../protocol/constants");
+const constants_2 = require("../binary/constants");
 const bytes_1 = require("../../util/bytes");
 class ByteWriter {
     constructor(initialCapacity = 256) {
@@ -50,34 +51,41 @@ 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);
     if (code >= 48 && code <= 57) {
         return code - 48;
     }
-    if (packedType === constants_1.NIBBLE_8) {
+    if (packedType === constants_2.NIBBLE_8) {
         if (code === 45) {
             return 10;
         }
@@ -85,7 +93,7 @@ function toNibble(value, index, packedType) {
             return 11;
         }
     }
-    if (packedType === constants_1.HEX_8 && code >= 65 && code <= 70) {
+    if (packedType === constants_2.HEX_8 && code >= 65 && code <= 70) {
         return code - 55;
     }
     throw new Error(`cannot nibble encode char code ${code}`);
@@ -112,12 +120,12 @@ function writeBinaryLength(length, writer) {
         throw new Error(`invalid binary length ${length}`);
     }
     if (length < 256) {
-        writer.writeUint8(constants_1.BINARY_8);
+        writer.writeUint8(constants_2.BINARY_8);
         writer.writeUint8(length);
         return;
     }
     if (length < 1 << 20) {
-        writer.writeUint8(constants_1.BINARY_20);
+        writer.writeUint8(constants_2.BINARY_20);
         writer.writeUint8((length >>> 16) & 0xff);
         writer.writeUint8((length >>> 8) & 0xff);
         writer.writeUint8(length & 0xff);
@@ -126,48 +134,107 @@ function writeBinaryLength(length, writer) {
     if (!(length < 4294967296)) {
         throw new Error(`binary with length ${length} is too big for WAP protocol`);
     }
-    writer.writeUint8(constants_1.BINARY_32);
+    writer.writeUint8(constants_2.BINARY_32);
     writer.writeUint32(length);
 }
 function writeString(value, writer) {
-    const singleToken = constants_1.SINGLE_BYTE_TOKEN_MAP.get(value);
+    const singleToken = constants_2.SINGLE_BYTE_TOKEN_MAP.get(value);
     if (singleToken !== undefined) {
         writer.writeUint8(singleToken);
         return;
     }
-    for (let dictionaryIndex = 0; dictionaryIndex < constants_1.DICTIONARY_TOKEN_MAPS.length; dictionaryIndex += 1) {
-        const dictToken = constants_1.DICTIONARY_TOKEN_MAPS[dictionaryIndex].get(value);
+    for (let dictionaryIndex = 0; dictionaryIndex < constants_2.DICTIONARY_TOKEN_MAPS.length; dictionaryIndex += 1) {
+        const dictToken = constants_2.DICTIONARY_TOKEN_MAPS[dictionaryIndex].get(value);
         if (dictToken !== undefined) {
-            writer.writeUint8(constants_1.DICTIONARY_0 + dictionaryIndex);
+            writer.writeUint8(constants_2.DICTIONARY_0 + dictionaryIndex);
             writer.writeUint8(dictToken);
             return;
         }
     }
-    if (value.length < 128 && isNibbleString(value)) {
-        writePackedString(value, constants_1.NIBBLE_8, writer);
+    const packed = classifyPackedString(value);
+    if (packed === PACKED_NIBBLE) {
+        writePackedString(value, constants_2.NIBBLE_8, writer);
         return;
     }
-    if (value.length < 128 && isHexString(value)) {
-        writePackedString(value, constants_1.HEX_8, writer);
+    if (packed === PACKED_HEX) {
+        writePackedString(value, constants_2.HEX_8, writer);
         return;
     }
     const encoded = bytes_1.TEXT_ENCODER.encode(value);
     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 === constants_1.WA_DEFAULTS.LID_SERVER) {
+        domainType = constants_2.JID_U_DOMAIN_TYPE_LID;
+    }
+    else if (server === constants_1.WA_DEFAULTS.HOSTED_LID_SERVER) {
+        domainType = constants_2.JID_U_DOMAIN_TYPE_HOSTED_LID;
+    }
+    else if (server === constants_1.WA_DEFAULTS.HOST_DOMAIN) {
+        domainType = constants_2.JID_U_DOMAIN_TYPE_PN;
+    }
+    else if (server === constants_1.WA_DEFAULTS.HOSTED_SERVER) {
+        domainType = constants_2.JID_U_DOMAIN_TYPE_HOSTED;
+    }
+    if (domainType !== -1 && device !== 0 && userEnd > 0) {
+        writer.writeUint8(constants_2.JID_U);
+        writer.writeUint8(domainType);
+        writer.writeUint8(device);
+        writeString(value.slice(0, userEnd), writer);
+        return true;
+    }
+    writer.writeUint8(constants_2.JID_PAIR);
+    if (userEnd === 0) {
+        writer.writeUint8(constants_2.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}`);
     }
     if (size < 256) {
-        writer.writeUint8(constants_1.LIST_8);
+        writer.writeUint8(constants_2.LIST_8);
         writer.writeUint8(size);
         return;
     }
     if (!(size < 1 << 16)) {
         throw new Error(`list with size ${size} is too large for WAP protocol`);
     }
-    writer.writeUint8(constants_1.LIST_16);
+    writer.writeUint8(constants_2.LIST_16);
     writer.writeUint16(size);
 }
 function writeNodeInternal(node, writer) {
@@ -180,7 +247,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;
@@ -202,11 +272,16 @@ function writeNodeInternal(node, writer) {
         writeNodeInternal(child, writer);
     }
 }
+/** Encodes a {@link BinaryNode} into its raw WhatsApp binary representation. */
 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.
+ */
 function encodeBinaryNodeStanza(node) {
     const writer = new ByteWriter();
     writer.writeUint8(0x00);