zapo-js 0.1.1 → 0.2.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

@@ -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 '../../../util/signal-address.js';
 const DEFAULT_SENDER_KEY_STORE_LIMITS = Object.freeze({
     senderKeys: 8192,
     senderDistributions: 8192
@@ -45,12 +45,13 @@ export class SenderKeyMemoryStore {
         const record = this.senderKeys.get(this.makeKey(groupId, sender));
         return record ?? null;
     }
-    async getDeviceSenderKeyDistribution(groupId, sender) {
-        const record = this.senderDistributions.get(this.makeKey(groupId, sender));
-        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;
@@ -60,8 +61,10 @@ export class SenderKeyMemoryStore {
     }
     async markForgetSenderKey(groupId, participants) {
         let deleted = 0;
-        for (const participant of participants) {
-            deleted += await this.deleteDeviceSenderKey(participant, groupId);
+        for (let index = 0; index < participants.length; index += 1) {
+            const participant = participants[index];
+            deleted += this.deleteMatching(this.senderKeys, participant, groupId);
+            deleted += this.deleteMatching(this.senderDistributions, participant, groupId);
         }
         return deleted;
     }

package/dist/esm/store/providers/memory/signal.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 '../../../util/signal-address.js';
 const DEFAULT_SIGNAL_STORE_LIMITS = Object.freeze({
     preKeys: 4096,
     sessions: 8192,
@@ -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,24 +124,56 @@ 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) {
+        const result = new Array(addresses.length);
+        for (let i = 0; i < addresses.length; i += 1) {
+            result[i] = this.signalSessions.get(signalAddressKey(addresses[i])) ?? null;
+        }
+        return result;
+    }
     async setSession(address, session) {
         setBoundedMapEntry(this.signalSessions, signalAddressKey(address), session, this.maxSessions);
     }
+    async setSessionsBatch(entries) {
+        for (let index = 0; index < entries.length; index += 1) {
+            const entry = entries[index];
+            setBoundedMapEntry(this.signalSessions, signalAddressKey(entry.address), entry.session, this.maxSessions);
+        }
+    }
     async deleteSession(address) {
         this.signalSessions.delete(signalAddressKey(address));
     }
     async getRemoteIdentity(address) {
         return this.remoteIdentities.get(signalAddressKey(address)) ?? null;
     }
+    async getRemoteIdentities(addresses) {
+        const result = new Array(addresses.length);
+        for (let i = 0; i < addresses.length; i += 1) {
+            result[i] = this.remoteIdentities.get(signalAddressKey(addresses[i])) ?? null;
+        }
+        return result;
+    }
     async setRemoteIdentity(address, identityKey) {
         setBoundedMapEntry(this.remoteIdentities, signalAddressKey(address), identityKey, this.maxRemoteIdentities);
     }
@@ -155,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/store/providers/memory/thread.store.js

@@ -11,6 +11,11 @@ export class WaThreadMemoryStore {
     async upsert(record) {
         setBoundedMapEntry(this.threads, record.jid, record, this.maxThreads);
     }
+    async upsertBatch(records) {
+        for (const record of records) {
+            setBoundedMapEntry(this.threads, record.jid, record, this.maxThreads);
+        }
+    }
     async getByJid(jid) {
         return this.threads.get(jid) ?? null;
     }

package/dist/esm/transport/WaComms.js

@@ -3,7 +3,7 @@ import { BoundedTaskQueue, BoundedTaskQueueFullError } from '../infra/perf/Bound
 import { WA_DEFAULTS } from '../protocol/constants.js';
 import { WaNoiseSession } from './noise/WaNoiseSession.js';
 import { WaWebSocket } from './WaWebSocket.js';
-import { bytesToBase64UrlSafe } from '../util/base64.js';
+import { bytesToBase64UrlSafe } from '../util/bytes.js';
 import { EMPTY_BYTES } from '../util/bytes.js';
 import { toError } from '../util/primitives.js';
 const WA_FRAME_HANDLER_QUEUE_MAX_SIZE = 4096;
@@ -27,6 +27,8 @@ export class WaComms {
             url: this.config.url,
             urls: this.config.urls,
             protocols: this.config.protocols,
+            dispatcher: this.config.dispatcher,
+            agent: this.config.agent,
             timeoutIntervalMs: this.config.timeoutIntervalMs
         }, logger);
         this.socket.setHandlers({
@@ -144,9 +146,7 @@ export class WaComms {
     startHandlingRequests() {
         this.handlingRequests = true;
         this.logger.debug('comms request handling enabled');
-        this.frameProcessingQueue = this.frameProcessingQueue
-            .catch(() => undefined)
-            .then(async () => this.flushPendingFrames());
+        this.frameProcessingQueue = this.frameProcessingQueue.then(() => this.flushPendingFrames(), () => this.flushPendingFrames());
     }
     async stopComms() {
         this.logger.info('comms stop requested');
@@ -272,9 +272,7 @@ export class WaComms {
         });
     }
     onSocketMessage(payload) {
-        this.frameProcessingQueue = this.frameProcessingQueue
-            .catch(() => undefined)
-            .then(async () => this.processSocketPayload(payload));
+        this.frameProcessingQueue = this.frameProcessingQueue.then(() => this.processSocketPayload(payload), () => this.processSocketPayload(payload));
     }
     async processSocketPayload(payload) {
         if (!this.noiseSession) {
@@ -401,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;
     }
@@ -423,20 +423,19 @@ export class WaComms {
     }
     scheduleDecodedFrame(frame) {
         void this.frameHandlerQueue
-            .enqueue(async () => this.onDecodedFrame(frame))
+            .enqueue(() => this.onDecodedFrame(frame))
             .catch((error) => {
-            const normalized = toError(error);
-            this.logger.error('failed to enqueue decoded frame handler', {
-                message: normalized.message
-            });
-            if (!(error instanceof BoundedTaskQueueFullError)) {
+            if (error instanceof BoundedTaskQueueFullError) {
+                this.logger.warn('frame handler queue is full, resuming socket to preserve bounds', {
+                    pending: this.frameHandlerQueue.pending(),
+                    inFlight: this.frameHandlerQueue.inFlight()
+                });
+                void this.closeSocketAndResume();
                 return;
             }
-            this.logger.warn('frame handler queue is full, processing frame inline', {
-                pending: this.frameHandlerQueue.pending(),
-                inFlight: this.frameHandlerQueue.inFlight()
+            this.logger.error('failed to enqueue decoded frame handler', {
+                message: toError(error).message
             });
-            void this.onDecodedFrame(frame);
         });
     }
     scheduleReconnect() {
@@ -460,12 +459,16 @@ export class WaComms {
         this.reconnectTimer = null;
     }
     removeWaiter(reject) {
-        const index = this.waiters.findIndex((entry) => entry.reject === reject);
-        if (index === -1) {
+        for (let index = 0; index < this.waiters.length; index += 1) {
+            const waiter = this.waiters[index];
+            if (waiter.reject !== reject) {
+                continue;
+            }
+            clearTimeout(waiter.timer);
+            this.waiters[index] = this.waiters[this.waiters.length - 1];
+            this.waiters.pop();
             return;
         }
-        const [waiter] = this.waiters.splice(index, 1);
-        clearTimeout(waiter.timer);
     }
     withStickyRoutingCookie(headers) {
         const out = headers ? { ...headers } : {};
@@ -518,10 +521,11 @@ export class WaComms {
         }
     }
     drainWaiters(drain) {
-        const waiters = this.waiters.splice(0, this.waiters.length);
-        for (const waiter of waiters) {
+        for (let index = this.waiters.length - 1; index >= 0; index -= 1) {
+            const waiter = this.waiters[index];
             clearTimeout(waiter.timer);
             drain(waiter);
         }
+        this.waiters.length = 0;
     }
 }

package/dist/esm/transport/WaWebSocket.js

@@ -2,6 +2,45 @@ import { ConsoleLogger } from '../infra/log/ConsoleLogger.js';
 import { WA_DEFAULTS, WA_READY_STATES } from '../protocol/constants.js';
 import { TEXT_ENCODER, toBytesView } from '../util/bytes.js';
 import { toError } from '../util/primitives.js';
+const WS_OPTIONAL_MODULE = 'ws';
+function asOptionalNodeWsConstructor(loaded) {
+    if (loaded && typeof loaded === 'object') {
+        const direct = loaded.WebSocket;
+        if (typeof direct === 'function') {
+            return direct;
+        }
+        const fallback = loaded.default;
+        if (typeof fallback === 'function') {
+            return fallback;
+        }
+    }
+    if (typeof loaded === 'function') {
+        return loaded;
+    }
+    return null;
+}
+async function loadOptionalNodeWsConstructor() {
+    try {
+        const loaded = await import(WS_OPTIONAL_MODULE);
+        const constructor = asOptionalNodeWsConstructor(loaded);
+        if (constructor) {
+            return constructor;
+        }
+        throw new Error('invalid ws module export');
+    }
+    catch (error) {
+        const normalized = toError(error);
+        const code = normalized.code;
+        const message = normalized.message ?? '';
+        const isModuleNotFound = (code === 'ERR_MODULE_NOT_FOUND' || code === 'MODULE_NOT_FOUND') &&
+            (message.includes(`'${WS_OPTIONAL_MODULE}'`) ||
+                message.includes(`"${WS_OPTIONAL_MODULE}"`));
+        if (isModuleNotFound) {
+            throw new Error('optional dependency "ws" is not installed. Install with: npm i ws');
+        }
+        throw normalized;
+    }
+}
 function resolveWebSocketConstructor() {
     const ctor = globalThis
         .WebSocket;
@@ -13,12 +52,13 @@ function resolveWebSocketConstructor() {
 function resolveSocketUrls(config) {
     const preferredUrls = config.urls;
     if (preferredUrls && preferredUrls.length > 0) {
-        return Object.freeze(Array.from(new Set(preferredUrls)));
+        const unique = [];
+        for (const url of preferredUrls)
+            if (unique.indexOf(url) === -1)
+                unique.push(url);
+        return Object.freeze(unique);
     }
-    if (config.url) {
-        return Object.freeze([config.url]);
-    }
-    return WA_DEFAULTS.CHAT_SOCKET_URLS;
+    return config.url ? Object.freeze([config.url]) : WA_DEFAULTS.CHAT_SOCKET_URLS;
 }
 function resolveSocketRuntime() {
     const maybeNodeProcess = globalThis.process;
@@ -41,6 +81,7 @@ export class WaWebSocket {
         this.handlers = {};
         this.socket = null;
         this.closeWaiter = null;
+        this.nodeWsCtorPromise = null;
     }
     setHandlers(handlers) {
         this.handlers = handlers;
@@ -52,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');
@@ -144,7 +179,7 @@ export class WaWebSocket {
         socket.send(data);
     }
     async openSingle(url) {
-        const pending = this.createPendingSocket(url);
+        const pending = await this.createPendingSocket(url);
         return new Promise((resolve, reject) => {
             this.bindPendingSocket(pending, {
                 onOpen: () => {
@@ -166,7 +201,20 @@ export class WaWebSocket {
         });
     }
     async openConcurrently(urls) {
-        const pendingSockets = urls.map((url) => this.createPendingSocket(url));
+        const setupResults = await Promise.allSettled(urls.map((url) => this.createPendingSocket(url)));
+        const pendingSockets = [];
+        let setupError = null;
+        for (const result of setupResults) {
+            if (result.status === 'fulfilled') {
+                pendingSockets.push(result.value);
+                continue;
+            }
+            setupError = setupError ?? toError(result.reason);
+        }
+        if (setupError) {
+            this.releasePendingSocketsAfterSetupFailure(pendingSockets);
+            throw setupError;
+        }
         return new Promise((resolve, reject) => {
             let done = false;
             let failedCount = 0;
@@ -210,6 +258,14 @@ export class WaWebSocket {
             }
         });
     }
+    releasePendingSocketsAfterSetupFailure(entries) {
+        for (const entry of entries) {
+            if (!this.settlePendingSocket(entry)) {
+                continue;
+            }
+            this.closeSocketSafe(entry.socket, 1000, 'connect_setup_failed');
+        }
+    }
     bindRuntimeHandlers(socket) {
         socket.onmessage = (event) => {
             void this.handleMessage(event.data);
@@ -257,8 +313,8 @@ export class WaWebSocket {
         }
         return null;
     }
-    createPendingSocket(url) {
-        const socket = this.createRawSocket(url);
+    async createPendingSocket(url) {
+        const socket = await this.createRawSocket(url);
         socket.binaryType = 'arraybuffer';
         this.connectingSockets.add(socket);
         return {
@@ -351,11 +407,52 @@ export class WaWebSocket {
             // no-op
         }
     }
-    createRawSocket(url) {
+    async createRawSocket(url) {
         const headers = this.config.headers;
-        if (this.socketRuntime === 'node' && headers && Object.keys(headers).length > 0) {
-            return new this.webSocketCtor(url, this.config.protocols, { headers });
+        const dispatcher = this.config.dispatcher;
+        const agent = this.config.agent;
+        let hasHeaders = false;
+        if (headers) {
+            for (const key in headers) {
+                if (Object.prototype.hasOwnProperty.call(headers, key)) {
+                    hasHeaders = true;
+                    break;
+                }
+            }
+        }
+        if (this.socketRuntime === 'node' && agent) {
+            const nodeWsCtor = await this.resolveNodeWsConstructor();
+            return new nodeWsCtor(url, this.config.protocols, {
+                headers,
+                agent
+            });
+        }
+        if (this.socketRuntime === 'node' && (hasHeaders || dispatcher || agent)) {
+            const globalWebSocketCtor = globalThis.WebSocket;
+            if (globalWebSocketCtor && this.webSocketCtor === globalWebSocketCtor) {
+                const init = {
+                    protocols: this.config.protocols,
+                    headers,
+                    dispatcher,
+                    agent
+                };
+                return new this.webSocketCtor(url, init);
+            }
+            return new this.webSocketCtor(url, this.config.protocols, {
+                headers,
+                dispatcher,
+                agent
+            });
         }
         return new this.webSocketCtor(url, this.config.protocols);
     }
+    async resolveNodeWsConstructor() {
+        if (!this.nodeWsCtorPromise) {
+            this.nodeWsCtorPromise = loadOptionalNodeWsConstructor().catch((error) => {
+                this.nodeWsCtorPromise = null;
+                throw error;
+            });
+        }
+        return this.nodeWsCtorPromise;
+    }
 }

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