@violetix/baileys 0.5.0 → 0.5.1

package/lib/Defaults/index.d.ts

@@ -41,6 +41,11 @@ export namespace DEFAULT_CONNECTION_CONFIG {
     export let browser: any[];
     export let waWebSocketUrl: string;
     export let connectTimeoutMs: number;
+    export let closeTimeoutMs: number;
+    export let autoReconnect: boolean;
+    export let reconnectDelayMs: number;
+    export let maxReconnectDelayMs: number;
+    export let maxReconnectAttempts: number;
     export let keepAliveIntervalMs: number;
     export let logger: any;
     export let emitOwnEvents: boolean;

package/lib/Defaults/index.js

@@ -57,6 +57,14 @@ export const DEFAULT_CONNECTION_CONFIG = {
     browser: Browsers.macOS('Chrome'),
     waWebSocketUrl: 'wss://web.whatsapp.com/ws/chat',
     connectTimeoutMs: 20000,
+    // a half-open socket never answers close(); without a ceiling every reconnect leaks one
+    closeTimeoutMs: 5000,
+    // reconnect the transport in place instead of ending the socket, so a host that treats
+    // connection 'close' as "build a new socket" never runs two sockets for one account
+    autoReconnect: true,
+    reconnectDelayMs: 2000,
+    maxReconnectDelayMs: 60000,
+    maxReconnectAttempts: 10,
     keepAliveIntervalMs: 30000,
     keepAliveGracePeriodMs: 30000,
     logger: logger.child({ class: 'baileys' }),

package/lib/Socket/Client/websocket.js

@@ -35,16 +35,51 @@ export class WebSocketClient extends AbstractSocketClient {
             this.socket?.on(event, (...args) => this.emit(event, ...args));
         }
     }
+    /**
+     * Drop the raw socket and open a new one on the SAME emitter. Every stanza listener the layers
+     * above registered (messages-recv, chats, the host) stays attached, which is what makes a
+     * reconnect invisible to them. The noise session is rebuilt by the caller.
+     */
+    reconnect() {
+        const socket = this.socket;
+        this.socket = null;
+        if (socket) {
+            // remove the forwarders first: a late close from the old socket must not be reported
+            // as a close of the new one
+            socket.removeAllListeners();
+            try {
+                socket.terminate();
+            }
+            catch { }
+        }
+        this.connect();
+    }
     async close() {
         if (!this.socket) {
             return;
         }
+        const socket = this.socket;
+        // A half-open peer never answers the close handshake, so an unbounded wait here leaks one
+        // socket per reconnect. With a fleet that ends as FD exhaustion, so bound it and terminate.
+        const timeoutMs = this.config.closeTimeoutMs ?? 5000;
         const closePromise = new Promise(resolve => {
-            this.socket?.once('close', resolve);
-            this.socket?.once('error', resolve);
+            const timer = setTimeout(() => {
+                try {
+                    socket.terminate();
+                }
+                catch { }
+                resolve();
+            }, timeoutMs);
+            timer.unref?.();
+            const done = () => {
+                clearTimeout(timer);
+                resolve();
+            };
+            socket.once('close', done);
+            socket.once('error', done);
         });
         try {
-            this.socket.close();
+            socket.close();
         } catch { }
         await closePromise;
         this.socket = null;

package/lib/Socket/index.d.ts

@@ -875,6 +875,8 @@ declare function makeWASocket(config: import('../Types/Socket.js').SocketConfig)
     };
     signalRepository: any;
     user: any;
+    /** true while the transport is repairing itself; do not build a second socket for the account */
+    isReconnecting: boolean;
     generateMessageTag: () => string;
     /**
      * Drops matching inbound stanzas before any handler — including the decryption and
@@ -890,6 +892,7 @@ declare function makeWASocket(config: import('../Types/Socket.js').SocketConfig)
     logout: (msg: any) => Promise<void>;
     end: (error: any) => Promise<void>;
     registerSocketEndHandler: (handler: any) => void;
+    registerSocketReconnectHandler: (handler: any) => void;
     onUnexpectedError: (err: any, msg: any) => void;
     uploadPreKeys: (count?: number) => Promise<void>;
     uploadPreKeysToServerIfRequired: () => Promise<void>;

package/lib/Socket/messages-send.js

@@ -55,7 +55,7 @@ const getMediaTypeForGroupStatus = (media) => {
 export const makeMessagesSocket = (config) => {
     const { logger, linkPreviewImageThumbnailWidth, generateHighQualityLinkPreview, options: httpRequestOptions, patchMessageBeforeSending, cachedGroupMetadata, enableRecentMessageCache, maxMsgRetryCount } = config;
     const sock = makeNewsletterSocket(config);
-    const { ev, authState, messageMutex, signalRepository, upsertMessage, query, fetchPrivacySettings, sendNode, groupMetadata, groupToggleEphemeral, registerSocketEndHandler } = sock;
+    const { ev, authState, messageMutex, signalRepository, upsertMessage, query, fetchPrivacySettings, sendNode, groupMetadata, groupToggleEphemeral, registerSocketEndHandler, registerSocketReconnectHandler } = sock;
     /**
      * Echo a message we just sent back into our own store, off the send path.
      *
@@ -1242,6 +1242,10 @@ export const makeMessagesSocket = (config) => {
             messageRetryManager.clear();
         }
     });
+    // the media host auth token is bound to the connection that fetched it
+    registerSocketReconnectHandler?.(() => {
+        mediaConn = undefined;
+    });
     const socket = {
         ...sock,
         userDevicesCache,

package/lib/Socket/socket.js

@@ -27,6 +27,17 @@ import { executeWMexQuery } from './mex.js';
  * so a stale hardcoded version heals on the next reconnect instead of looping on 405.
  */
 let latestVersionOverride;
+/**
+ * Reasons that end a session for good. Reconnecting any of these is how an unattended host turns
+ * one logout into an auth loop and gets the number banned.
+ */
+const DEAD_DISCONNECT_REASONS = new Set([
+    DisconnectReason.loggedOut,
+    DisconnectReason.forbidden,
+    DisconnectReason.multideviceMismatch,
+    DisconnectReason.badSession,
+    DisconnectReason.connectionReplaced
+]);
 export const makeSocket = (config) => {
     const { waWebSocketUrl, connectTimeoutMs, logger, keepAliveIntervalMs, keepAliveGracePeriodMs, browser, auth: authState, printQRInTerminal, defaultQueryTimeoutMs, transactionOpts, qrTimeout, makeSignalRepository } = config;
     const publicWAMBuffer = new BinaryInfo();
@@ -52,9 +63,9 @@ export const makeSocket = (config) => {
         url.searchParams.append('ED', authState.creds.routingInfo.toString('base64url'));
     }
     /** ephemeral key pair used to encrypt/decrypt communication. Unique for each connection */
-    const ephemeralKeyPair = Curve.generateKeyPair();
+    let ephemeralKeyPair = Curve.generateKeyPair();
     /** WA noise protocol wrapper */
-    const noise = makeNoiseHandler({
+    let noise = makeNoiseHandler({
         keyPair: ephemeralKeyPair,
         NOISE_HEADER: NOISE_WA_HEADER,
         logger,
@@ -383,6 +394,11 @@ export const makeSocket = (config) => {
     let keepAliveReq;
     let qrTimer;
     let closed = false;
+    /** transparent transport reconnect state; see scheduleReconnect */
+    let reconnecting = false;
+    let reconnectAttempts = 0;
+    let reconnectTimer;
+    let reconnectWaitResolve;
     /** set once WhatsApp sends pair-device; requestPairingCode queues until then */
     let pairingReady = false;
     let pairingInProgress = false;
@@ -391,6 +407,8 @@ export const makeSocket = (config) => {
     let pendingPairingResolve;
     let pendingPairingReject;
     const socketEndHandlers = [];
+    /** per-connection caches (media host auth, ...) that must be dropped when the transport reopens */
+    const socketReconnectHandlers = [];
     const timers = new Set();
     const safeSetTimeout = (fn, ms) => { const id = setTimeout(fn, ms); timers.add(id); return id; };
     const safeSetInterval = (fn, ms) => { const id = setInterval(fn, ms); timers.add(id); return id; };
@@ -650,6 +668,9 @@ export const makeSocket = (config) => {
             keepAliveReq?.cancel();
             clearSafeTimer(qrTimer);
             clearAllTimers();
+            // release a pending reconnect wait so scheduleReconnect cannot stay suspended
+            reconnectWaitResolve?.();
+            reconnectWaitResolve = undefined;
             // a queued requestPairingCode would hang forever otherwise
             pairingReady = false;
             pairingInProgress = false;
@@ -693,6 +714,90 @@ export const makeSocket = (config) => {
             logger.error({ err }, 'error while closing connection');
         }
     };
+    /** rebuild the state that belongs to one transport connection, not to the socket object */
+    const resetTransport = () => {
+        keepAliveReq?.cancel();
+        keepAliveReq = undefined;
+        clearSafeTimer(qrTimer);
+        qrTimer = undefined;
+        lastDateRecv = undefined;
+        ephemeralKeyPair = Curve.generateKeyPair();
+        noise = makeNoiseHandler({
+            keyPair: ephemeralKeyPair,
+            NOISE_HEADER: NOISE_WA_HEADER,
+            logger,
+            routingInfo: authState?.creds?.routingInfo
+        });
+        // the media host token is issued per connection; a cached one fails every upload after this
+        for (const handler of socketReconnectHandlers) {
+            try {
+                handler();
+            }
+            catch (err) {
+                logger.error({ err }, 'error in socket reconnect handler');
+            }
+        }
+    };
+    /**
+     * Transparent reconnect. The WebSocket client object is kept and only the raw socket and the
+     * noise session under it are replaced, so every stanza listener registered by the layers above
+     * (messages-recv, chats, the host) keeps working and the host never sees a `close` for a drop
+     * that this socket can repair itself.
+     */
+    const scheduleReconnect = async (error) => {
+        if (reconnecting || closed) {
+            return;
+        }
+        reconnecting = true;
+        const statusCode = error?.output?.statusCode;
+        const maxAttempts = config.maxReconnectAttempts ?? 10;
+        if (!config.autoReconnect || DEAD_DISCONNECT_REASONS.has(statusCode) || reconnectAttempts >= maxAttempts) {
+            reconnecting = false;
+            return end(error);
+        }
+        reconnectAttempts += 1;
+        // 515 means the server wants the connection back now; backing off only delays it
+        const immediate = statusCode === DisconnectReason.restartRequired;
+        const base = config.reconnectDelayMs ?? 2000;
+        const ceiling = config.maxReconnectDelayMs ?? 60000;
+        const backoff = Math.min(ceiling, base * 2 ** (reconnectAttempts - 1));
+        // jitter keeps a fleet from reconnecting in lockstep after a server-side blip
+        const delayMs = immediate ? 0 : Math.round(backoff * (0.75 + Math.random() * 0.5));
+        logger.info({ statusCode, attempt: reconnectAttempts, delayMs }, 'connection lost, reconnecting');
+        // NOT 'close': a host reads close as "build a new socket", and a second socket for the same
+        // account is what earns a 440 connectionReplaced
+        ev.emit('connection.update', {
+            connection: 'connecting',
+            lastDisconnect: { error, date: new Date() }
+        });
+        await new Promise(resolve => {
+            reconnectWaitResolve = resolve;
+            reconnectTimer = safeSetTimeout(() => {
+                reconnectWaitResolve = undefined;
+                resolve();
+            }, delayMs);
+        });
+        reconnectTimer = undefined;
+        reconnecting = false;
+        if (closed) {
+            return;
+        }
+        try {
+            resetTransport();
+            ws.reconnect();
+        }
+        catch (err) {
+            logger.error({ err }, 'failed to reopen the transport');
+            return end(err);
+        }
+    };
+    /** single entry point for every transport-level close */
+    const handleDisconnect = (error) => {
+        if (closed) {
+            return;
+        }
+        return scheduleReconnect(error);
+    };
     const waitForSocketOpen = async () => {
         if (ws.isOpen) {
             return;
@@ -758,7 +863,7 @@ export const makeSocket = (config) => {
                 logger.warn({ lagMs, sinceLastRecvMs: sinceRecvMs }, 'event loop stalled; deferring keep-alive timeout');
             }
             if (sinceRecvMs > keepAliveIntervalMs + keepAliveGracePeriodMs && !loopStalled) {
-                void end(new Boom('Connection was lost', { statusCode: DisconnectReason.connectionLost }));
+                void handleDisconnect(new Boom('Connection was lost', { statusCode: DisconnectReason.connectionLost }));
                 return;
             }
             if (!ws.isOpen) {
@@ -988,13 +1093,13 @@ export const makeSocket = (config) => {
         }
         catch (err) {
             logger.error({ err }, 'error in validating connection');
-            void end(err);
+            void handleDisconnect(err);
         }
     });
-    ws.on('error', mapWebSocketError(end));
-    ws.on('close', () => void end(new Boom('Connection Terminated', { statusCode: DisconnectReason.connectionClosed })));
+    ws.on('error', mapWebSocketError(handleDisconnect));
+    ws.on('close', () => void handleDisconnect(new Boom('Connection Terminated', { statusCode: DisconnectReason.connectionClosed })));
     // the server terminated the connection
-    ws.on('CB:xmlstreamend', () => void end(new Boom('Connection Terminated by Server', { statusCode: DisconnectReason.connectionClosed })));
+    ws.on('CB:xmlstreamend', () => void handleDisconnect(new Boom('Connection Terminated by Server', { statusCode: DisconnectReason.connectionClosed })));
     // QR gen
     ws.on('CB:iq,type:set,pair-device', async (stanza) => {
         const iq = {
@@ -1059,6 +1164,9 @@ export const makeSocket = (config) => {
     });
     // login complete
     ws.on('CB:success', async (node) => {
+        // a completed handshake clears the reconnect budget: the next drop starts from the base delay
+        reconnectAttempts = 0;
+        reconnecting = false;
         try {
             updateServerTimeOffset(node);
             await uploadPreKeysToServerIfRequired();
@@ -1107,7 +1215,7 @@ export const makeSocket = (config) => {
         const [reasonNode] = getAllBinaryNodeChildren(node);
         logger.error({ reasonNode, fullErrorNode: node }, 'stream errored out');
         const { reason, statusCode } = getErrorCodeFromStreamError(node);
-        void end(new Boom(`Stream Errored (${reason})`, { statusCode, data: reasonNode || node }));
+        void handleDisconnect(new Boom(`Stream Errored (${reason})`, { statusCode, data: reasonNode || node }));
     });
     // stream fail, possible logout
     ws.on('CB:failure', async (node) => {
@@ -1123,10 +1231,10 @@ export const makeSocket = (config) => {
                 logger.warn({ err: latest.error?.message }, 'server rejected the client version as too old (405) and the latest version could not be fetched; pass a current `version`');
             }
         }
-        void end(new Boom('Connection Failure', { statusCode: reason, data: node.attrs }));
+        void handleDisconnect(new Boom('Connection Failure', { statusCode: reason, data: node.attrs }));
     });
     ws.on('CB:ib,,downgrade_webclient', () => {
-        void end(new Boom('Multi-device beta not joined', { statusCode: DisconnectReason.multideviceMismatch }));
+        void handleDisconnect(new Boom('Multi-device beta not joined', { statusCode: DisconnectReason.multideviceMismatch }));
     });
     // The server delivers the offline queue in windows and waits for another <offline_batch/>
     // before sending the next one. A single request only drained the first 100 stanzas, so a
@@ -1255,6 +1363,9 @@ export const makeSocket = (config) => {
     const registerSocketEndHandler = (handler) => {
         socketEndHandlers.push(handler);
     };
+    const registerSocketReconnectHandler = (handler) => {
+        socketReconnectHandlers.push(handler);
+    };
     /**
      * Fetches your account's standing when it comes to restrictions.
      * @returns Returns the state of the restrictions.
@@ -1287,6 +1398,14 @@ export const makeSocket = (config) => {
         get user() {
             return authState.creds.me;
         },
+        /**
+         * True while the transport is repairing itself. A host that reads this does not build a
+         * second socket for the same account, which is what a `ws.isOpen === false` check would
+         * make it do during the backoff window and the handshake that follows.
+         */
+        get isReconnecting() {
+            return reconnecting || (reconnectAttempts > 0 && !closed && !ws.isOpen);
+        },
         generateMessageTag,
         ignoreKey: ignoreKeyRegistry.register,
         query,
@@ -1297,6 +1416,7 @@ export const makeSocket = (config) => {
         logout,
         end,
         registerSocketEndHandler,
+        registerSocketReconnectHandler,
         onUnexpectedError,
         uploadPreKeys,
         uploadPreKeysToServerIfRequired,

package/lib/Utils/connection-manager.d.ts

@@ -0,0 +1,44 @@
+import { EventEmitter } from "events";
+import { Agent } from "https";
+export type ConnectionManagerSession = {
+    id: string;
+    [key: string]: any;
+};
+export type ConnectionManagerOptions = {
+    /** Build one socket for a session. Called again for every reconnect. */
+    create: (session: ConnectionManagerSession) => Promise<any> | any;
+    sessions?: ConnectionManagerSession[];
+    maxConcurrent?: number;
+    reconnect?: boolean;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+    maxAttempts?: number;
+    staggerMs?: number;
+    logger?: any;
+};
+export type ConnectionManagerStats = {
+    total: number;
+    idle: number;
+    connecting: number;
+    open: number;
+    reconnecting: number;
+    closed: number;
+    failed: number;
+    activeConnects: number;
+    queuedConnects: number;
+};
+export declare class ConnectionManager extends EventEmitter {
+    #private;
+    constructor(options: ConnectionManagerOptions);
+    start(): ConnectionManagerStats;
+    get(id: string): any | null;
+    stop(id: string): boolean;
+    close(): Promise<void>;
+    stats(): ConnectionManagerStats;
+}
+export declare const makeConnectionManager: (options: ConnectionManagerOptions) => ConnectionManager;
+export declare const makeWssAgent: (options?: {
+    maxSockets?: number;
+    keepAlive?: boolean;
+    keepAliveMsecs?: number;
+}) => Agent;

package/lib/Utils/connection-manager.js

@@ -0,0 +1,258 @@
+import { EventEmitter } from 'events';
+import { Agent } from 'https';
+import { DisconnectReason } from '../Types/index.js';
+/**
+ * Supervises a fleet of sockets inside one process.
+ *
+ * The library builds and tears down one socket; it deliberately does not reconnect, because only
+ * the host knows which auth state to reload. With hundreds of accounts that leaves three fleet-level
+ * problems to whoever wires them up, and getting them wrong is what makes accounts drop:
+ *
+ *  - every socket reconnecting the moment the server closes it, all at once, which hammers the
+ *    endpoint and gets throttled or banned (this is what `baseDelayMs` + jitter + stagger fix);
+ *  - a permanently dead session (401/403/411/440) being reconnected forever, which is the
+ *    documented path to a ban (this is what DEAD_REASONS stops);
+ *  - unbounded parallel connects, which exhausts FDs and TLS handshakes on boot.
+ *
+ * Events are deliberately never named 'error': EventEmitter throws on an unhandled 'error', and one
+ * dead session must not take the process down.
+ *
+ * ponytail: supervision only. Every socket still shares one event loop, so this bounds reconnect
+ * storms and socket leaks but not CPU-bound crypto; past a few hundred accounts, shard by process.
+ */
+const DEAD_REASONS = new Set([
+    DisconnectReason.loggedOut,
+    DisconnectReason.forbidden,
+    DisconnectReason.multideviceMismatch,
+    DisconnectReason.badSession,
+    DisconnectReason.connectionReplaced
+]);
+export class ConnectionManager extends EventEmitter {
+    #create;
+    #sessions = new Map();
+    #maxConcurrent;
+    #active = 0;
+    #waiters = [];
+    #reconnect;
+    #baseDelayMs;
+    #maxDelayMs;
+    #maxAttempts;
+    #staggerMs;
+    #logger;
+    #started = false;
+    constructor({ create, sessions = [], maxConcurrent = 8, reconnect = true, baseDelayMs = 2000, maxDelayMs = 60000, maxAttempts = Infinity, staggerMs = 250, logger = console }) {
+        super();
+        if (typeof create !== 'function') {
+            throw new TypeError('ConnectionManager needs a create(session) function');
+        }
+        for (const session of sessions) {
+            if (!session?.id) {
+                throw new TypeError('every session needs an id');
+            }
+            if (this.#sessions.has(session.id)) {
+                throw new TypeError(`duplicate session id: ${session.id}`);
+            }
+            this.#sessions.set(session.id, {
+                id: session.id,
+                session,
+                sock: null,
+                state: 'idle',
+                attempts: 0,
+                generation: 0,
+                timer: null,
+                stopped: false,
+                lastError: null
+            });
+        }
+        this.#create = create;
+        this.#maxConcurrent = Math.max(1, maxConcurrent);
+        this.#reconnect = reconnect;
+        this.#baseDelayMs = baseDelayMs;
+        this.#maxDelayMs = maxDelayMs;
+        this.#maxAttempts = maxAttempts;
+        this.#staggerMs = staggerMs;
+        this.#logger = logger;
+    }
+    /** Connect every session, staggered so boot does not fire them all in one tick. */
+    start() {
+        if (this.#started) {
+            return this.stats();
+        }
+        this.#started = true;
+        let index = 0;
+        for (const rec of this.#sessions.values()) {
+            const delayMs = this.#staggerMs * index++;
+            if (!delayMs) {
+                void this.#connect(rec);
+            }
+            else {
+                rec.timer = setTimeout(() => {
+                    rec.timer = null;
+                    void this.#connect(rec);
+                }, delayMs);
+            }
+        }
+        return this.stats();
+    }
+    get(id) {
+        return this.#sessions.get(id)?.sock ?? null;
+    }
+    /** Stop one session for good. A close event that arrives afterwards is ignored. */
+    stop(id) {
+        const rec = this.#sessions.get(id);
+        if (!rec) {
+            return false;
+        }
+        this.#stop(rec);
+        return true;
+    }
+    /** Stop everything and wait for each socket's teardown. */
+    async close() {
+        const pending = [];
+        for (const rec of this.#sessions.values()) {
+            const sock = this.#stop(rec);
+            if (sock) {
+                pending.push(Promise.resolve(sock.end?.(undefined)).catch(() => { }));
+            }
+        }
+        await Promise.all(pending);
+        this.#started = false;
+        this.removeAllListeners();
+    }
+    stats() {
+        const counts = { total: 0, idle: 0, connecting: 0, open: 0, reconnecting: 0, closed: 0, failed: 0 };
+        for (const rec of this.#sessions.values()) {
+            counts.total += 1;
+            counts[rec.state] += 1;
+        }
+        counts.activeConnects = this.#active;
+        counts.queuedConnects = this.#waiters.length;
+        return counts;
+    }
+    #stop(rec) {
+        rec.stopped = true;
+        rec.generation += 1;
+        if (rec.timer) {
+            clearTimeout(rec.timer);
+            rec.timer = null;
+        }
+        const sock = rec.sock;
+        rec.sock = null;
+        rec.state = 'closed';
+        return sock;
+    }
+    async #connect(rec) {
+        if (rec.stopped) {
+            return;
+        }
+        if (rec.timer) {
+            clearTimeout(rec.timer);
+            rec.timer = null;
+        }
+        const generation = ++rec.generation;
+        rec.state = 'connecting';
+        await this.#acquire();
+        let sock;
+        try {
+            sock = await this.#create(rec.session);
+        }
+        catch (err) {
+            this.#release();
+            rec.lastError = err;
+            this.emit('session-error', { id: rec.id, error: err });
+            this.#scheduleReconnect(rec, err);
+            return;
+        }
+        this.#release();
+        // stop() or a newer connect won the race while this one was being created
+        if (rec.stopped || generation !== rec.generation) {
+            void sock?.end?.(undefined);
+            return;
+        }
+        rec.sock = sock;
+        try {
+            sock.ev.on('connection.update', update => this.#onUpdate(rec, sock, update));
+        }
+        catch (err) {
+            rec.lastError = err;
+            this.emit('session-error', { id: rec.id, error: err });
+            this.#scheduleReconnect(rec, err);
+        }
+    }
+    #onUpdate(rec, sock, update) {
+        // a socket that was already replaced must not drive this session any more
+        if (rec.sock !== sock) {
+            return;
+        }
+        const { connection, lastDisconnect, qr } = update;
+        if (qr) {
+            this.emit('qr', { id: rec.id, qr });
+        }
+        if (connection === 'open') {
+            rec.state = 'open';
+            rec.attempts = 0;
+            rec.lastError = null;
+            this.emit('open', { id: rec.id, sock });
+        }
+        else if (connection === 'close') {
+            const error = lastDisconnect?.error;
+            rec.sock = null;
+            rec.lastError = error;
+            this.emit('close', { id: rec.id, error, statusCode: error?.output?.statusCode });
+            this.#scheduleReconnect(rec, error);
+        }
+    }
+    #scheduleReconnect(rec, error) {
+        if (!this.#reconnect || rec.stopped) {
+            rec.state = 'closed';
+            return;
+        }
+        const statusCode = error?.output?.statusCode;
+        if (DEAD_REASONS.has(statusCode) || rec.attempts >= this.#maxAttempts) {
+            rec.state = 'failed';
+            this.#logger?.warn?.({ id: rec.id, statusCode, attempts: rec.attempts }, 'session will not be reconnected');
+            this.emit('dead', { id: rec.id, error, statusCode });
+            return;
+        }
+        // the server asks for a restart on 515; backing off there only delays the reconnect
+        const immediate = statusCode === DisconnectReason.restartRequired;
+        const backoff = Math.min(this.#maxDelayMs, this.#baseDelayMs * 2 ** rec.attempts);
+        const delayMs = immediate ? 0 : Math.round(backoff * (0.75 + Math.random() * 0.5));
+        rec.attempts += 1;
+        rec.state = 'reconnecting';
+        this.emit('reconnect', { id: rec.id, attempt: rec.attempts, delayMs, statusCode });
+        rec.timer = setTimeout(() => {
+            rec.timer = null;
+            void this.#connect(rec);
+        }, delayMs);
+    }
+    #acquire() {
+        if (this.#active < this.#maxConcurrent) {
+            this.#active += 1;
+            return Promise.resolve();
+        }
+        return new Promise(resolve => this.#waiters.push(resolve));
+    }
+    #release() {
+        const next = this.#waiters.shift();
+        if (next) {
+            // hand the slot over without touching the counter
+            next();
+        }
+        else {
+            this.#active -= 1;
+        }
+    }
+}
+export const makeConnectionManager = (options) => new ConnectionManager(options);
+/**
+ * One TLS agent shared by every socket in the fleet. `ws` opens one TCP connection per socket, so
+ * this does not multiplex them, but it does keep the agent, its DNS cache and its free-socket pool
+ * shared instead of one per account.
+ */
+export const makeWssAgent = ({ maxSockets = 256, keepAlive = true, keepAliveMsecs = 30000 } = {}) => new Agent({
+    keepAlive,
+    keepAliveMsecs,
+    maxSockets,
+    maxFreeSockets: Math.min(32, maxSockets)
+});

package/lib/Utils/index.d.ts

@@ -24,6 +24,7 @@ export * from "./identity-change-handler.js";
 export * from "./stanza-ack.js";
 export * from "./ignore-key.js";
 export * from "./anchor-guard.js";
+export * from "./connection-manager.js";
 export * from "./a2ui.js";
 export * from "./meta-ai-msmsg.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/Utils/index.js

@@ -18,6 +18,7 @@ export * from './event-buffer.js';
 export * from './process-message.js';
 export * from './rich-message-utils.js';
 export * from './message-retry-manager.js';
+export * from './connection-manager.js';
 export * from './browser-utils.js';
 export * from './companion-reg-client-utils.js';
 export * from './identity-change-handler.js';

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@violetix/baileys",
-   "version": "0.5.0",
+   "version": "0.5.1",
    "description": "Enhanced Baileys v7 with fixes for newsletter media uploads, plus support for interactive messages, albums, and additional message types.",
    "main": "lib/index.js",
    "types": "lib/index.d.ts",