zapo-js 0.3.0 → 1.0.0

package/dist/esm/store/{providers/memory → memory}/message-secret.store.js

@@ -1,5 +1,5 @@
-import { resolvePositive } from '../../../util/coercion.js';
-import { resolveCleanupIntervalMs, setBoundedMapEntry } from '../../../util/collections.js';
+import { resolvePositive } from '../../util/coercion.js';
+import { createPeriodicCleanup, setBoundedMapEntry } from '../../util/collections.js';
 const DEFAULTS = Object.freeze({
     ttlMs: 30 * 60 * 1000,
     maxSecrets: 10000
@@ -12,10 +12,19 @@ export class WaMessageSecretMemoryStore {
         this.secrets = new Map();
         this.ttlMs = ttlMs;
         this.maxSecrets = resolvePositive(options.maxSecrets, DEFAULTS.maxSecrets, 'WaMessageSecretMemoryStoreOptions.maxSecrets');
-        this.cleanupTimer = setInterval(() => {
+        this.logger = options.logger;
+        this.capacityWarned = false;
+        this.cleanup = createPeriodicCleanup(ttlMs, () => {
             void this.cleanupExpired(Date.now());
-        }, resolveCleanupIntervalMs(ttlMs));
-        this.cleanupTimer.unref();
+        });
+    }
+    warnCapacity() {
+        if (this.capacityWarned || !this.logger)
+            return;
+        this.capacityWarned = true;
+        this.logger.warn('message secret store at capacity, evicting oldest', {
+            max: this.maxSecrets
+        });
     }
     async get(messageId, nowMs = Date.now()) {
         const cached = this.secrets.get(messageId);
@@ -49,7 +58,7 @@ export class WaMessageSecretMemoryStore {
             secret: entry.secret,
             senderJid: entry.senderJid,
             expiresAtMs: Date.now() + this.ttlMs
-        }, this.maxSecrets);
+        }, this.maxSecrets, () => this.warnCapacity());
     }
     async setBatch(entries) {
         const nowMs = Date.now();
@@ -58,7 +67,7 @@ export class WaMessageSecretMemoryStore {
                 secret: entries[i].entry.secret,
                 senderJid: entries[i].entry.senderJid,
                 expiresAtMs: nowMs + this.ttlMs
-            }, this.maxSecrets);
+            }, this.maxSecrets, () => this.warnCapacity());
         }
     }
     async cleanupExpired(nowMs) {
@@ -75,7 +84,7 @@ export class WaMessageSecretMemoryStore {
         this.secrets.clear();
     }
     async destroy() {
-        clearInterval(this.cleanupTimer);
+        this.cleanup.destroy();
         this.secrets.clear();
     }
 }

package/dist/esm/store/{providers/memory → memory}/message.store.js

@@ -1,5 +1,5 @@
-import { resolvePositive } from '../../../util/coercion.js';
-import { normalizeQueryLimit, setBoundedMapEntry } from '../../../util/collections.js';
+import { resolvePositive } from '../../util/coercion.js';
+import { normalizeQueryLimit, setBoundedMapEntry } from '../../util/collections.js';
 const DEFAULT_MESSAGE_MEMORY_STORE_LIMITS = Object.freeze({
     messages: 50000
 });

package/dist/esm/store/{providers/memory → memory}/pre-key.store.js

