zapo-js 0.1.2 → 0.2.0

package/dist/esm/store/locks/signal.lock.js

@@ -0,0 +1,63 @@
+import { SharedExclusiveGate } from '../../infra/perf/SharedExclusiveGate.js';
+import { StoreLock } from '../../infra/perf/StoreLock.js';
+const WA_SIGNAL_REGISTRATION_KEY = 'signal:registration';
+const WA_SIGNAL_SIGNED_PREKEY_KEY = 'signal:signedPreKey';
+const WA_SIGNAL_PREKEYS_KEY = 'signal:prekeys';
+const WA_SIGNAL_SERVER_HAS_PREKEYS_KEY = 'signal:serverHasPreKeys';
+const WA_SIGNAL_CLEAR_KEY = 'signal:clear';
+export function withSignalLock(store) {
+    const lock = new StoreLock();
+    const gate = new SharedExclusiveGate();
+    const destroyStore = store;
+    let cachedRegInfo;
+    return {
+        getRegistrationInfo: () => gate.runShared(async () => {
+            if (cachedRegInfo !== undefined) {
+                return cachedRegInfo;
+            }
+            const info = await store.getRegistrationInfo();
+            cachedRegInfo = info;
+            return info;
+        }),
+        setRegistrationInfo: (info) => gate.runShared(() => lock.run(WA_SIGNAL_REGISTRATION_KEY, async () => {
+            await store.setRegistrationInfo(info);
+            cachedRegInfo = info;
+        })),
+        getSignedPreKey: () => gate.runShared(() => store.getSignedPreKey()),
+        setSignedPreKey: (record) => gate.runShared(() => lock.run(WA_SIGNAL_SIGNED_PREKEY_KEY, () => store.setSignedPreKey(record))),
+        getSignedPreKeyById: (keyId) => gate.runShared(() => store.getSignedPreKeyById(keyId)),
+        setSignedPreKeyRotationTs: (value) => gate.runShared(() => lock.run(WA_SIGNAL_SIGNED_PREKEY_KEY, () => store.setSignedPreKeyRotationTs(value))),
+        getSignedPreKeyRotationTs: () => gate.runShared(() => store.getSignedPreKeyRotationTs()),
+        putPreKey: (record) => gate.runShared(() => lock.run(WA_SIGNAL_PREKEYS_KEY, () => store.putPreKey(record))),
+        getOrGenPreKeys: (count, generator) => gate.runShared(() => lock.run(WA_SIGNAL_PREKEYS_KEY, () => store.getOrGenPreKeys(count, generator))),
+        getPreKeyById: (keyId) => gate.runShared(() => store.getPreKeyById(keyId)),
+        getPreKeysById: (keyIds) => gate.runShared(() => store.getPreKeysById(keyIds)),
+        consumePreKeyById: (keyId) => gate.runShared(() => lock.run(WA_SIGNAL_PREKEYS_KEY, () => store.consumePreKeyById(keyId))),
+        getOrGenSinglePreKey: (generator) => gate.runShared(() => lock.run(WA_SIGNAL_PREKEYS_KEY, () => store.getOrGenSinglePreKey(generator))),
+        markKeyAsUploaded: (keyId) => gate.runShared(() => lock.run(WA_SIGNAL_PREKEYS_KEY, () => store.markKeyAsUploaded(keyId))),
+        setServerHasPreKeys: (value) => gate.runShared(() => lock.run(WA_SIGNAL_SERVER_HAS_PREKEYS_KEY, () => store.setServerHasPreKeys(value))),
+        getServerHasPreKeys: () => gate.runShared(() => store.getServerHasPreKeys()),
+        getSignalMeta: () => gate.runShared(() => store.getSignalMeta()),
+        hasSession: (address) => gate.runShared(() => store.hasSession(address)),
+        hasSessions: (addresses) => gate.runShared(() => store.hasSessions(addresses)),
+        getSession: (address) => gate.runShared(() => store.getSession(address)),
+        getSessionsBatch: (addresses) => gate.runShared(() => store.getSessionsBatch(addresses)),
+        // Session and identity read-modify-write semantics are serialized in SignalProtocol per address.
+        setSession: (address, session) => gate.runShared(() => store.setSession(address, session)),
+        setSessionsBatch: (entries) => gate.runShared(() => store.setSessionsBatch(entries)),
+        deleteSession: (address) => gate.runShared(() => store.deleteSession(address)),
+        getRemoteIdentity: (address) => gate.runShared(() => store.getRemoteIdentity(address)),
+        getRemoteIdentities: (addresses) => gate.runShared(() => store.getRemoteIdentities(addresses)),
+        setRemoteIdentity: (address, identityKey) => gate.runShared(() => store.setRemoteIdentity(address, identityKey)),
+        setRemoteIdentities: (entries) => gate.runShared(() => store.setRemoteIdentities(entries)),
+        clear: () => gate.runExclusive(() => lock.run(WA_SIGNAL_CLEAR_KEY, async () => {
+            await store.clear();
+            cachedRegInfo = undefined;
+        })),
+        destroy: async () => {
+            await gate.close();
+            await lock.shutdown();
+            await destroyStore.destroy?.();
+        }
+    };
+}

