zapo-js 0.1.1 → 0.1.2

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

@@ -1,11 +1,21 @@
+import { signalAddressKey } from '../../../protocol/jid.js';
 import { decodeSignalPreKeyRow, decodeSignalRegistrationRow, decodeSignalRemoteIdentity, decodeSignalSessionRecord, decodeSignalSignedPreKeyRow, encodeSignalSessionRecord, toSignalAddressParts } from '../../../signal/store/sqlite.js';
 import { BaseSqliteStore } from '../../providers/sqlite/BaseSqliteStore.js';
 import { asNumber, asOptionalNumber, asString, toBoolOrUndef, resolvePositive } from '../../../util/coercion.js';
-import { signalAddressKey } from '../../../util/signal-address.js';
 const DEFAULTS = Object.freeze({
     preKeyBatchSize: 500,
     hasSessionBatchSize: 250
 });
+function repeatSqlToken(token, count, separator) {
+    if (count <= 1) {
+        return token;
+    }
+    let out = token;
+    for (let index = 1; index < count; index += 1) {
+        out += separator + token;
+    }
+    return out;
+}
 export class WaSignalSqliteStore extends BaseSqliteStore {
     constructor(options, storeOptions = {}) {
         super(options, ['signal']);
@@ -141,7 +151,7 @@ export class WaSignalSqliteStore extends BaseSqliteStore {
         for (let start = 0; start < uniqueKeyIds.length; start += this.preKeyBatchSize) {
             const end = Math.min(start + this.preKeyBatchSize, uniqueKeyIds.length);
             const batchLength = end - start;
-            const placeholders = new Array(batchLength).fill('?').join(', ');
+            const placeholders = repeatSqlToken('?', batchLength, ', ');
             const params = [this.options.sessionId];
             for (let index = start; index < end; index += 1) {
                 params.push(uniqueKeyIds[index]);
@@ -213,9 +223,7 @@ export class WaSignalSqliteStore extends BaseSqliteStore {
         for (let start = 0; start < targets.length; start += this.hasSessionBatchSize) {
             const end = Math.min(start + this.hasSessionBatchSize, targets.length);
             const batchLength = end - start;
-            const filters = new Array(batchLength)
-                .fill('(user = ? AND server = ? AND device = ?)')
-                .join(' OR ');
+            const filters = repeatSqlToken('(user = ? AND server = ? AND device = ?)', batchLength, ' OR ');
             const params = [this.options.sessionId];
             for (let index = start; index < end; index += 1) {
                 const target = targets[index];
@@ -232,7 +240,7 @@ export class WaSignalSqliteStore extends BaseSqliteStore {
                 }));
             }
         }
-        return addresses.map((address) => existingKeys.has(signalAddressKey(address)));
+        return targets.map((target) => existingKeys.has(signalAddressKey(target)));
     }
     async getSession(address) {
         const db = await this.getConnection();
@@ -242,24 +250,50 @@ export class WaSignalSqliteStore extends BaseSqliteStore {
              WHERE session_id = ? AND user = ? AND server = ? AND device = ?`, [this.options.sessionId, target.user, target.server, target.device]);
         return row ? decodeSignalSessionRecord(row.record) : null;
     }
+    async getSessionsBatch(addresses) {
+        if (addresses.length === 0) {
+            return [];
+        }
+        const db = await this.getConnection();
+        const targets = addresses.map((address) => toSignalAddressParts(address));
+        const byAddressKey = new Map();
+        for (let start = 0; start < targets.length; start += this.hasSessionBatchSize) {
+            const end = Math.min(start + this.hasSessionBatchSize, targets.length);
+            const batchLength = end - start;
+            const filters = repeatSqlToken('(user = ? AND server = ? AND device = ?)', batchLength, ' OR ');
+            const params = [this.options.sessionId];
+            for (let index = start; index < end; index += 1) {
+                const target = targets[index];
+                params.push(target.user, target.server, target.device);
+            }
+            const rows = db.all(`SELECT user, server, device, record
+                 FROM signal_session
+                 WHERE session_id = ? AND (${filters})`, params);
+            for (const row of rows) {
+                byAddressKey.set(signalAddressKey({
+                    user: asString(row.user, 'signal_session.user'),
+                    server: asString(row.server, 'signal_session.server'),
+                    device: asNumber(row.device, 'signal_session.device')
+                }), decodeSignalSessionRecord(row.record));
+            }
+        }
+        return targets.map((target) => byAddressKey.get(signalAddressKey(target)) ?? null);
+    }
     async setSession(address, session) {
         const db = await this.getConnection();
         const target = toSignalAddressParts(address);
-        db.run(`INSERT INTO signal_session (
-                session_id,
-                user,
-                server,
-                device,
-                record
-            ) VALUES (?, ?, ?, ?, ?)
-            ON CONFLICT(session_id, user, server, device) DO UPDATE SET
-                record=excluded.record`, [
-            this.options.sessionId,
-            target.user,
-            target.server,
-            target.device,
-            encodeSignalSessionRecord(session)
-        ]);
+        this.upsertSession(db, target, session);
+    }
+    async setSessionsBatch(entries) {
+        if (entries.length === 0) {
+            return;
+        }
+        await this.withTransaction((db) => {
+            for (let index = 0; index < entries.length; index += 1) {
+                const entry = entries[index];
+                this.upsertSession(db, toSignalAddressParts(entry.address), entry.session);
+            }
+        });
     }
     async deleteSession(address) {
         const db = await this.getConnection();
@@ -275,6 +309,35 @@ export class WaSignalSqliteStore extends BaseSqliteStore {
              WHERE session_id = ? AND user = ? AND server = ? AND device = ?`, [this.options.sessionId, target.user, target.server, target.device]);
         return row ? decodeSignalRemoteIdentity(row.identity_key) : null;
     }
+    async getRemoteIdentities(addresses) {
+        if (addresses.length === 0) {
+            return [];
+        }
+        const db = await this.getConnection();
+        const targets = addresses.map((address) => toSignalAddressParts(address));
+        const byAddressKey = new Map();
+        for (let start = 0; start < targets.length; start += this.hasSessionBatchSize) {
+            const end = Math.min(start + this.hasSessionBatchSize, targets.length);
+            const batchLength = end - start;
+            const filters = repeatSqlToken('(user = ? AND server = ? AND device = ?)', batchLength, ' OR ');
+            const params = [this.options.sessionId];
+            for (let index = start; index < end; index += 1) {
+                const target = targets[index];
+                params.push(target.user, target.server, target.device);
+            }
+            const rows = db.all(`SELECT user, server, device, identity_key
+                 FROM signal_identity
+                 WHERE session_id = ? AND (${filters})`, params);
+            for (const row of rows) {
+                byAddressKey.set(signalAddressKey({
+                    user: asString(row.user, 'signal_identity.user'),
+                    server: asString(row.server, 'signal_identity.server'),
+                    device: asNumber(row.device, 'signal_identity.device')
+                }), decodeSignalRemoteIdentity(row.identity_key));
+            }
+        }
+        return targets.map((target) => byAddressKey.get(signalAddressKey(target)) ?? null);
+    }
     async setRemoteIdentity(address, identityKey) {
         const db = await this.getConnection();
         const target = toSignalAddressParts(address);
@@ -294,7 +357,9 @@ export class WaSignalSqliteStore extends BaseSqliteStore {
     async clear() {
         await this.withTransaction((db) => {
             db.run('DELETE FROM signal_registration WHERE session_id = ?', [this.options.sessionId]);
-            db.run('DELETE FROM signal_signed_prekey WHERE session_id = ?', [this.options.sessionId]);
+            db.run('DELETE FROM signal_signed_prekey WHERE session_id = ?', [
+                this.options.sessionId
+            ]);
             db.run('DELETE FROM signal_prekey WHERE session_id = ?', [this.options.sessionId]);
             db.run('DELETE FROM signal_session WHERE session_id = ?', [this.options.sessionId]);
             db.run('DELETE FROM signal_identity WHERE session_id = ?', [this.options.sessionId]);
@@ -320,6 +385,23 @@ export class WaSignalSqliteStore extends BaseSqliteStore {
             record.uploaded === true ? 1 : 0
         ]);
     }
+    upsertSession(db, target, session) {
+        db.run(`INSERT INTO signal_session (
+                session_id,
+                user,
+                server,
+                device,
+                record
+            ) VALUES (?, ?, ?, ?, ?)
+            ON CONFLICT(session_id, user, server, device) DO UPDATE SET
+                record=excluded.record`, [
+            this.options.sessionId,
+            target.user,
+            target.server,
+            target.device,
+            encodeSignalSessionRecord(session)
+        ]);
+    }
     ensureMetaRow(db) {
         db.run(`INSERT INTO signal_meta (
                 session_id,

package/dist/esm/store/providers/sqlite/table-names.js

@@ -0,0 +1,107 @@
+const SQLITE_TABLE_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const WA_SQLITE_TABLE_NAME_ORDER = Object.freeze([
+    'wa_migrations',
+    'auth_credentials',
+    'signal_meta',
+    'signal_registration',
+    'signal_signed_prekey',
+    'signal_prekey',
+    'signal_session',
+    'signal_identity',
+    'sender_keys',
+    'sender_key_distribution',
+    'appstate_sync_keys',
+    'appstate_collection_versions',
+    'appstate_collection_index_values',
+    'retry_outbound_messages',
+    'retry_inbound_counters',
+    'mailbox_messages',
+    'mailbox_threads',
+    'mailbox_contacts',
+    'group_participants_cache',
+    'device_list_cache'
+]);
+const WA_SQLITE_ALLOWED_TABLE_NAME_SET = new Set(WA_SQLITE_TABLE_NAME_ORDER);
+const WA_SQLITE_ALLOWED_TABLE_NAME_LIST = WA_SQLITE_TABLE_NAME_ORDER.join(', ');
+export const WA_SQLITE_DEFAULT_TABLE_NAMES = Object.freeze({
+    wa_migrations: 'wa_migrations',
+    auth_credentials: 'auth_credentials',
+    signal_meta: 'signal_meta',
+    signal_registration: 'signal_registration',
+    signal_signed_prekey: 'signal_signed_prekey',
+    signal_prekey: 'signal_prekey',
+    signal_session: 'signal_session',
+    signal_identity: 'signal_identity',
+    sender_keys: 'sender_keys',
+    sender_key_distribution: 'sender_key_distribution',
+    appstate_sync_keys: 'appstate_sync_keys',
+    appstate_collection_versions: 'appstate_collection_versions',
+    appstate_collection_index_values: 'appstate_collection_index_values',
+    retry_outbound_messages: 'retry_outbound_messages',
+    retry_inbound_counters: 'retry_inbound_counters',
+    mailbox_messages: 'mailbox_messages',
+    mailbox_threads: 'mailbox_threads',
+    mailbox_contacts: 'mailbox_contacts',
+    group_participants_cache: 'group_participants_cache',
+    device_list_cache: 'device_list_cache'
+});
+const DEFAULT_SQLITE_TABLE_NAME_SERIALIZATION = serializeSqliteTableNames(WA_SQLITE_DEFAULT_TABLE_NAMES);
+function normalizeTableName(table, rawValue) {
+    const value = rawValue.trim();
+    if (value.length === 0) {
+        throw new Error(`sqlite tableNames.${table} must be a non-empty string`);
+    }
+    if (!SQLITE_TABLE_NAME_PATTERN.test(value)) {
+        throw new Error(`sqlite tableNames.${table} must match ${SQLITE_TABLE_NAME_PATTERN.toString()}`);
+    }
+    return value;
+}
+function assertNoDuplicateTableNames(tableNames) {
+    const seen = new Set();
+    for (const table of WA_SQLITE_TABLE_NAME_ORDER) {
+        const mapped = tableNames[table];
+        const normalizedMapped = mapped.toLowerCase();
+        if (seen.has(normalizedMapped)) {
+            throw new Error(`sqlite tableNames contains duplicate target "${mapped}"`);
+        }
+        seen.add(normalizedMapped);
+    }
+}
+export function resolveSqliteTableNames(overrides) {
+    if (!overrides) {
+        return WA_SQLITE_DEFAULT_TABLE_NAMES;
+    }
+    const entries = Object.entries(overrides);
+    if (entries.length === 0) {
+        return WA_SQLITE_DEFAULT_TABLE_NAMES;
+    }
+    const resolved = {
+        ...WA_SQLITE_DEFAULT_TABLE_NAMES
+    };
+    for (const [table, rawName] of entries) {
+        if (!WA_SQLITE_ALLOWED_TABLE_NAME_SET.has(table)) {
+            throw new Error(`unsupported sqlite tableNames key "${table}". Allowed table names: ${WA_SQLITE_ALLOWED_TABLE_NAME_LIST}`);
+        }
+        if (typeof rawName !== 'string') {
+            throw new Error(`sqlite tableNames.${table} must be a string`);
+        }
+        const tableName = table;
+        resolved[tableName] = normalizeTableName(tableName, rawName);
+    }
+    assertNoDuplicateTableNames(resolved);
+    return Object.freeze(resolved);
+}
+export function serializeSqliteTableNames(tableNames) {
+    return WA_SQLITE_TABLE_NAME_ORDER.map((table) => `${table}=${tableNames[table]}`).join(';');
+}
+function escapeRegexToken(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+export function createSqliteTableNameSqlResolver(tableNames) {
+    const serialized = serializeSqliteTableNames(tableNames);
+    if (serialized === DEFAULT_SQLITE_TABLE_NAME_SERIALIZATION) {
+        return (sql) => sql;
+    }
+    const pattern = new RegExp(`\\b(?:${WA_SQLITE_TABLE_NAME_ORDER.map(escapeRegexToken).join('|')})\\b`, 'g');
+    return (sql) => sql.replace(pattern, (token) => tableNames[token] ?? token);
+}

package/dist/esm/store/providers/sqlite/thread.store.js

@@ -20,28 +20,17 @@ export class WaThreadSqliteStore extends BaseSqliteStore {
     }
     async upsert(record) {
         const db = await this.getConnection();
-        db.run(`INSERT INTO mailbox_threads (
-                session_id, jid, name, unread_count, archived, pinned,
-                mute_end_ms, marked_as_unread, ephemeral_expiration
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-            ON CONFLICT(session_id, jid) DO UPDATE SET
-                name=COALESCE(excluded.name, mailbox_threads.name),
-                unread_count=COALESCE(excluded.unread_count, mailbox_threads.unread_count),
-                archived=COALESCE(excluded.archived, mailbox_threads.archived),
-                pinned=COALESCE(excluded.pinned, mailbox_threads.pinned),
-                mute_end_ms=COALESCE(excluded.mute_end_ms, mailbox_threads.mute_end_ms),
-                marked_as_unread=COALESCE(excluded.marked_as_unread, mailbox_threads.marked_as_unread),
-                ephemeral_expiration=COALESCE(excluded.ephemeral_expiration, mailbox_threads.ephemeral_expiration)`, [
-            this.options.sessionId,
-            record.jid,
-            record.name ?? null,
-            record.unreadCount ?? null,
-            record.archived === undefined ? null : record.archived ? 1 : 0,
-            record.pinned ?? null,
-            record.muteEndMs ?? null,
-            record.markedAsUnread === undefined ? null : record.markedAsUnread ? 1 : 0,
-            record.ephemeralExpiration ?? null
-        ]);
+        this.upsertThreadRow(db, record);
+    }
+    async upsertBatch(records) {
+        if (records.length === 0) {
+            return;
+        }
+        await this.withTransaction((db) => {
+            for (const record of records) {
+                this.upsertThreadRow(db, record);
+            }
+        });
     }
     async getByJid(jid) {
         const db = await this.getConnection();
@@ -69,4 +58,28 @@ export class WaThreadSqliteStore extends BaseSqliteStore {
         const db = await this.getConnection();
         db.run('DELETE FROM mailbox_threads WHERE session_id = ?', [this.options.sessionId]);
     }
+    upsertThreadRow(db, record) {
+        db.run(`INSERT INTO mailbox_threads (
+                session_id, jid, name, unread_count, archived, pinned,
+                mute_end_ms, marked_as_unread, ephemeral_expiration
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT(session_id, jid) DO UPDATE SET
+                name=COALESCE(excluded.name, mailbox_threads.name),
+                unread_count=COALESCE(excluded.unread_count, mailbox_threads.unread_count),
+                archived=COALESCE(excluded.archived, mailbox_threads.archived),
+                pinned=COALESCE(excluded.pinned, mailbox_threads.pinned),
+                mute_end_ms=COALESCE(excluded.mute_end_ms, mailbox_threads.mute_end_ms),
+                marked_as_unread=COALESCE(excluded.marked_as_unread, mailbox_threads.marked_as_unread),
+                ephemeral_expiration=COALESCE(excluded.ephemeral_expiration, mailbox_threads.ephemeral_expiration)`, [
+            this.options.sessionId,
+            record.jid,
+            record.name ?? null,
+            record.unreadCount ?? null,
+            record.archived === undefined ? null : record.archived ? 1 : 0,
+            record.pinned ?? null,
+            record.muteEndMs ?? null,
+            record.markedAsUnread === undefined ? null : record.markedAsUnread ? 1 : 0,
+            record.ephemeralExpiration ?? 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) {
@@ -423,20 +421,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 +457,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 +519,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)));
-    }
-    if (config.url) {
-        return Object.freeze([config.url]);
+        const unique = [];
+        for (const url of preferredUrls)
+            if (unique.indexOf(url) === -1)
+                unique.push(url);
+        return Object.freeze(unique);
     }
-    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;
@@ -144,7 +185,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 +207,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 +264,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 +319,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 +413,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/decoder.js

@@ -238,10 +238,10 @@ function decodeNodeInternal(reader) {
             }
         }
     }
-    if (content === null || content === undefined) {
-        return { tag: tagValue, attrs };
-    }
-    return { tag: tagValue, attrs, content };
+    const node = content === null || content === undefined
+        ? { tag: tagValue, attrs }
+        : { tag: tagValue, attrs, content };
+    return node;
 }
 export function decodeBinaryNode(data) {
     const reader = new ByteReader(data);