@@ -1,5 +1,5 @@
-import { resolvePositive } from '../../../util/coercion.js';
-import { setBoundedMapEntry } from '../../../util/collections.js';
+import { resolvePositive } from '../../util/coercion.js';
+import { setBoundedMapEntry } from '../../util/collections.js';
 const DEFAULT_MAX_PRE_KEYS = 4096;
 export class WaPreKeyMemoryStore {
     constructor(options = {}) {

package/dist/esm/store/{providers/memory → memory}/privacy-token.store.js

@@ -1,4 +1,4 @@
-import { setBoundedMapEntry } from '../../../util/collections.js';
+import { setBoundedMapEntry } from '../../util/collections.js';
 const DEFAULT_MAX_ENTRIES = 10000;
 export class WaPrivacyTokenMemoryStore {
     constructor(maxEntries = DEFAULT_MAX_ENTRIES) {

package/dist/esm/store/{providers/memory → memory}/retry.store.js

@@ -1,5 +1,5 @@
-import { resolvePositive } from '../../../util/coercion.js';
-import { resolveCleanupIntervalMs, setBoundedMapEntry } from '../../../util/collections.js';
+import { resolvePositive } from '../../util/coercion.js';
+import { createPeriodicCleanup, setBoundedMapEntry } from '../../util/collections.js';
 const DEFAULTS = Object.freeze({
     ttlMs: 60 * 1000,
     maxOutboundMessages: 10000,
@@ -16,10 +16,28 @@ export class WaRetryMemoryStore {
         this.ttlMs = ttlMs;
         this.maxOutboundMessages = resolvePositive(options.maxOutboundMessages, DEFAULTS.maxOutboundMessages, 'WaRetryMemoryStoreOptions.maxOutboundMessages');
         this.maxInboundCounters = resolvePositive(options.maxInboundCounters, DEFAULTS.maxInboundCounters, 'WaRetryMemoryStoreOptions.maxInboundCounters');
-        this.cleanupTimer = setInterval(() => {
+        this.logger = options.logger;
+        this.outboundCapacityWarned = false;
+        this.inboundCapacityWarned = false;
+        this.cleanup = createPeriodicCleanup(this.ttlMs, () => {
             void this.cleanupExpired(Date.now());
-        }, resolveCleanupIntervalMs(this.ttlMs));
-        this.cleanupTimer.unref();
+        });
+    }
+    warnOutboundCapacity() {
+        if (this.outboundCapacityWarned || !this.logger)
+            return;
+        this.outboundCapacityWarned = true;
+        this.logger.warn('retry outbound store at capacity, evicting oldest', {
+            max: this.maxOutboundMessages
+        });
+    }
+    warnInboundCapacity() {
+        if (this.inboundCapacityWarned || !this.logger)
+            return;
+        this.inboundCapacityWarned = true;
+        this.logger.warn('retry inbound counters at capacity, evicting oldest', {
+            max: this.maxInboundCounters
+        });
     }
     getTtlMs() {
         return this.ttlMs;
@@ -75,6 +93,7 @@ export class WaRetryMemoryStore {
         };
         setBoundedMapEntry(this.outboundMessages, record.messageId, storedRecord, this.maxOutboundMessages, (messageId) => {
             this.eligibleSets.delete(messageId);
+            this.warnOutboundCapacity();
         });
         if (record.eligibleRequesterDeviceJids && record.eligibleRequesterDeviceJids.length > 0) {
             this.eligibleSets.set(record.messageId, new Set(record.eligibleRequesterDeviceJids));
@@ -103,6 +122,7 @@ export class WaRetryMemoryStore {
             expiresAtMs
         }, this.maxOutboundMessages, (evictedMessageId) => {
             this.eligibleSets.delete(evictedMessageId);
+            this.warnOutboundCapacity();
         });
     }
     async markOutboundRequesterDelivered(messageId, requesterDeviceJid, updatedAtMs, expiresAtMs) {
@@ -119,13 +139,14 @@ export class WaRetryMemoryStore {
             expiresAtMs
         }, this.maxOutboundMessages, (evictedMessageId) => {
             this.eligibleSets.delete(evictedMessageId);
+            this.warnOutboundCapacity();
         });
     }
     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;
-        setBoundedMapEntry(this.inboundCounters, key, { count, expiresAtMs }, this.maxInboundCounters);
+        setBoundedMapEntry(this.inboundCounters, key, { count, expiresAtMs }, this.maxInboundCounters, () => this.warnInboundCapacity());
         return count;
     }
     async cleanupExpired(nowMs) {
@@ -151,7 +172,7 @@ export class WaRetryMemoryStore {
         this.inboundCounters.clear();
     }
     async destroy() {
-        clearInterval(this.cleanupTimer);
+        this.cleanup.destroy();
         await this.clear();
     }
     counterKey(messageId, requesterJid) {

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

@@ -1,6 +1,6 @@
-import { signalAddressKey } from '../../../protocol/jid.js';
-import { resolvePositive } from '../../../util/coercion.js';
-import { setBoundedMapEntry } from '../../../util/collections.js';
+import { signalAddressKey } from '../../protocol/jid.js';
+import { resolvePositive } from '../../util/coercion.js';
+import { setBoundedMapEntry } from '../../util/collections.js';
 const DEFAULT_SENDER_KEY_STORE_LIMITS = Object.freeze({
     senderKeys: 8192,
     senderDistributions: 8192

package/dist/esm/store/{providers/memory → memory}/session.store.js

@@ -1,6 +1,6 @@
-import { signalAddressKey } from '../../../protocol/jid.js';
-import { resolvePositive } from '../../../util/coercion.js';
-import { setBoundedMapEntry } from '../../../util/collections.js';
+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 = {}) {

package/dist/esm/store/{providers/memory → memory}/thread.store.js

@@ -1,5 +1,5 @@
-import { resolvePositive } from '../../../util/coercion.js';
-import { normalizeQueryLimit, setBoundedMapEntry } from '../../../util/collections.js';
+import { resolvePositive } from '../../util/coercion.js';
+import { normalizeQueryLimit, setBoundedMapEntry } from '../../util/collections.js';
 const DEFAULT_THREAD_MEMORY_STORE_LIMITS = Object.freeze({
     threads: 10000
 });

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

@@ -27,6 +27,7 @@ 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 () => { }
 });
@@ -42,10 +43,10 @@ export const NOOP_RETRY_STORE = Object.freeze({
     clear: async () => { },
     destroy: async () => { }
 });
-export const NOOP_PARTICIPANTS_STORE = Object.freeze({
-    upsertGroupParticipants: async (_snapshot) => { },
-    getGroupParticipants: async (_groupJid, _nowMs) => null,
-    deleteGroupParticipants: async (_groupJid) => 0,
+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 () => { }
@@ -53,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

@@ -9,6 +9,11 @@ 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) {
@@ -46,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 });
             },
@@ -110,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();
@@ -150,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,
@@ -163,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,
@@ -248,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})`));
@@ -269,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) {
@@ -344,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({
@@ -172,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) {
@@ -335,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}`));
         };
     }
@@ -404,8 +424,12 @@ 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) {

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);