package/dist/esm/store/locks/thread.lock.js

@@ -0,0 +1,21 @@
+import { SharedExclusiveGate } from '../../infra/perf/SharedExclusiveGate.js';
+import { StoreLock } from '../../infra/perf/StoreLock.js';
+const WA_THREAD_CLEAR_KEY = 'thread:clear';
+export function withThreadLock(store) {
+    const lock = new StoreLock();
+    const gate = new SharedExclusiveGate();
+    const destroyStore = store;
+    return {
+        upsert: (record) => gate.runShared(() => lock.run(`thread:${record.jid}`, () => store.upsert(record))),
+        upsertBatch: (records) => gate.runShared(() => lock.runMany(records.map((record) => `thread:${record.jid}`), () => store.upsertBatch(records))),
+        getByJid: (jid) => gate.runShared(() => store.getByJid(jid)),
+        list: (limit) => gate.runShared(() => store.list(limit)),
+        deleteByJid: (jid) => gate.runShared(() => lock.run(`thread:${jid}`, () => store.deleteByJid(jid))),
+        clear: () => gate.runExclusive(() => lock.run(WA_THREAD_CLEAR_KEY, () => store.clear())),
+        destroy: async () => {
+            await gate.close();
+            await lock.shutdown();
+            await destroyStore.destroy?.();
+        }
+    };
+}

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

