libzapitu 1.0.0-alpha.20 → 1.0.0-alpha.22

package/lib/Socket/chats.js

@@ -740,7 +740,7 @@ const makeChatsSocket = (config) => {
         }
         const historyMsg = (0, Utils_1.getHistoryMsg)(msg.message);
         const shouldProcessHistoryMsg = historyMsg
-            ? shouldSyncHistoryMessage(historyMsg) && Defaults_1.PROCESSABLE_HISTORY_TYPES.includes(historyMsg.syncType)
+            ? (await shouldSyncHistoryMessage(historyMsg)) && Defaults_1.PROCESSABLE_HISTORY_TYPES.includes(historyMsg.syncType)
             : false;
         if (historyMsg && !authState.creds.myAppStateKeyId) {
             logger.warn('skipping app state sync, as myAppStateKeyId is not set');

package/lib/Socket/messages-recv.js

@@ -542,7 +542,7 @@ const makeMessagesRecvSocket = (config) => {
             fromMe,
             participant: attrs.participant
         };
-        if (remoteJid && shouldIgnoreJid(remoteJid) && remoteJid !== '@s.whatsapp.net') {
+        if (remoteJid && (await shouldIgnoreJid(remoteJid)) && remoteJid !== '@s.whatsapp.net') {
             logger.debug({ remoteJid }, 'ignoring receipt from jid');
             await sendMessageAck(node);
             return;
@@ -610,7 +610,7 @@ const makeMessagesRecvSocket = (config) => {
     };
     const handleNotification = async (node) => {
         const remoteJid = node.attrs.from;
-        if (shouldIgnoreJid(remoteJid) && remoteJid !== '@s.whatsapp.net') {
+        if ((await shouldIgnoreJid(remoteJid)) && remoteJid !== '@s.whatsapp.net') {
             logger.debug({ remoteJid, id: node.attrs.id }, 'ignored notification');
             await sendMessageAck(node);
             return;
@@ -643,7 +643,7 @@ const makeMessagesRecvSocket = (config) => {
     };
     const handleMessage = async (node) => {
         var _a, _b, _c, _d, _e;
-        if (shouldIgnoreJid(node.attrs.from) && node.attrs.from !== '@s.whatsapp.net') {
+        if ((await shouldIgnoreJid(node.attrs.from)) && node.attrs.from !== '@s.whatsapp.net') {
             logger.debug({ key: node.attrs.key }, 'ignored message');
             await sendMessageAck(node);
             return;
@@ -1165,12 +1165,12 @@ const makeMessagesRecvSocket = (config) => {
             }
         }
     };
-    const handlePresenceUpdate = ({ tag, attrs, content }) => {
+    const handlePresenceUpdate = async ({ tag, attrs, content }) => {
         var _a;
         let presence;
         const jid = attrs.from;
         const participant = attrs.participant || attrs.from;
-        if (shouldIgnoreJid(jid)) {
+        if (await shouldIgnoreJid(jid)) {
             return;
         }
         if (tag === 'presence') {

package/lib/Types/Socket.d.ts

@@ -62,7 +62,7 @@ export type SocketConfig = {
     /** provide an auth state object to maintain the auth state */
     auth: AuthenticationState;
     /** manage history processing with this control; by default will sync up everything */
-    shouldSyncHistoryMessage: (msg: proto.Message.IHistorySyncNotification) => boolean;
+    shouldSyncHistoryMessage: (msg: proto.Message.IHistorySyncNotification) => boolean | Promise<boolean>;
     /** transaction capability options for SignalKeyStore */
     transactionOpts: TransactionCapabilityOptions;
     /** marks the client as online whenever the socket successfully connects */
@@ -95,9 +95,10 @@ export type SocketConfig = {
     /**
      * Returns if a jid should be ignored,
      * no event for that jid will be triggered.
-     * Messages from that jid will also not be decrypted
+     * Messages from that jid will also not be decrypted.
+     * May return a boolean or a Promise resolving to a boolean.
      * */
-    shouldIgnoreJid: (jid: string) => boolean | undefined;
+    shouldIgnoreJid: (jid: string) => boolean | undefined | Promise<boolean | undefined>;
     /**
      * Optionally patch the message before sending out
      * */

package/lib/Utils/logger.js

@@ -4,4 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const pino_1 = __importDefault(require("pino"));
-exports.default = (0, pino_1.default)({ timestamp: () => `,"time":"${new Date().toJSON()}"` });
+exports.default = (0, pino_1.default)({
+    timestamp: () => `,"time":"${new Date().toJSON()}"`,
+    level: process.env.BAILEYS_LOG_LEVEL || 'info'
+});

package/lib/worker/child.js

@@ -12,8 +12,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * by a unique `socketId` sent in the `init` message from the parent.
  */
 const worker_threads_1 = require("worker_threads");
+const node_cache_1 = __importDefault(require("@cacheable/node-cache"));
 const Socket_1 = __importDefault(require("../Socket"));
-const pino_1 = __importDefault(require("pino"));
+const libsignal_1 = require("../Signal/libsignal");
+const logger_1 = __importDefault(require("../Utils/logger"));
 // ---------------------------------------------------------------------------
 // Ensure we never run this in the main thread
 // ---------------------------------------------------------------------------
@@ -28,8 +30,7 @@ const CALLBACK_PROXIED_KEYS = [
     'shouldIgnoreJid',
     'patchMessageBeforeSending',
     'cachedGroupMetadata',
-    'shouldSyncHistoryMessage',
-    'makeSignalRepository',
+    'shouldSyncHistoryMessage'
 ];
 const sockets = new Map();
 let _reqId = 0;
@@ -44,7 +45,7 @@ function createNoopLogger() {
         debug: noop,
         info: noop,
         warn: noop,
-        error: noop,
+        error: noop
     };
 }
 // ---------------------------------------------------------------------------
@@ -136,11 +137,10 @@ function createSocket(socketId, rawConfig) {
     const config = reviveBuffers(rawConfig);
     // The proxy replaces the logger with a sentinel string because functions
     // can't be serialized across postMessage. Create a real logger here.
-    // Use a basic pino logger so the real makeWASocket has a working logger.
+    // Use the default logger (level controlled by BAILEYS_LOG_LEVEL) so the
+    // real makeWASocket has a working logger.
     const hasLogger = config.logger === '__proxy_logger__';
-    const realLogger = hasLogger
-        ? (0, pino_1.default)({ timestamp: () => `,"time":"${new Date().toJSON()}"` }).child({ worker: 'child', socketId })
-        : createNoopLogger();
+    const realLogger = hasLogger ? logger_1.default.child({ worker: 'child', socketId }) : createNoopLogger();
     config.logger = realLogger;
     // Create a child logger for our own worker-level logging
     const log = realLogger.child({ component: 'worker-bridge' });
@@ -152,6 +152,13 @@ function createSocket(socketId, rawConfig) {
             config[k] = (...args) => proxyCallback(socketId, k, log, ...args);
         }
     }
+    // Recreate the signal repository inside the worker. The repository object
+    // contains closures and methods that cannot cross postMessage, so the parent
+    // sends a sentinel instead of proxying the factory.
+    if (config.makeSignalRepository === '__worker_signal_repository__') {
+        ;
+        config.makeSignalRepository = libsignal_1.makeLibSignalRepository;
+    }
     // Replace sentinel keystore with forwarding stubs
     if (((_a = config.auth) === null || _a === void 0 ? void 0 : _a.keys) === '__proxy_keystore__') {
         const keystoreMethods = ['get', 'set', 'clear', 'isInTransaction', 'transaction'];
@@ -162,8 +169,60 @@ function createSocket(socketId, rawConfig) {
         ;
         config.auth.keys = stub;
     }
+    // Replace worker-local cache sentinels with real cache instances.
+    // The parent's cache cannot be cloned (methods live on prototype).
+    const cacheKeys = [
+        'msgRetryCounterCache',
+        'mediaCache',
+        'userDevicesCache',
+        'callOfferCache',
+        'placeholderResendCache'
+    ];
+    for (const k of cacheKeys) {
+        if (config[k] === '__worker_cache__') {
+            ;
+            config[k] = new node_cache_1.default({ useClones: false });
+        }
+    }
     const sock = (0, Socket_1.default)(config);
     log.info('socket created successfully');
+    // Send user and authState to the parent when they become available.
+    // These are needed for wsocket.user and wsocket.authState on the proxy side.
+    const sendSocketInfo = () => {
+        try {
+            const info = {};
+            if (sock.user)
+                info.user = sock.user;
+            if (sock.authState)
+                info.authState = sock.authState;
+            if (Object.keys(info).length > 0) {
+                worker_threads_1.parentPort.postMessage({ type: 'socket-info', socketId, info });
+            }
+        }
+        catch (_) {
+            /* best-effort */
+        }
+    };
+    // Send immediately (may be empty) and also on connection.open.
+    // IMPORTANT: we send socket-info synchronously in the connection.update
+    // listener so it arrives at the parent BEFORE the forwarded event.
+    // Otherwise wsocket.user would be undefined when the parent's
+    // connection.update handler runs.
+    sendSocketInfo();
+    sock.ev.on('connection.update', (update) => {
+        if ((update === null || update === void 0 ? void 0 : update.connection) === 'open') {
+            sendSocketInfo();
+        }
+        // When the socket closes, clean up this socket entry so a new
+        // init with a different socketId can reuse this worker.
+        if ((update === null || update === void 0 ? void 0 : update.connection) === 'close') {
+            const entry = sockets.get(socketId);
+            if (entry) {
+                log.info('socket closed — removing from worker');
+                sockets.delete(socketId);
+            }
+        }
+    });
     sock.ev.on('event', (map) => {
         log.trace({ eventKeys: Object.keys(map) }, 'event → parent');
         try {
@@ -181,6 +240,23 @@ function createSocket(socketId, rawConfig) {
             }
         }
     });
+    // Forward raw WS events to the parent so ws.on() works on the proxy side.
+    // We forward all events by monkey-patching sock.ws.emit.
+    const ws = sock.ws;
+    if (ws) {
+        const origEmit = ws.emit.bind(ws);
+        ws.emit = (event, ...args) => {
+            // Forward to parent first (best-effort, non-cloneable data is dropped)
+            try {
+                worker_threads_1.parentPort.postMessage({ type: 'ws-event', socketId, event, args });
+            }
+            catch (_) {
+                // silently drop — ws events with non-cloneable data are rare
+            }
+            // Then call the original emit so local listeners still work
+            return origEmit(event, ...args);
+        };
+    }
     sockets.set(socketId, { sock, config, log });
 }
 // ---------------------------------------------------------------------------
@@ -210,7 +286,7 @@ worker_threads_1.parentPort.on('message', async (msg) => {
                     type: 'result',
                     socketId,
                     id,
-                    error: `Socket ${socketId} not found`,
+                    error: `Socket ${socketId} not found`
                 });
                 return;
             }
@@ -242,7 +318,7 @@ worker_threads_1.parentPort.on('message', async (msg) => {
                     type: 'result',
                     socketId,
                     id,
-                    error: (err === null || err === void 0 ? void 0 : err.message) || String(err),
+                    error: (err === null || err === void 0 ? void 0 : err.message) || String(err)
                 });
             }
             break;

package/lib/worker/proxy.js

@@ -36,9 +36,21 @@ const CALLBACK_CONFIG_KEYS = [
     'shouldIgnoreJid',
     'patchMessageBeforeSending',
     'cachedGroupMetadata',
-    'shouldSyncHistoryMessage',
-    'makeSignalRepository',
+    'shouldSyncHistoryMessage'
 ];
+/**
+ * Cache stores that live inside the worker thread. They cannot be safely
+ * cloned via postMessage because their methods live on the prototype, so we
+ * replace them with a sentinel and recreate a fresh NodeCache in the worker.
+ */
+const CACHE_CONFIG_KEYS = [
+    'msgRetryCounterCache',
+    'mediaCache',
+    'userDevicesCache',
+    'callOfferCache',
+    'placeholderResendCache'
+];
+const CACHE_SENTINEL = '__worker_cache__';
 // ---------------------------------------------------------------------------
 // Globals
 // ---------------------------------------------------------------------------
@@ -69,12 +81,16 @@ function createNoopLogger() {
         debug: noop,
         info: noop,
         warn: noop,
-        error: noop,
+        error: noop
     };
 }
 /**
  * Recursively revive objects that were sanitized by the child's
  * sanitizeForPostMessage (e.g. Error sentinels).
+ *
+ * IMPORTANT: structured clone already produces a perfect copy of the data.
+ * We only need to recursively look for __error__ sentinels and convert
+ * them back to Error instances. Everything else passes through unchanged.
  */
 function revivePostMessage(value) {
     if (value !== null && typeof value === 'object') {
@@ -85,13 +101,30 @@ function revivePostMessage(value) {
             return err;
         }
         if (Array.isArray(value)) {
-            return value.map(revivePostMessage);
+            // Arrays: recurse to revive any Error sentinels inside
+            let hasError = false;
+            const result = value.map(v => {
+                const revived = revivePostMessage(v);
+                if (revived !== v)
+                    hasError = true;
+                return revived;
+            });
+            return hasError ? result : value;
         }
-        const result = {};
-        for (const key of Object.keys(value)) {
-            result[key] = revivePostMessage(value[key]);
+        // Plain objects: only recurse if they might contain __error__ sentinels.
+        // Check one level deep to avoid unnecessary cloning of large objects.
+        if (value.constructor === Object || value.constructor === undefined) {
+            let changed = false;
+            const result = {};
+            for (const key of Object.keys(value)) {
+                const orig = value[key];
+                const revived = revivePostMessage(orig);
+                if (revived !== orig)
+                    changed = true;
+                result[key] = revived;
+            }
+            return changed ? result : value;
         }
-        return result;
     }
     return value;
 }
@@ -104,7 +137,7 @@ function getStats() {
         size: slots.length,
         active,
         idle: slots.length - active,
-        totalSockets: slots.reduce((sum, s) => sum + s.load, 0),
+        totalSockets: slots.reduce((sum, s) => sum + s.load, 0)
     };
 }
 /**
@@ -131,19 +164,23 @@ function acquireSlot() {
 }
 function spawnWorker() {
     const worker = new worker_threads_1.Worker(workerScript, {
-        execArgv: workerExecArgv ? [...workerExecArgv] : undefined,
+        execArgv: workerExecArgv ? [...workerExecArgv] : undefined
     });
     const slot = {
         worker,
         load: 0,
         emitters: new Map(),
+        wsEmitters: new Map(),
+        props: new Map(),
         callbacks: new Map(),
         keystores: new Map(),
         loggers: new Map(),
-        pending: new Map(),
+        configs: new Map(),
+        pending: new Map()
     };
     // Global message handler — dispatches to the right socket's emitter
     worker.on('message', (msg) => {
+        var _a, _b, _c, _d;
         if (!msg || typeof msg !== 'object')
             return;
         const socketId = msg.socketId;
@@ -155,12 +192,56 @@ function spawnWorker() {
                     if (ev) {
                         const map = revivePostMessage(msg.map);
                         log === null || log === void 0 ? void 0 : log.trace({ eventKeys: Object.keys(map) }, 'worker event received');
+                        // Sync creds.update back to the parent's auth.creds object.
+                        // The worker mutates its own copy; without this the parent's
+                        // copy stays stale and saveCreds() writes old data.
+                        if (map['creds.update']) {
+                            const cfg = slot.configs.get(socketId);
+                            if ((_a = cfg === null || cfg === void 0 ? void 0 : cfg.auth) === null || _a === void 0 ? void 0 : _a.creds) {
+                                Object.assign(cfg.auth.creds, map['creds.update']);
+                                log === null || log === void 0 ? void 0 : log.debug({ me: (_b = cfg.auth.creds.me) === null || _b === void 0 ? void 0 : _b.id }, 'synced creds.update to parent');
+                            }
+                            // Also update localProps.user so wsocket.user and its
+                            // nested properties (id, lid, name, verifiedName, etc.)
+                            // stay in sync with the worker's authState.creds.me.
+                            const credsUpdate = map['creds.update'];
+                            if (credsUpdate === null || credsUpdate === void 0 ? void 0 : credsUpdate.me) {
+                                const props = slot.props.get(socketId);
+                                if (props) {
+                                    props.user = { ...props.user, ...credsUpdate.me };
+                                    log === null || log === void 0 ? void 0 : log.debug({ me: (_c = credsUpdate.me) === null || _c === void 0 ? void 0 : _c.id }, 'synced user to localProps');
+                                }
+                            }
+                        }
                         // Emit the aggregated 'event' for ev.process() compatibility
                         ev.emit('event', map);
                         // Also emit individual typed events for ev.on() listeners
                         for (const [event, data] of Object.entries(map)) {
                             ev.emit(event, data);
                         }
+                        // When the socket closes, clean up proxy-side resources.
+                        // The worker already removed its entry; we remove the
+                        // emitter so a future startSock() can create a fresh one.
+                        if (((_d = map['connection.update']) === null || _d === void 0 ? void 0 : _d.connection) === 'close') {
+                            cleanupSocket(slot, socketId, log || createNoopLogger());
+                        }
+                    }
+                }
+                break;
+            case 'ws-event':
+                if (socketId !== undefined) {
+                    const wsEv = slot.wsEmitters.get(socketId);
+                    if (wsEv) {
+                        const { event, args } = msg;
+                        wsEv.emit(event, ...args);
+                    }
+                }
+                break;
+            case 'socket-info':
+                if (socketId !== undefined) {
+                    const props = slot.props.get(socketId);
+                    if (props && msg.info) {
+                        Object.assign(props, msg.info);
                     }
                 }
                 break;
@@ -187,7 +268,7 @@ function spawnWorker() {
                 break;
         }
     });
-    worker.on('error', (err) => {
+    worker.on('error', err => {
         // Log to all socket loggers on this worker
         for (const log of slot.loggers.values()) {
             log.error({ err, workerPid: worker.threadId }, 'worker thread error');
@@ -196,7 +277,7 @@ function spawnWorker() {
         if (idx !== -1)
             slots.splice(idx, 1);
     });
-    worker.on('exit', (code) => {
+    worker.on('exit', code => {
         for (const log of slot.loggers.values()) {
             log.info({ exitCode: code, workerPid: worker.threadId }, 'worker thread exited');
         }
@@ -220,7 +301,7 @@ async function handleCallbackCall(slot, socketId, msg) {
                 type: 'callback-result',
                 socketId,
                 id,
-                error: `No keystore method "${method}"`,
+                error: `No keystore method "${method}"`
             });
         }
         try {
@@ -234,7 +315,7 @@ async function handleCallbackCall(slot, socketId, msg) {
                 type: 'callback-result',
                 socketId,
                 id,
-                error: (err === null || err === void 0 ? void 0 : err.message) || String(err),
+                error: (err === null || err === void 0 ? void 0 : err.message) || String(err)
             });
         }
         return;
@@ -248,7 +329,7 @@ async function handleCallbackCall(slot, socketId, msg) {
             type: 'callback-result',
             socketId,
             id,
-            error: `No callback registered for "${key}"`,
+            error: `No callback registered for "${key}"`
         });
     }
     try {
@@ -262,7 +343,7 @@ async function handleCallbackCall(slot, socketId, msg) {
             type: 'callback-result',
             socketId,
             id,
-            error: (err === null || err === void 0 ? void 0 : err.message) || String(err),
+            error: (err === null || err === void 0 ? void 0 : err.message) || String(err)
         });
     }
 }
@@ -355,12 +436,10 @@ function deepStripFunctions(value, seen = new WeakSet()) {
     return value;
 }
 const makeWASocket = (config) => {
-    var _a;
+    var _a, _b;
     const socketId = nextSocketId();
     // ---- Create a child logger for this socket ---------------------------
-    const log = config.logger
-        ? config.logger.child({ worker: 'proxy', socketId })
-        : createNoopLogger();
+    const log = config.logger ? config.logger.child({ worker: 'proxy', socketId }) : createNoopLogger();
     // ---- Extract non-serializable callbacks ------------------------------
     const callbackStore = {};
     // Save the real keystore before stripping
@@ -369,7 +448,14 @@ const makeWASocket = (config) => {
     // Functions are replaced with the sentinel string '__proxy_fn__'.
     // The child will create forwarding stubs for known callback keys and
     // the keystore; other stripped functions become no-ops.
-    const serializableConfig = deepStripFunctions(config);
+    //
+    // makeSignalRepository returns a complex object (closures + methods) that
+    // cannot be cloned back to the worker. We replace it with a sentinel and
+    // recreate the default libsignal repository inside the worker.
+    const configWithSignalRepo = typeof config.makeSignalRepository === 'function'
+        ? { ...config, makeSignalRepository: '__worker_signal_repository__' }
+        : config;
+    const serializableConfig = deepStripFunctions(configWithSignalRepo);
     // Mark the logger so the child knows to create a real one
     if (config.logger) {
         ;
@@ -381,6 +467,23 @@ const makeWASocket = (config) => {
             serializableConfig.auth = {};
         serializableConfig.auth.keys = '__proxy_keystore__';
     }
+    // Worker-local cache stores cannot be cloned (their methods live on the
+    // prototype and would become broken plain objects). Replace them with a
+    // sentinel so the child creates a fresh cache inside the worker.
+    for (const k of CACHE_CONFIG_KEYS) {
+        if (typeof ((_b = config[k]) === null || _b === void 0 ? void 0 : _b.get) === 'function') {
+            ;
+            serializableConfig[k] = CACHE_SENTINEL;
+        }
+    }
+    // HTTP agents contain sockets and native state; they cannot cross
+    // postMessage. The worker will create its own agents.
+    if (serializableConfig.agent) {
+        serializableConfig.agent = undefined;
+    }
+    if (serializableConfig.fetchAgent) {
+        serializableConfig.fetchAgent = undefined;
+    }
     // Restore known callback sentinels with the proper key names
     for (const k of CALLBACK_CONFIG_KEYS) {
         if (typeof config[k] === 'function') {
@@ -392,20 +495,23 @@ const makeWASocket = (config) => {
     const slot = acquireSlot();
     slot.load++;
     slot.emitters.set(socketId, new events_1.EventEmitter());
+    slot.wsEmitters.set(socketId, new events_1.EventEmitter());
+    slot.props.set(socketId, {});
     slot.callbacks.set(socketId, callbackStore);
     slot.keystores.set(socketId, realKeystore);
     slot.loggers.set(socketId, log);
+    slot.configs.set(socketId, config);
     log.info({
         workerPid: slot.worker.threadId,
         workerLoad: slot.load,
         poolSize: slots.length,
-        maxWorkers,
+        maxWorkers
     }, 'socket assigned to worker');
     // ---- Send init message to the worker for this socket -----------------
     slot.worker.postMessage({
         type: 'init',
         socketId,
-        config: serializableConfig,
+        config: serializableConfig
     });
     log.debug('init message sent to worker');
     // ---- Public event emitter (local to this socket) ---------------------
@@ -418,13 +524,21 @@ const makeWASocket = (config) => {
     const ev = new Proxy(rawEv, {
         get(target, prop) {
             // Local EventEmitter methods
-            if (prop === 'on' || prop === 'off' || prop === 'emit' ||
-                prop === 'removeListener' || prop === 'addListener' ||
-                prop === 'removeAllListeners' || prop === 'listeners' ||
-                prop === 'listenerCount' || prop === 'eventNames' ||
-                prop === 'getMaxListeners' || prop === 'setMaxListeners' ||
-                prop === 'rawListeners' || prop === 'prependListener' ||
-                prop === 'prependOnceListener' || prop === 'once') {
+            if (prop === 'on' ||
+                prop === 'off' ||
+                prop === 'emit' ||
+                prop === 'removeListener' ||
+                prop === 'addListener' ||
+                prop === 'removeAllListeners' ||
+                prop === 'listeners' ||
+                prop === 'listenerCount' ||
+                prop === 'eventNames' ||
+                prop === 'getMaxListeners' ||
+                prop === 'setMaxListeners' ||
+                prop === 'rawListeners' ||
+                prop === 'prependListener' ||
+                prop === 'prependOnceListener' ||
+                prop === 'once') {
                 return target[prop].bind(target);
             }
             // process() is implemented locally: it listens to the aggregated
@@ -448,52 +562,115 @@ const makeWASocket = (config) => {
         const id = nextReqId();
         log.trace({ rpcId: id, method, argCount: args.length }, 'RPC call → worker');
         return new Promise((resolve, reject) => {
-            slot.pending.set(id, { resolve, reject });
+            slot.pending.set(id, { socketId, resolve, reject });
             slot.worker.postMessage({ type: 'call', socketId, id, method, args });
         });
     };
     // ---- Build the proxy object ------------------------------------------
-    const socketProxy = new Proxy({ ev }, {
+    const rawWs = slot.wsEmitters.get(socketId);
+    const localProps = slot.props.get(socketId);
+    // Wrap ws in a proxy: EventEmitter methods work locally,
+    // close() is forwarded to the worker via RPC.
+    const wsProxy = new Proxy(rawWs, {
+        get(target, prop) {
+            if (prop === 'close') {
+                return (...args) => {
+                    if (!isSocketActive(slot, socketId)) {
+                        log.debug('ws.close() ignored — socket already cleaned up');
+                        return Promise.resolve();
+                    }
+                    return rpcCall('ws.close', args);
+                };
+            }
+            // Delegate everything else (on, off, removeAllListeners, etc.) to the EventEmitter
+            const value = target[prop];
+            if (typeof value === 'function') {
+                return value.bind(target);
+            }
+            return value;
+        }
+    });
+    const socketProxy = new Proxy({ ev, ws: wsProxy }, {
         get(_target, prop) {
             if (prop === 'ev')
                 return ev;
+            if (prop === 'ws')
+                return wsProxy;
             if (prop === 'then')
                 return undefined;
             if (prop === 'pool')
                 return getStats();
+            // Check local property store first (wsocket.id, wsocket.user, etc.)
+            if (prop in localProps)
+                return localProps[prop];
             if (prop === 'end') {
                 return async (...args) => {
+                    if (!isSocketActive(slot, socketId)) {
+                        log.debug('socket.end() ignored — already cleaned up');
+                        return;
+                    }
                     log.info('socket.end() called — cleaning up');
                     try {
                         await rpcCall('end', args);
                     }
-                    catch (_) { /* ok */ }
+                    catch (_) {
+                        /* ok */
+                    }
                     cleanupSocket(slot, socketId, log);
                 };
             }
             if (prop === 'logout') {
                 return async (...args) => {
+                    if (!isSocketActive(slot, socketId)) {
+                        log.debug('socket.logout() ignored — already cleaned up');
+                        return;
+                    }
                     log.info('socket.logout() called — cleaning up');
                     try {
                         await rpcCall('logout', args);
                     }
-                    catch (_) { /* ok */ }
+                    catch (_) {
+                        /* ok */
+                    }
                     cleanupSocket(slot, socketId, log);
                 };
             }
             return (...args) => rpcCall(prop, args);
         },
+        set(_target, prop, value) {
+            localProps[prop] = value;
+            return true;
+        }
     });
     return socketProxy;
 };
 exports.makeWASocket = makeWASocket;
+function isSocketActive(slot, socketId) {
+    return slot.emitters.has(socketId);
+}
 function cleanupSocket(slot, socketId, log) {
+    // Idempotent cleanup: only run once per socketId.
+    if (!isSocketActive(slot, socketId)) {
+        return false;
+    }
+    // Reject any pending RPC calls for this socket so they don't hang or
+    // receive the worker's "Socket X not found" error after reconnection.
+    for (const [id, p] of slot.pending) {
+        if (p.socketId === socketId) {
+            slot.pending.delete(id);
+            p.reject(new Error(`Socket ${socketId} closed`));
+        }
+    }
     slot.emitters.delete(socketId);
+    slot.wsEmitters.delete(socketId);
+    slot.props.delete(socketId);
     slot.callbacks.delete(socketId);
     slot.keystores.delete(socketId);
     slot.loggers.delete(socketId);
+    slot.configs.delete(socketId);
     slot.load = Math.max(0, slot.load - 1);
     log.info({ workerLoad: slot.load, poolSize: slots.length }, 'socket cleaned up');
+    return true;
     // If the worker is now idle and we're over capacity, terminate it
     if (slot.load === 0 && slots.length > maxWorkers) {
         const idx = slots.indexOf(slot);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libzapitu",
-  "version": "1.0.0-alpha.20",
+  "version": "1.0.0-alpha.22",
   "description": "A WebSockets library for interacting with WhatsApp Web",
   "keywords": [
     "whatsapp",
@@ -83,6 +83,7 @@
     "jimp": "^1.6.0",
     "json": "^11.0.0",
     "link-preview-js": "^3.0.0",
+    "node-cache": "^5.1.2",
     "open": "^8.4.2",
     "prettier": "^3.5.3",
     "protobufjs-cli": "^1.1.3",