@@ -32,7 +32,7 @@ export const NOOP_PARTICIPANTS_STORE = Object.freeze({
 });
 export const NOOP_DEVICE_LIST_STORE = Object.freeze({
     upsertUserDevicesBatch: async (_snapshots) => { },
-    getUserDevicesBatch: async (userJids, _nowMs) => userJids.map(() => null),
+    getUserDevicesBatch: async (userJids, _nowMs) => new Array(userJids.length).fill(null),
     deleteUserDevices: async (_userJid) => 0,
     cleanupExpired: async (_nowMs) => 0,
     clear: async () => { },

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

@@ -7,13 +7,6 @@ const DEFAULT_APPSTATE_MEMORY_STORE_LIMITS = Object.freeze({
     syncKeys: 4096,
     collectionEntries: 50000
 });
-function toBoundedMap(entries, maxEntries) {
-    const map = new Map();
-    for (const [key, value] of entries) {
-        setBoundedMapEntry(map, key, value, maxEntries);
-    }
-    return map;
-}
 export class WaAppStateMemoryStore {
     constructor(initial, options = {}) {
         this.keys = new Map();
@@ -28,11 +21,15 @@ export class WaAppStateMemoryStore {
                 if (!collection) {
                     continue;
                 }
+                const indexValueMap = new Map();
+                for (const [key, value] of Object.entries(collection.indexValueMap)) {
+                    setBoundedMapEntry(indexValueMap, key, value, this.maxCollectionEntries);
+                }
                 this.collections.set(collectionName, {
                     initialized: true,
                     version: collection.version,
                     hash: collection.hash,
-                    indexValueMap: toBoundedMap(Object.entries(collection.indexValueMap), this.maxCollectionEntries)
+                    indexValueMap
                 });
             }
         }
@@ -65,14 +62,22 @@ export class WaAppStateMemoryStore {
         }
         return inserted;
     }
-    async getSyncKey(keyId) {
-        return this.keys.get(bytesToHex(keyId)) ?? null;
+    async getSyncKeysBatch(keyIds) {
+        const keys = new Array(keyIds.length);
+        for (let index = 0; index < keyIds.length; index += 1) {
+            keys[index] = this.keys.get(bytesToHex(keyIds[index])) ?? null;
+        }
+        return keys;
     }
     async getSyncKeyData(keyId) {
         return this.keys.get(bytesToHex(keyId))?.keyData ?? null;
     }
     async getSyncKeyDataBatch(keyIds) {
-        return keyIds.map((keyId) => this.keys.get(bytesToHex(keyId))?.keyData ?? null);
+        const keys = new Array(keyIds.length);
+        for (let index = 0; index < keyIds.length; index += 1) {
+            keys[index] = this.keys.get(bytesToHex(keyIds[index]))?.keyData ?? null;
+        }
+        return keys;
     }
     async getActiveSyncKey() {
         return pickActiveSyncKey(this.keys.values());
@@ -93,28 +98,21 @@ export class WaAppStateMemoryStore {
     async getCollectionStates(collections) {
         const result = new Array(collections.length);
         for (let index = 0; index < collections.length; index += 1) {
-            const collection = collections[index];
-            let state = this.collections.get(collection);
-            if (!state) {
-                state = {
-                    initialized: false,
-                    version: 0,
-                    hash: APP_STATE_EMPTY_LT_HASH,
-                    indexValueMap: new Map()
-                };
-                this.collections.set(collection, state);
-            }
-            result[index] = state;
+            result[index] = await this.getCollectionState(collections[index]);
         }
         return result;
     }
     async setCollectionStates(updates) {
         for (const update of updates) {
+            const indexValueMap = new Map();
+            for (const [key, value] of update.indexValueMap.entries()) {
+                setBoundedMapEntry(indexValueMap, key, value, this.maxCollectionEntries);
+            }
             this.collections.set(update.collection, {
                 initialized: true,
                 version: update.version,
                 hash: update.hash,
-                indexValueMap: toBoundedMap(update.indexValueMap.entries(), this.maxCollectionEntries)
+                indexValueMap
             });
         }
     }

package/dist/esm/store/providers/memory/device-list.store.js

@@ -24,17 +24,22 @@ export class WaDeviceListMemoryStore {
         }
     }
     async getUserDevicesBatch(userJids, nowMs = Date.now()) {
-        return userJids.map((userJid) => {
+        const snapshots = new Array(userJids.length);
+        for (let index = 0; index < userJids.length; index += 1) {
+            const userJid = userJids[index];
             const record = this.records.get(userJid);
             if (!record) {
-                return null;
+                snapshots[index] = null;
+                continue;
             }
             if (record.expiresAtMs <= nowMs) {
                 this.records.delete(userJid);
-                return null;
+                snapshots[index] = null;
+                continue;
             }
-            return record;
-        });
+            snapshots[index] = record;
+        }
+        return snapshots;
     }
     async deleteUserDevices(userJid) {
         return this.records.delete(userJid) ? 1 : 0;

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

@@ -0,0 +1,43 @@
+import { setBoundedMapEntry } from '../../../util/collections.js';
+const DEFAULT_MAX_ENTRIES = 10000;
+export class WaPrivacyTokenMemoryStore {
+    constructor(maxEntries = DEFAULT_MAX_ENTRIES) {
+        this.records = new Map();
+        this.maxEntries = maxEntries;
+    }
+    async upsert(record) {
+        const existing = this.records.get(record.jid);
+        const merged = existing ? this.mergeRecord(existing, record) : record;
+        setBoundedMapEntry(this.records, record.jid, merged, this.maxEntries);
+    }
+    async upsertBatch(records) {
+        for (let i = 0; i < records.length; i += 1) {
+            const record = records[i];
+            const existing = this.records.get(record.jid);
+            const merged = existing ? this.mergeRecord(existing, record) : record;
+            setBoundedMapEntry(this.records, record.jid, merged, this.maxEntries);
+        }
+    }
+    async getByJid(jid) {
+        return this.records.get(jid) ?? null;
+    }
+    async deleteByJid(jid) {
+        return this.records.delete(jid) ? 1 : 0;
+    }
+    async clear() {
+        this.records.clear();
+    }
+    async destroy() {
+        this.records.clear();
+    }
+    mergeRecord(existing, incoming) {
+        return {
+            jid: incoming.jid,
+            tcToken: incoming.tcToken ?? existing.tcToken,
+            tcTokenTimestamp: incoming.tcTokenTimestamp ?? existing.tcTokenTimestamp,
+            tcTokenSenderTimestamp: incoming.tcTokenSenderTimestamp ?? existing.tcTokenSenderTimestamp,
+            nctSalt: incoming.nctSalt ?? existing.nctSalt,
+            updatedAtMs: incoming.updatedAtMs
+        };
+    }
+}

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

@@ -1,8 +1,9 @@
 import { resolveCleanupIntervalMs } from '../../../util/collections.js';
-const DEFAULT_RETRY_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+const DEFAULT_RETRY_TTL_MS = 60 * 1000;
 export class WaRetryMemoryStore {
     constructor(ttlMs = DEFAULT_RETRY_TTL_MS) {
         this.outboundMessages = new Map();
+        this.eligibleSets = new Map();
         this.inboundCounters = new Map();
         this.ttlMs = ttlMs;
         this.cleanupTimer = setInterval(() => {
@@ -13,8 +14,66 @@ export class WaRetryMemoryStore {
     getTtlMs() {
         return this.ttlMs;
     }
+    supportsRawReplayPayload() {
+        return true;
+    }
+    async getOutboundRequesterStatus(messageId, requesterDeviceJid) {
+        const current = this.outboundMessages.get(messageId);
+        if (!current) {
+            return null;
+        }
+        const eligible = current.eligibleRequesterDeviceJids;
+        if (!eligible || eligible.length === 0) {
+            return null;
+        }
+        const eligibleSet = this.eligibleSets.get(current.messageId);
+        let isEligible = false;
+        if (eligibleSet) {
+            isEligible = eligibleSet.has(requesterDeviceJid);
+        }
+        else {
+            for (let index = 0; index < eligible.length; index += 1) {
+                if (eligible[index] === requesterDeviceJid) {
+                    isEligible = true;
+                    break;
+                }
+            }
+        }
+        if (!isEligible) {
+            return { eligible: false, delivered: false };
+        }
+        const delivered = current.deliveredRequesterDeviceJids;
+        if (!delivered || delivered.length === 0) {
+            return { eligible: true, delivered: false };
+        }
+        for (let index = 0; index < delivered.length; index += 1) {
+            if (delivered[index] === requesterDeviceJid) {
+                return { eligible: true, delivered: true };
+            }
+        }
+        return { eligible: true, delivered: false };
+    }
     async upsertOutboundMessage(record) {
-        this.outboundMessages.set(record.messageId, record);
+        this.outboundMessages.set(record.messageId, {
+            ...record,
+            eligibleRequesterDeviceJids: record.eligibleRequesterDeviceJids
+                ? [...record.eligibleRequesterDeviceJids]
+                : undefined,
+            deliveredRequesterDeviceJids: record.deliveredRequesterDeviceJids
+                ? [...record.deliveredRequesterDeviceJids]
+                : undefined
+        });
+        if (record.eligibleRequesterDeviceJids && record.eligibleRequesterDeviceJids.length > 0) {
+            this.eligibleSets.set(record.messageId, new Set(record.eligibleRequesterDeviceJids));
+        }
+        else {
+            this.eligibleSets.delete(record.messageId);
+        }
+    }
+    async deleteOutboundMessage(messageId) {
+        const existed = this.outboundMessages.delete(messageId);
+        this.eligibleSets.delete(messageId);
+        return existed ? 1 : 0;
     }
     async getOutboundMessage(messageId) {
         return this.outboundMessages.get(messageId) ?? null;
@@ -31,6 +90,20 @@ export class WaRetryMemoryStore {
             expiresAtMs
         });
     }
+    async markOutboundRequesterDelivered(messageId, requesterDeviceJid, updatedAtMs, expiresAtMs) {
+        const current = this.outboundMessages.get(messageId);
+        if (!current) {
+            return;
+        }
+        const delivered = new Set(current.deliveredRequesterDeviceJids ?? []);
+        delivered.add(requesterDeviceJid);
+        this.outboundMessages.set(messageId, {
+            ...current,
+            deliveredRequesterDeviceJids: Array.from(delivered),
+            updatedAtMs,
+            expiresAtMs
+        });
+    }
     async incrementInboundCounter(messageId, requesterJid, _updatedAtMs, expiresAtMs) {
         const key = this.counterKey(messageId, requesterJid);
         const current = this.inboundCounters.get(key);
@@ -47,6 +120,7 @@ export class WaRetryMemoryStore {
             if (record.expiresAtMs > nowMs)
                 continue;
             this.outboundMessages.delete(messageId);
+            this.eligibleSets.delete(messageId);
             removed += 1;
         }
         for (const [key, record] of this.inboundCounters) {
@@ -59,6 +133,7 @@ export class WaRetryMemoryStore {
     }
     async clear() {
         this.outboundMessages.clear();
+        this.eligibleSets.clear();
         this.inboundCounters.clear();
     }
     async destroy() {

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

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

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

@@ -58,12 +58,15 @@ export class WaSignalMemoryStore {
             throw new Error(`invalid prekey count: ${count}`);
         }
         const available = [];
-        const sortedIds = [...this.preKeys.keys()].sort((left, right) => left - right);
-        for (let index = 0; index < sortedIds.length; index += 1) {
-            const keyId = sortedIds[index];
-            if (this.uploadedPreKeys.has(keyId)) {
-                continue;
+        const 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;
@@ -86,7 +89,11 @@ export class WaSignalMemoryStore {
         return this.preKeys.get(keyId) ?? null;
     }
     async getPreKeysById(keyIds) {
-        return keyIds.map((keyId) => this.preKeys.get(keyId) ?? null);
+        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;
@@ -117,17 +124,33 @@ export class WaSignalMemoryStore {
     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) {
-        return addresses.map((address) => this.signalSessions.has(signalAddressKey(address)));
+        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) {
-        return addresses.map((address) => this.signalSessions.get(signalAddressKey(address)) ?? null);
+        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);
@@ -145,7 +168,11 @@ export class WaSignalMemoryStore {
         return this.remoteIdentities.get(signalAddressKey(address)) ?? null;
     }
     async getRemoteIdentities(addresses) {
-        return addresses.map((address) => this.remoteIdentities.get(signalAddressKey(address)) ?? null);
+        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);
@@ -167,16 +194,6 @@ export class WaSignalMemoryStore {
         this.nextPreKeyId = 1;
     }
     addUploadedPreKey(keyId) {
-        if (this.uploadedPreKeys.has(keyId)) {
-            this.uploadedPreKeys.delete(keyId);
-        }
         this.uploadedPreKeys.add(keyId);
-        while (this.uploadedPreKeys.size > this.maxPreKeys) {
-            const oldest = this.uploadedPreKeys.values().next().value;
-            if (oldest === undefined) {
-                break;
-            }
-            this.uploadedPreKeys.delete(oldest);
-        }
     }
 }

package/dist/esm/transport/WaComms.js

@@ -399,7 +399,9 @@ export class WaComms {
             this.schedulePendingFramesOverflowClose();
             return false;
         }
-        this.pendingFrames.push(...frames);
+        for (let i = 0; i < frames.length; i += 1) {
+            this.pendingFrames.push(frames[i]);
+        }
         this.pendingFramesByteLength = nextBytes;
         return true;
     }

package/dist/esm/transport/WaWebSocket.js

@@ -93,12 +93,6 @@ export class WaWebSocket {
         return (this.socket?.readyState === WA_READY_STATES.CONNECTING ||
             this.connectingSockets.size > 0);
     }
-    getReadyState() {
-        if (this.connectingSockets.size > 0) {
-            return WA_READY_STATES.CONNECTING;
-        }
-        return this.socket?.readyState ?? WA_READY_STATES.CLOSED;
-    }
     async open() {
         if (this.isOpen()) {
             this.logger.trace('socket open skipped: already open');

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

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

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

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

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

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

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

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