@arcaelas/whatsapp 6.2.0 → 7.0.1

package/build/esm/lib/whatsapp/index.js

@@ -1,245 +1,54 @@
-/**
- * @file whatsapp/index.ts
- * @description Orquestador principal del cliente WhatsApp v3.
- * Main orchestrator of the WhatsApp v3 client.
- */
 import { Browsers, decryptPollVote, DisconnectReason, downloadMediaMessage, fetchLatestBaileysVersion, getContentType, initAuthCreds, jidNormalizedUser, makeWASocket, proto, updateMessageWithPollUpdate, } from 'baileys';
 import { EventEmitter } from 'node:events';
 import pino from 'pino';
 import * as QRCode from 'qrcode';
 import { chat } from '../../lib/chat/index.js';
-import { contact } from '../../lib/contact/index.js';
-import { bind } from '../../lib/internal.js';
-import { Audio, Document, Event, Image, Location, message, Message, Poll, Sticker, Text, VCard, Video, } from '../../lib/message/index.js';
+import { Account, contact } from '../../lib/contact/index.js';
+import Message, { message } from '../../lib/message/index.js';
 import { Feed, TTL_MS as FEED_TTL_MS } from '../../lib/status/index.js';
-import { deserialize, serialize } from '../../lib/store/index.js';
-/** Rechazo del servidor: estado terminal, el único que puede retroceder el avance. / Server rejection: terminal state, the only one allowed to move the state backwards. */
-const ERROR = 0;
-/** Estados legibles del mensaje que el receipt puede avanzar. / Readable message states a receipt can advance to. */
-const READ = 4;
-const PLAYED = 5;
-/**
- * Deduce el MIME de un binario por su firma, acotado a lo que WhatsApp acepta en un estado.
- * Infers a binary's MIME from its signature, limited to what WhatsApp accepts in a status.
- *
- * @param data - Binario a inspeccionar / Binary to inspect
- * @returns MIME reconocido, o null / Recognized MIME, or null
- */
-function sniff_media(data) {
-    if (data.subarray(0, 3).toString('hex') === 'ffd8ff')
-        return 'image/jpeg';
-    if (data.subarray(0, 8).toString('hex') === '89504e470d0a1a0a')
-        return 'image/png';
-    if (data.subarray(0, 4).toString() === 'RIFF' && data.subarray(8, 12).toString() === 'WEBP')
-        return 'image/webp';
-    if (data.subarray(4, 8).toString() === 'ftyp')
-        return 'video/mp4';
-    return null;
-}
-/**
- * Cliente principal de WhatsApp. No inicia la conexión al instanciar.
- * Main WhatsApp client. Does not connect on instantiation.
- *
- * @example
- * const wa = new WhatsApp({ engine: new FileSystemEngine(__dirname), phone: 5491112345678 });
- * wa.on('message:created', (msg) => console.log(msg.caption));
- * await wa.connect((code) => console.log(code));
- */
-export class WhatsApp {
-    /** @internal Emisor de los eventos del cliente. / Client event emitter. */
+import { deserialize, jid_of, serialize } from '../../lib/store/index.js';
+export default class WhatsApp {
     #event = new EventEmitter();
-    /** @internal Estado compartido con las entidades (socket, resolución de JIDs). / State shared with the entities. */
-    #internals;
-    #phone;
-    #method;
-    #autoclean;
-    #reconnect;
-    #sync;
-    #intentional_close = false;
-    #silent_close = false;
-    #has_connected = false;
-    #retry_timer = null;
-    #retry_count = 0;
-    /**
-     * @internal
-     * Cadena que serializa los handlers de eventos de baileys: dos eventos sobre el mismo
-     * documento ya no se intercalan (lost updates por read-modify-write concurrente).
-     * Chain serializing baileys event handlers: two events over the same document no longer
-     * interleave (lost updates from concurrent read-modify-write).
-     */
-    #chain = Promise.resolve();
+    #options;
+    #close = null;
     constructor(options) {
         this.engine = options.engine;
-        this.#phone = options.phone !== undefined ? String(options.phone).replace(/\D+/g, '') : undefined;
-        this.#method = options.method;
-        this.#autoclean = options.autoclean ?? true;
-        this.#sync = options.sync ?? true;
-        this.#reconnect =
-            options.reconnect === false ? { max: 0, interval_ms: 60_000 }
-                : options.reconnect === undefined || options.reconnect === true ? { max: null, interval_ms: 60_000 }
-                    : typeof options.reconnect === 'number' ? { max: options.reconnect, interval_ms: 60_000 }
-                        : { max: options.reconnect.max ?? null, interval_ms: (options.reconnect.interval ?? 60) * 1_000 };
-        this.#internals = { socket: null, resolve_jid: (uid) => this.#resolve_jid(uid) };
-        bind(this, this.#internals);
-        this.Contact = contact(this);
-        this.Chat = chat(this);
-        this.Message = {
-            get: (cid, mid) => Message.get(this, cid, mid),
-            list: (cid, offset, limit) => Message.list(this, cid, offset, limit),
-            text: (cid, ...rest) => Message.text(this, cid, ...rest),
-            image: (cid, ...rest) => Message.image(this, cid, ...rest),
-            video: (cid, ...rest) => Message.video(this, cid, ...rest),
-            audio: (cid, ...rest) => Message.audio(this, cid, ...rest),
-            location: (cid, ...rest) => Message.location(this, cid, ...rest),
-            poll: (cid, ...rest) => Message.poll(this, cid, ...rest),
-            document: (cid, ...rest) => Message.document(this, cid, ...rest),
-            vcard: (cid, ...rest) => Message.vcard(this, cid, ...rest),
-            event: (cid, ...rest) => Message.event(this, cid, ...rest),
-            react: (cid, mid, emoji) => Message.react(this, cid, mid, emoji),
-            star: (cid, mid, value) => Message.star(this, cid, mid, value),
-            seen: (cid, mid) => Message.seen(this, cid, mid),
-            edit: (cid, mid, caption) => Message.edit(this, cid, mid, caption),
-            forward: (cid, mid, target) => Message.forward(this, cid, mid, target),
-            delete: (cid, mid, all) => Message.delete(this, cid, mid, all),
-            reactions: (cid, mid) => Message.reactions(this, cid, mid),
-            Text, Image, Video, Audio, Sticker, Document, Location, Poll, VCard, Event,
-        };
-    }
-    /**
-     * Contacto de la cuenta autenticada, o null mientras no hay sesión abierta.
-     * Authenticated account's contact, or null while there is no open session.
-     */
-    get contact() {
-        const user = this.#internals.socket?.user;
-        if (user) {
-            const jid = jidNormalizedUser(user.id);
-            return new this.Contact({ id: jid, phone_number: jid, lid: user.lid ?? null, name: user.name ?? null });
-        }
-        return null;
-    }
-    /**
-     * @internal
-     * Persiste un binario: crudo cuando el driver lo soporta, JSON con base64 si no.
-     * Persists a binary: raw when the driver supports it, base64 JSON otherwise.
-     */
-    async #write_content(path, data) {
-        if (this.engine.set_buffer) {
-            await this.engine.set_buffer(path, data);
-        }
-        else {
-            await this.engine.set(path, serialize({ data: data.toString('base64') }));
-        }
+        this.#options = options;
     }
-    /** @internal Encola una tarea en la cadena serial de handlers. / Queues a task on the serial handler chain. */
-    #enqueue(task) {
-        this.#chain = this.#chain.then(task).catch(() => { });
-    }
-    /**
-     * Emite un evento del cliente. Lo usan las entidades de la librería para propagar los
-     * cambios que provocan; el consumidor puede emitir los suyos para pruebas.
-     * Emits a client event. Library entities use it to propagate the changes they cause;
-     * consumers may emit their own for testing.
-     *
-     * @param event - Nombre del evento / Event name
-     * @param args - Argumentos del evento / Event arguments
-     * @returns true si había listeners / true when listeners were present
-     */
     emit(event, ...args) {
         return this.#event.emit(event, ...args);
     }
-    /**
-     * Registra un listener de evento. Retorna función para desuscribirse.
-     * Registers an event listener. Returns an unsubscribe function.
-     */
     on(event, handler) {
         this.#event.on(event, handler);
         return () => { this.#event.off(event, handler); };
     }
-    /**
-     * Quita un listener previamente registrado.
-     * Removes a previously registered listener.
-     */
-    off(event, handler) {
-        this.#event.off(event, handler);
-        return this;
-    }
-    /**
-     * Registra un listener one-shot. Retorna función para desuscribirse antes de que dispare.
-     * Registers a one-shot listener. Returns an unsubscribe function.
-     */
     once(event, handler) {
         this.#event.once(event, handler);
         return () => { this.#event.off(event, handler); };
     }
-    /**
-     * @internal
-     * Normaliza cualquier identificador (JID, LID, número, etc.) a JID canónico. Las
-     * entidades lo alcanzan por el canal interno, no por la instancia.
-     * Normalizes any identifier (JID, LID, number…) into a canonical JID. Entities reach it
-     * through the internal channel, not through the instance.
-     */
-    async #resolve_jid(uid) {
-        let result = null;
-        if (uid.endsWith('@g.us') || uid.endsWith('@s.whatsapp.net')) {
-            result = uid;
-        }
-        else if (uid.endsWith('@lid')) {
-            // Los receipts direccionan por dispositivo (`…:9@lid`); el índice se guarda sin él.
-            // Receipts address per device (`…:9@lid`); the index is stored without it.
-            const lid = jidNormalizedUser(uid);
-            const direct = deserialize(await this.engine.get(`/lid/${lid}`));
-            if (direct) {
-                result = direct.includes('@') ? direct : `${direct}@s.whatsapp.net`;
-            }
-            else {
-                const reverse = deserialize(await this.engine.get(`/lid/${lid.split('@')[0]}_reverse`));
-                if (reverse != null) {
-                    result = `${reverse}@s.whatsapp.net`;
-                }
-                else {
-                    // El store local puede no tener el mapping (sesión sin upsert del contacto);
-                    // baileys lo conoce vía su lidMapping. Sin esto, un chat referenciado por @lid
-                    // (p.ej. el pollCreationMessageKey de un voto entrante) no resuelve al PN donde
-                    // realmente está guardado, y el mensaje/poll no se encuentra.
-                    const pn = await this.#internals.socket?.signalRepository?.lidMapping?.getPNForLID(lid).catch(() => null);
-                    if (pn) {
-                        // getPNForLID puede traer sufijo de dispositivo (`:0`); se normaliza para
-                        // que el JID coincida con el que usa el store (sin device).
-                        result = jidNormalizedUser(pn.includes('@') ? pn : `${pn}@s.whatsapp.net`);
-                    }
-                }
-            }
-        }
-        else {
-            const cleaned = uid.replace(/\D/g, '');
-            if (cleaned) {
-                result = `${cleaned}@s.whatsapp.net`;
-            }
-        }
-        return result;
+    off(event, handler) {
+        this.#event.off(event, handler);
+        return this;
     }
-    /**
-     * Inicia la conexión. El callback recibe el PIN (string) si se configuró `phone`, o el QR (Buffer PNG) si no.
-     * Resuelve cuando la sesión sincroniza; reintenta automáticamente en cierres no-loggedOut.
-     *
-     * Starts the connection. Callback receives the PIN (string) when `phone` is configured, or the QR (PNG Buffer) otherwise.
-     * Resolves once the session is synced; retries on non-loggedOut disconnects.
-     */
     async connect(callback) {
-        if (this.#internals.socket) {
-            await this.disconnect({ silent: true });
-        }
+        const { engine } = this;
+        const { phone, method, autoclean = true, sync = true, reconnect = true } = this.#options;
+        const digits = phone !== undefined ? String(phone).replace(/\D+/g, '') : '';
+        const budget = reconnect === false ? 0 : reconnect === true ? null : typeof reconnect === 'number' ? reconnect : reconnect.max ?? null;
+        const wait = typeof reconnect === 'object' ? (reconnect.interval ?? 60) * 1_000 : 60_000;
+        await this.#close?.(true);
         const { version } = await fetchLatestBaileysVersion();
-        this.#intentional_close = false;
-        this.#silent_close = false;
-        this.#has_connected = false;
+        let connected = false;
+        let retries = 0;
+        let intentional = false;
+        let silent = false;
+        let alive = null;
+        let timer = null;
+        let chain = Promise.resolve();
         return new Promise((resolve, reject) => {
             const start = async () => {
-                // Re-lee creds en cada start() para que limpiezas del engine tomen efecto
-                // en reintentos (permite al consumer forzar nueva sesión borrando /session/creds).
-                const stored = await this.engine.get('/session/creds');
-                const creds = deserialize(stored) ?? initAuthCreds();
-                this.#internals.socket = makeWASocket({
+                const creds = deserialize(await engine.get('/session/creds')) ?? initAuthCreds();
+                const socket = makeWASocket({
                     version,
                     auth: {
                         creds,
@@ -247,949 +56,525 @@ export class WhatsApp {
                             get: async (type, ids) => {
                                 const data = {};
                                 await Promise.all(ids.map(async (id) => {
-                                    const value = deserialize(await this.engine.get(`/session/${type}/${id}`));
+                                    const value = deserialize(await engine.get(`/session/${type}/${id}`));
                                     if (value) {
-                                        data[id] =
-                                            type === 'app-state-sync-key'
-                                                ? proto.Message.AppStateSyncKeyData.create(value)
-                                                : value;
+                                        data[id] = type === 'app-state-sync-key'
+                                            ? proto.Message.AppStateSyncKeyData.create(value)
+                                            : value;
                                     }
                                 }));
                                 return data;
                             },
                             set: async (data) => {
                                 await Promise.all(Object.entries(data).flatMap(([category, entries]) => Object.entries(entries).map(([id, value]) => value != null
-                                    ? this.engine.set(`/session/${category}/${id}`, serialize(value))
-                                    : this.engine.unset(`/session/${category}/${id}`))));
+                                    ? engine.set(`/session/${category}/${id}`, serialize(value))
+                                    : engine.unset(`/session/${category}/${id}`))));
                             },
                         },
                     },
                     browser: Browsers.windows('Chrome'),
                     logger: pino({ level: 'silent' }),
-                    syncFullHistory: this.#sync,
-                    // Los syncs no-FULL cargan las LID mappings y los tctokens (trusted-contact
-                    // tokens) que rc13 exige para enviar: apagarlos todos con `() => this.#sync`
-                    // deja la sesión sin tctoken y el server rechaza los mensajes con
-                    // "error 463: account restricted or missing tctoken". Por eso se procesan
-                    // siempre los no-FULL; `sync` solo decide si además se trae el historial FULL.
-                    // Non-FULL syncs carry the LID mappings and tctokens rc13 requires to send;
-                    // disabling them all made the server reject messages with error 463. We always
-                    // process non-FULL; `sync` only gates whether FULL history is pulled too.
-                    shouldSyncHistoryMessage: ({ syncType }) => this.#sync || syncType !== proto.HistorySync.HistorySyncType.FULL,
+                    syncFullHistory: sync,
+                    shouldSyncHistoryMessage: ({ syncType }) => sync || syncType !== proto.HistorySync.HistorySyncType.FULL,
+                    // Cuando el receptor no puede descifrar pide un retry; el cache interno de
+                    // baileys indexa por JID pero el retry llega por LID y no lo encuentra: sin
+                    // este fallback el mensaje muere en un solo check.
+                    // When the receiver cannot decrypt it asks for a retry; the internal baileys
+                    // cache indexes by JID but the retry arrives by LID and misses: without this
+                    // fallback the message dies at a single check.
+                    getMessage: async (key) => {
+                        const found = key.remoteJid && key.id ? await locate(key.remoteJid, key.id) : null;
+                        return found?.doc.raw.message ?? undefined;
+                    },
                     markOnlineOnConnect: false,
                 });
-                const socket = this.#internals.socket;
-                socket.ev.on('creds.update', () => this.engine.set('/session/creds', serialize(creds)));
-                socket.ev.on('connection.update', async (update) => {
-                    const { connection, lastDisconnect, qr } = update;
-                    if (qr && !creds.registered) {
-                        // Baileys refresca QR periódicamente (~20s). Emitimos nuevo pair
-                        // code / QR en cada refresh para que el usuario pueda renovar si
-                        // el anterior expiró.
-                        // El PIN necesita número: sin `phone` la vinculación es siempre QR, y
-                        // con `phone` manda `method` (OTP por defecto).
-                        // A PIN requires a number: without `phone` linking is always QR, and with
-                        // `phone` the `method` option decides (OTP by default).
-                        if (this.#phone && (this.#method ?? 'otp') === 'otp') {
-                            await callback(await socket.requestPairingCode(this.#phone));
-                        }
-                        else {
-                            await callback(await QRCode.toBuffer(qr, { type: 'png', margin: 2 }));
+                alive = socket;
+                const init = { wa: this, engine, socket };
+                this.Contact = contact(init);
+                this.Chat = chat(init);
+                this.Message = message(init);
+                this.account = async () => {
+                    const user = socket.user;
+                    if (!user)
+                        return null;
+                    const id = jidNormalizedUser(user.id);
+                    const card = deserialize(await engine.get(`/contact/${id}`));
+                    return new Account(init, {
+                        id,
+                        phone_number: id,
+                        lid: user.lid ?? card?.lid ?? null,
+                        name: user.name ?? card?.name ?? null,
+                        notify: card?.notify ?? null,
+                        verified_name: card?.verified_name ?? null,
+                        img_url: (await socket.profilePictureUrl(id, 'image').catch(() => null)) ?? card?.img_url ?? null,
+                        status: card?.status ?? null,
+                    });
+                };
+                const locate = async (cid, mid) => {
+                    const lid = cid.endsWith('@lid') ? jidNormalizedUser(cid) : '';
+                    const resolved = await jid_of(engine, cid, socket);
+                    for (const candidate of new Set([resolved, cid, lid].filter(Boolean))) {
+                        const path = `/chat/${candidate}/message/${mid}`;
+                        const doc = deserialize(await engine.get(path));
+                        if (doc) {
+                            return { path, doc };
                         }
                     }
+                    return null;
+                };
+                socket.ev.on('creds.update', () => engine.set('/session/creds', serialize(creds)));
+                socket.ev.on('connection.update', async ({ connection, lastDisconnect, qr }) => {
+                    if (qr && !creds.registered) {
+                        await callback(digits && (method ?? 'otp') === 'otp'
+                            ? await socket.requestPairingCode(digits)
+                            : await QRCode.toBuffer(qr, { type: 'png', margin: 2 }));
+                    }
                     if (connection === 'open') {
-                        this.#has_connected = true;
-                        this.#retry_count = 0;
+                        connected = true;
+                        retries = 0;
                         this.emit('connected', this);
                         resolve();
                     }
                     else if (connection === 'close') {
-                        this.#internals.socket = null;
-                        const status_code = lastDisconnect?.error?.output?.statusCode;
-                        // `restartRequired` (515) es una reconexión exigida por el protocolo
-                        // tras el sync inicial — no es un disconnect "real".
-                        const is_transient = status_code === DisconnectReason.restartRequired;
-                        // Limpieza del engine ANTES de emitir `disconnected` para que los
-                        // listeners vean el estado final (engine vaciado o creds borradas).
-                        if (status_code === DisconnectReason.loggedOut) {
-                            if (this.#autoclean) {
-                                await this.engine.clear();
-                            }
-                            else {
-                                await this.engine.unset('/session/creds');
-                            }
+                        const code = lastDisconnect?.error?.output?.statusCode;
+                        const transient = code === DisconnectReason.restartRequired;
+                        if (code === DisconnectReason.loggedOut) {
+                            await (autoclean ? engine.clear() : engine.unset('/session/creds'));
                         }
-                        // `disconnect({ silent: true })` calla el evento de este cierre concreto.
-                        // `disconnect({ silent: true })` mutes this specific close's event.
-                        if (this.#has_connected && !is_transient && !this.#silent_close) {
+                        if (connected && !transient && !silent) {
                             this.emit('disconnected', this);
                         }
-                        if (!this.#intentional_close) {
-                            if (status_code === DisconnectReason.loggedOut) {
-                                reject(new Error('Logged out'));
-                            }
-                            else {
-                                const max = this.#reconnect.max;
-                                // Transient closes (restartRequired) son parte del protocolo,
-                                // no cuentan contra el límite de reintentos por fallo.
-                                const exhausted = !is_transient && max !== null && this.#retry_count >= max;
-                                if (exhausted) {
-                                    reject(new Error(`Reconnect attempts exhausted (${max})`));
-                                }
-                                else {
-                                    if (!is_transient) {
-                                        this.#retry_count++;
+                        if (intentional) {
+                            /* cierre pedido por disconnect(): sin reintentos / close requested by disconnect(): no retries */
+                        }
+                        else if (code === DisconnectReason.loggedOut) {
+                            reject(new Error('Logged out'));
+                        }
+                        else if (!transient && budget !== null && retries >= budget) {
+                            reject(new Error(`Reconnect attempts exhausted (${budget})`));
+                        }
+                        else {
+                            retries += transient ? 0 : 1;
+                            timer = setTimeout(() => {
+                                timer = null;
+                                start().catch(reject);
+                            }, transient ? 0 : wait);
+                        }
+                    }
+                });
+                socket.ev.on('messaging-history.set', ({ chats, contacts, messages }) => {
+                    socket.ev.emit('contacts.upsert', contacts);
+                    socket.ev.emit('chats.upsert', chats);
+                    socket.ev.emit('messages.upsert', { messages, type: 'append' });
+                });
+                socket.ev.on('contacts.upsert', (rows) => {
+                    chain = chain.then(async () => {
+                        for (const row of rows) {
+                            if (row.id) {
+                                const current = deserialize(await engine.get(`/contact/${row.id}`));
+                                const doc = {
+                                    id: row.id,
+                                    lid: row.lid ?? current?.lid ?? null,
+                                    name: row.name ?? current?.name ?? null,
+                                    notify: row.notify ?? current?.notify ?? null,
+                                    verified_name: row.verifiedName ?? current?.verified_name ?? null,
+                                    img_url: (typeof row.imgUrl === 'string' ? row.imgUrl : null) ?? current?.img_url ?? null,
+                                    status: row.status ?? current?.status ?? null,
+                                };
+                                if (!current || JSON.stringify(current) !== JSON.stringify(doc)) {
+                                    await engine.set(`/contact/${row.id}`, serialize(doc));
+                                    if (doc.lid) {
+                                        await engine.set(`/lid/${doc.lid}`, serialize(doc.id));
                                     }
-                                    const delay = is_transient ? 0 : this.#reconnect.interval_ms;
-                                    this.#retry_timer = setTimeout(() => {
-                                        this.#retry_timer = null;
-                                        start().catch(reject);
-                                    }, delay);
+                                    const person = new this.Contact(doc);
+                                    const owner = deserialize(await engine.get(`/chat/${doc.id}`));
+                                    this.emit(current ? 'contact:updated' : 'contact:created', person, new this.Chat(owner ?? { id: doc.id, name: person.name }), this);
                                 }
                             }
                         }
-                    }
+                    }).catch(() => { });
                 });
-                this.#attach_business_handlers(socket);
-            };
-            start().catch(reject);
-        });
-    }
-    /**
-     * Actualiza el perfil de la cuenta en WhatsApp: nombre público, bio y/o foto. Sólo se
-     * envía lo que llega en el parche; `photo: null` elimina la foto actual.
-     * Updates the account profile on WhatsApp: public name, bio and/or picture. Only the
-     * given fields are sent; `photo: null` removes the current picture.
-     *
-     * @param patch - Campos a actualizar / Fields to update
-     * @returns true si todo lo pedido se envió / true when everything requested was sent
-     * @throws ERR_PROFILE_PICTURE_LIB si falta `sharp` o `jimp` para procesar la foto / when `sharp` or `jimp` is missing to process the picture
-     */
-    async profile(patch) {
-        const socket = this.#internals.socket;
-        let ok = false;
-        if (socket) {
-            const self = jidNormalizedUser(socket.user?.id ?? '');
-            if (patch.name !== undefined) {
-                await socket.updateProfileName(patch.name);
-            }
-            if (patch.content !== undefined) {
-                await socket.updateProfileStatus(patch.content);
-            }
-            if (patch.photo === null) {
-                await socket.removeProfilePicture(self);
-            }
-            else if (patch.photo !== undefined) {
-                // baileys redimensiona la foto con `sharp` o `jimp`; ninguna es dependencia
-                // nuestra, así que su ausencia se traduce a un error accionable.
-                // baileys resizes the picture with `sharp` or `jimp`; neither is a dependency
-                // of ours, so their absence is translated into an actionable error.
-                await socket
-                    .updateProfilePicture(self, typeof patch.photo === 'string' ? { url: patch.photo } : patch.photo)
-                    .catch((error) => {
-                    if (/image processing library/i.test(error.message)) {
-                        throw new Error('ERR_PROFILE_PICTURE_LIB');
-                    }
-                    throw error;
+                socket.ev.on('contacts.update', (rows) => {
+                    chain = chain.then(async () => {
+                        for (const row of rows) {
+                            const current = row.id ? deserialize(await engine.get(`/contact/${row.id}`)) : null;
+                            const patch = {
+                                ...(row.notify && { notify: row.notify }),
+                                ...(row.name && { name: row.name }),
+                                ...(row.verifiedName && { verified_name: row.verifiedName }),
+                                ...(typeof row.imgUrl === 'string' && { img_url: row.imgUrl }),
+                                ...(row.status && { status: row.status }),
+                                ...(row.lid && { lid: row.lid }),
+                            };
+                            if (current && row.id && Object.keys(patch).length > 0) {
+                                const doc = { ...current, ...patch };
+                                await engine.set(`/contact/${row.id}`, serialize(doc));
+                                if (patch.lid) {
+                                    await engine.set(`/lid/${patch.lid}`, serialize(row.id));
+                                }
+                                const person = new this.Contact(doc);
+                                const owner = deserialize(await engine.get(`/chat/${row.id}`));
+                                this.emit('contact:updated', person, new this.Chat(owner ?? { id: row.id, name: person.name }), this);
+                            }
+                        }
+                    }).catch(() => { });
                 });
-            }
-            ok = true;
-        }
-        return ok;
-    }
-    /**
-     * Publica un estado (status broadcast). Con sólo `caption` publica texto; con `content`
-     * publica imagen o video (el tipo se deduce del binario) usando `caption` como pie.
-     * `contacts` es la audiencia: WhatsApp no reparte el estado a quien no esté en la lista.
-     * Publishes a status broadcast. With only `caption` it posts text; with `content` it
-     * posts an image or video (type inferred from the binary) using `caption` as its footer.
-     * `contacts` is the audience: WhatsApp does not deliver the status to anyone outside it.
-     *
-     * @param post - Contenido, pie y audiencia / Content, caption and audience
-     * @returns Publicación creada, o null si no hay sesión / Created post, or null without a session
-     * @throws ERR_FEED_EMPTY sin `content` ni `caption` / when neither `content` nor `caption` is given
-     * @throws ERR_FEED_MEDIA si el binario no es imagen ni video / when the binary is neither image nor video
-     */
-    async feed(post) {
-        const socket = this.#internals.socket;
-        let result = null;
-        if (socket) {
-            const audience = (await Promise.all(post.contacts.map((uid) => this.#resolve_jid(String(uid))))).filter((jid) => jid !== null);
-            const mime = post.content ? sniff_media(post.content) : null;
-            if (post.content && !mime) {
-                throw new Error('ERR_FEED_MEDIA');
-            }
-            if (!post.content && !post.caption) {
-                throw new Error('ERR_FEED_EMPTY');
-            }
-            const kind = mime?.startsWith('video/') ? 'video' : mime ? 'image' : 'text';
-            const sent = await socket.sendMessage('status@broadcast', (post.content
-                ? { [kind]: post.content, caption: post.caption }
-                : { text: post.caption }), { statusJidList: audience });
-            if (sent?.key?.id) {
-                const created_at = (Number(sent.messageTimestamp) || Math.floor(Date.now() / 1_000)) * 1_000;
-                const doc = {
-                    id: sent.key.id,
-                    author_jid: jidNormalizedUser(socket.user?.id ?? ''),
-                    type: kind,
-                    caption: post.caption ?? '',
-                    mime: mime ?? 'text/plain',
-                    created_at,
-                    expires_at: created_at + FEED_TTL_MS,
-                    viewed: true,
-                    raw: sent,
-                };
-                await this.engine.set(`/status/${doc.id}`, serialize(doc), created_at);
-                if (post.content) {
-                    await this.#write_content(`/status/${doc.id}/content`, post.content);
-                }
-                result = new Feed(this, doc);
-                this.emit('feed:created', result, this);
-            }
-        }
-        return result;
-    }
-    /**
-     * Cierra la conexión. Con `destroy: true` vacía el engine completo.
-     * Closes the connection. With `destroy: true` clears the engine entirely.
-     */
-    async disconnect(options = {}) {
-        this.#intentional_close = true;
-        this.#silent_close = options.silent === true;
-        // Cancela cualquier retry programado por un close anterior, para no resucitar
-        // el socket después de una desconexión manual.
-        if (this.#retry_timer) {
-            clearTimeout(this.#retry_timer);
-            this.#retry_timer = null;
-        }
-        if (this.#internals.socket) {
-            try {
-                // Pasa un error Boom-like con statusCode=connectionClosed (428) para que
-                // `lastDisconnect.error.output.statusCode` quede explícito en el close
-                // en lugar de `undefined`.
-                const intentional = Object.assign(new Error('intentional close'), {
-                    output: { statusCode: DisconnectReason.connectionClosed },
+                socket.ev.on('lid-mapping.update', ({ lid, pn }) => {
+                    chain = chain.then(async () => {
+                        await engine.set(`/lid/${lid}`, serialize(pn));
+                        await engine.set(`/lid/${pn}`, serialize(lid));
+                    }).catch(() => { });
                 });
-                await this.#internals.socket.end(intentional);
-            }
-            catch {
-                /* socket may already be closed */
-            }
-            this.#internals.socket = null;
-        }
-        if (options.destroy) {
-            await this.engine.clear();
-        }
-    }
-    /**
-     * Conecta los handlers de eventos de baileys: contactos, chats y mensajes.
-     * Wires baileys event handlers: contacts, chats and messages.
-     *
-     * @internal
-     */
-    #attach_business_handlers(socket) {
-        socket.ev.on('messaging-history.set', ({ chats, contacts, messages }) => {
-            this.#enqueue(async () => {
-                await this.#handle_contacts_upsert(contacts);
-                await this.#handle_chats_upsert(chats);
-                await this.#handle_messages_upsert(messages);
-            });
-        });
-        socket.ev.on('contacts.upsert', (contacts) => {
-            this.#enqueue(() => this.#handle_contacts_upsert(contacts));
-        });
-        socket.ev.on('contacts.update', (contacts) => {
-            this.#enqueue(() => this.#handle_contacts_update(contacts));
-        });
-        socket.ev.on('lid-mapping.update', ({ lid, pn }) => {
-            this.#enqueue(() => this.#handle_lid_mapping(lid, pn));
-        });
-        socket.ev.on('chats.upsert', (chats) => {
-            this.#enqueue(() => this.#handle_chats_upsert(chats));
-        });
-        socket.ev.on('chats.update', (chats) => {
-            this.#enqueue(() => this.#handle_chats_update(chats));
-        });
-        socket.ev.on('chats.delete', (ids) => {
-            this.#enqueue(() => this.#handle_chats_delete(ids));
-        });
-        socket.ev.on('messages.upsert', ({ messages }) => {
-            this.#enqueue(() => this.#handle_messages_upsert(messages));
-        });
-        socket.ev.on('messages.update', (updates) => {
-            this.#enqueue(() => this.#handle_messages_update(updates));
-        });
-        socket.ev.on('message-receipt.update', (updates) => {
-            this.#enqueue(() => this.#handle_message_receipt(updates));
-        });
-        // Las reacciones llegan duplicadas por `messages.reaction` Y `messages.upsert`
-        // (como `reactionMessage`). Se usa solo `messages.upsert` para evitar el doble disparo.
-        // socket.ev.on('messages.reaction', (reactions) => {
-        //     void this.#handle_messages_reaction(reactions);
-        // });
-    }
-    /**
-     * Persiste un contacto y su índice LID; emite `contact:created` solo si es nuevo.
-     * Persists a contact and its LID index; emits `contact:created` only when new.
-     *
-     * @param raw - Documento del contacto a persistir / Contact document to persist
-     * @internal
-     */
-    async #persist_contact(raw) {
-        const current = deserialize(await this.engine.get(`/contact/${raw.id}`));
-        // Los upserts del re-sync llegan con los campos vacíos: sin fusionar borran el nombre
-        // que ya se conocía y el chat pasa a mostrar el número pelado.
-        // Re-sync upserts arrive with empty fields: without merging they wipe the name already
-        // known and the chat falls back to showing the bare number.
-        const doc = current
-            ? {
-                id: raw.id,
-                lid: raw.lid ?? current.lid,
-                name: raw.name ?? current.name,
-                notify: raw.notify ?? current.notify,
-                verified_name: raw.verified_name ?? current.verified_name,
-                img_url: raw.img_url ?? current.img_url,
-                status: raw.status ?? current.status,
-            }
-            : raw;
-        await this.engine.set(`/contact/${raw.id}`, serialize(doc));
-        if (doc.lid) {
-            await this.engine.set(`/lid/${doc.lid}`, serialize(doc.id));
-        }
-        // Una ficha que existía vacía y ahora tiene nombre es un cambio que el consumidor
-        // necesita: sin avisar, quien memorice el contacto sigue mostrando el número.
-        // A card that existed empty and now has a name is a change the consumer needs: without
-        // notifying, whoever memoized the contact keeps showing the bare number.
-        const changed = current && ['lid', 'name', 'notify', 'verified_name', 'img_url', 'status'].some((key) => current[key] !== doc[key]);
-        if (!current || changed) {
-            const person = new this.Contact(doc);
-            const cached_chat = deserialize(await this.engine.get(`/chat/${doc.id}`));
-            const chat = new this.Chat(cached_chat ?? { id: doc.id, name: person.name });
-            this.emit(current ? 'contact:updated' : 'contact:created', person, chat, this);
-        }
-    }
-    /** @internal */
-    async #handle_contacts_upsert(contacts) {
-        for (const c of contacts) {
-            if (c.id) {
-                await this.#persist_contact({
-                    id: c.id,
-                    lid: c.lid ?? null,
-                    name: c.name ?? null,
-                    notify: c.notify ?? null,
-                    verified_name: c.verifiedName ?? null,
-                    img_url: c.imgUrl ?? null,
-                    status: c.status ?? null,
-                });
-            }
-        }
-    }
-    /** @internal */
-    async #handle_contacts_update(contacts) {
-        for (const c of contacts) {
-            if (c.id) {
-                const current = deserialize(await this.engine.get(`/contact/${c.id}`));
-                if (current) {
-                    const patch = {
-                        ...(c.notify && { notify: c.notify }),
-                        ...(c.name && { name: c.name }),
-                        ...(c.verifiedName && { verified_name: c.verifiedName }),
-                        ...(c.imgUrl && { img_url: c.imgUrl }),
-                        ...(c.status && { status: c.status }),
-                        ...(c.lid && { lid: c.lid }),
-                    };
-                    if (Object.keys(patch).length > 0) {
-                        const merged = { ...current, ...patch };
-                        await this.engine.set(`/contact/${c.id}`, serialize(merged));
-                        if (patch.lid) {
-                            await this.engine.set(`/lid/${patch.lid}`, serialize(c.id));
-                        }
-                        const person = new this.Contact(merged);
-                        const cached_chat = deserialize(await this.engine.get(`/chat/${c.id}`));
-                        this.emit('contact:updated', person, new this.Chat(cached_chat ?? { id: c.id, name: person.name }), this);
-                    }
-                }
-            }
-        }
-    }
-    /** @internal */
-    async #handle_lid_mapping(lid, pn) {
-        await this.engine.set(`/lid/${lid}`, serialize(pn));
-        await this.engine.set(`/lid/${pn}`, serialize(lid));
-    }
-    /**
-     * Actividad del chat según su último mensaje persistido. Es el respaldo para los
-     * documentos que se guardaron antes de que el chat llevara su propia marca.
-     * Chat activity from its last persisted message. It is the fallback for documents stored
-     * before the chat carried its own stamp.
-     *
-     * @param cid - Identificador del chat / Chat identifier
-     * @returns Epoch ms del último mensaje, o 0 si el chat no tiene ninguno / Last message epoch ms, or 0 when the chat has none
-     * @internal
-     */
-    async #activity(cid) {
-        const [raw] = await this.engine.list(`/chat/${cid}/message`, 0, 1);
-        return deserialize(raw ?? null)?.created_at ?? 0;
-    }
-    /** @internal */
-    async #handle_chats_upsert(chats) {
-        for (const ch of chats) {
-            if (ch.id) {
-                const current = deserialize(await this.engine.get(`/chat/${ch.id}`));
-                const raw = current ?? {
-                    id: ch.id,
-                    name: ch.name ?? null,
-                    archived: ch.archived ?? null,
-                    pinned: ch.pinned ?? null,
-                    mute_end_time: ch.muteEndTime != null ? Number(ch.muteEndTime) : null,
-                    unread_count: ch.unreadCount ?? null,
-                };
-                if (ch.name) {
-                    raw.name = ch.name;
-                }
-                // El sync trae la última actividad del chat; sin ella la lista quedaría ordenada
-                // por el momento en que se escribió cada documento.
-                // The sync carries the chat's last activity; without it the list would be ordered
-                // by the moment each document happened to be written.
-                const stamp = ch.conversationTimestamp != null ? Number(ch.conversationTimestamp) * 1_000 : null;
-                raw.activity = Math.max(stamp ?? 0, raw.activity ?? 0, await this.#activity(ch.id)) || null;
-                await this.engine.set(`/chat/${ch.id}`, serialize(raw), raw.activity ?? 0);
-                if (current === null) {
-                    this.emit('chat:created', new this.Chat(raw), this);
-                }
-            }
-        }
-    }
-    /** @internal */
-    async #handle_chats_update(chats) {
-        for (const ch of chats) {
-            if (ch.id && ch.id !== 'status@broadcast') {
-                const current = deserialize(await this.engine.get(`/chat/${ch.id}`)) ?? {
-                    id: ch.id,
-                    name: ch.name ?? null,
-                };
-                const patch = {};
-                const pinned_changed = 'pinned' in ch;
-                const archived_changed = ch.archived !== undefined;
-                const mute_changed = 'muteEndTime' in ch;
-                if (ch.name) {
-                    patch.name = ch.name;
-                }
-                if (pinned_changed) {
-                    patch.pinned = ch.pinned ?? null;
-                }
-                if (archived_changed) {
-                    patch.archived = ch.archived ?? false;
-                }
-                if (mute_changed) {
-                    patch.mute_end_time = ch.muteEndTime != null ? Number(ch.muteEndTime) : null;
-                }
-                if (ch.unreadCount != null) {
-                    patch.unread_count = ch.unreadCount;
-                }
-                if (Object.keys(patch).length > 0) {
-                    const merged = { ...current, ...patch };
-                    // Fijar, archivar o silenciar no es actividad: el chat conserva su posición.
-                    // Pinning, archiving or muting is not activity: the chat keeps its position.
-                    await this.engine.set(`/chat/${ch.id}`, serialize(merged), merged.activity ?? undefined);
-                    if (pinned_changed) {
-                        this.emit(ch.pinned != null ? 'chat:pinned' : 'chat:unpinned', new this.Chat(merged), this);
-                    }
-                    if (archived_changed) {
-                        this.emit(ch.archived ? 'chat:archived' : 'chat:unarchived', new this.Chat(merged), this);
-                    }
-                    if (mute_changed) {
-                        const is_muted = patch.mute_end_time != null && patch.mute_end_time > Date.now();
-                        this.emit(is_muted ? 'chat:muted' : 'chat:unmuted', new this.Chat(merged), this);
-                    }
-                }
-            }
-        }
-    }
-    /** @internal */
-    async #handle_chats_delete(ids) {
-        for (const cid of ids) {
-            const raw = deserialize(await this.engine.get(`/chat/${cid}`)) ?? { id: cid };
-            await this.engine.unset(`/chat/${cid}`);
-            this.emit('chat:deleted', new this.Chat(raw), this);
-        }
-    }
-    /** @internal */
-    async #handle_message_receipt(updates) {
-        for (const { key, receipt } of updates) {
-            // Receipt sobre status@broadcast → marca el feed como visto y emite feed:updated.
-            // Receipt on status@broadcast → marks feed viewed and emits feed:updated.
-            if (key.remoteJid === 'status@broadcast' && key.id) {
-                const feed_raw = deserialize(await this.engine.get(`/status/${key.id}`));
-                if (feed_raw && !feed_raw.viewed) {
-                    feed_raw.viewed = true;
-                    await this.engine.set(`/status/${key.id}`, serialize(feed_raw));
-                    this.emit('feed:updated', new Feed(this, feed_raw), this);
-                }
-                continue;
-            }
-            if (key.remoteJid && key.id && (receipt.readTimestamp != null || receipt.playedTimestamp != null)) {
-                const found = await this.#locate(key.remoteJid, key.id);
-                if (found) {
-                    const { path, doc } = found;
-                    const next = receipt.playedTimestamp != null ? PLAYED : READ;
-                    if (doc.status < next) {
-                        doc.status = next;
-                        doc.raw.status = next;
-                        await this.engine.set(path, serialize(doc), doc.created_at);
-                    }
-                    const msg_instance = message(this, doc);
-                    this.emit('message:seen', msg_instance, await msg_instance.chat(), this);
-                }
-            }
-        }
-    }
-    /** @internal */
-    async #handle_messages_upsert(messages) {
-        for (const msg of messages) {
-            if (msg.key?.remoteJid && msg.key.id) {
-                const cid = msg.key.remoteJidAlt ?? msg.key.remoteJid;
-                const mid = msg.key.id;
-                const content_type = getContentType(msg.message ?? {});
-                if (content_type === 'reactionMessage') {
-                    // Canal único para reacciones: se procesa aquí y se ignora `messages.reaction`.
-                    // Single channel for reactions: handled here; `messages.reaction` is disabled.
-                    const reaction = msg.message?.reactionMessage;
-                    if (reaction?.key?.id && reaction.key.remoteJid) {
-                        const target_cid = (await this.#resolve_jid(reaction.key.remoteJid)) ?? reaction.key.remoteJid;
-                        await this.#handle_messages_reaction([{
-                                key: {
-                                    remoteJid: target_cid,
-                                    id: reaction.key.id,
-                                    participant: msg.key.fromMe ? (this.#internals.socket?.user?.id ?? null) : (msg.key.participant ?? cid),
-                                },
-                                reaction: { text: reaction.text ?? '' },
-                            }]);
-                    }
-                    continue;
-                }
-                // Status broadcast — flujo dedicado. Nunca emite `message:*`.
-                // Status broadcast — dedicated flow. Never emits `message:*`.
-                if (msg.key.remoteJid === 'status@broadcast') {
-                    if (content_type === 'protocolMessage') {
-                        const protocol = msg.message?.protocolMessage;
-                        if (protocol?.type === proto.Message.ProtocolMessage.Type.REVOKE &&
-                            protocol.key?.id) {
-                            const feed_raw = deserialize(await this.engine.get(`/status/${protocol.key.id}`));
-                            if (feed_raw) {
-                                await this.engine.unset(`/status/${protocol.key.id}`);
-                                this.emit('feed:deleted', new Feed(this, feed_raw), this);
+                socket.ev.on('chats.upsert', (rows) => {
+                    chain = chain.then(async () => {
+                        for (const row of rows) {
+                            if (row.id) {
+                                const current = deserialize(await engine.get(`/chat/${row.id}`));
+                                const doc = current ?? {
+                                    id: row.id,
+                                    name: row.name ?? null,
+                                    archived: row.archived ?? null,
+                                    pinned: row.pinned ?? null,
+                                    mute_end_time: row.muteEndTime != null ? Number(row.muteEndTime) : null,
+                                    unread_count: row.unreadCount ?? null,
+                                };
+                                if (row.name) {
+                                    doc.name = row.name;
+                                }
+                                const [newest] = await engine.list(`/chat/${row.id}/message`, 0, 1);
+                                doc.activity = Math.max(row.conversationTimestamp != null ? Number(row.conversationTimestamp) * 1_000 : 0, doc.activity ?? 0, deserialize(newest ?? null)?.created_at ?? 0) || null;
+                                await engine.set(`/chat/${row.id}`, serialize(doc), doc.activity ?? 0);
+                                if (!current) {
+                                    this.emit('chat:created', new this.Chat(doc), this);
+                                }
                             }
                         }
-                        continue;
-                    }
-                    const FEED_TYPE_MAP = {
-                        conversation: 'text',
-                        extendedTextMessage: 'text',
-                        imageMessage: 'image',
-                        videoMessage: 'video',
-                        audioMessage: 'audio',
-                    };
-                    const feed_type = FEED_TYPE_MAP[content_type ?? ''];
-                    const author = msg.key.participant ?? '';
-                    if (!feed_type || !author) {
-                        continue;
-                    }
-                    const msg_content = msg.message?.[content_type];
-                    let caption = '';
-                    let mime = 'text/plain';
-                    if (typeof msg_content === 'string') {
-                        caption = msg_content;
-                    }
-                    else if (msg_content && typeof msg_content === 'object') {
-                        caption =
-                            msg_content.caption ??
-                                msg_content.text ??
-                                '';
-                        if (feed_type !== 'text') {
-                            mime = msg_content.mimetype ?? 'application/octet-stream';
-                        }
-                    }
-                    const created_at = (Number(msg.messageTimestamp) || Math.floor(Date.now() / 1000)) * 1000;
-                    const feed_raw = {
-                        id: mid,
-                        author_jid: author,
-                        type: feed_type,
-                        caption,
-                        mime,
-                        created_at,
-                        expires_at: created_at + FEED_TTL_MS,
-                        viewed: false,
-                        raw: msg,
-                    };
-                    let content_buf = Buffer.alloc(0);
-                    if (feed_type === 'text') {
-                        content_buf = Buffer.from(caption, 'utf-8');
-                    }
-                    else if (this.#internals.socket) {
-                        try {
-                            const buf = await downloadMediaMessage(msg, 'buffer', {});
-                            if (Buffer.isBuffer(buf)) {
-                                content_buf = buf;
+                    }).catch(() => { });
+                });
+                socket.ev.on('chats.update', (rows) => {
+                    chain = chain.then(async () => {
+                        for (const row of rows) {
+                            if (row.id && row.id !== 'status@broadcast') {
+                                const current = deserialize(await engine.get(`/chat/${row.id}`)) ?? { id: row.id, name: row.name ?? null };
+                                const patch = {};
+                                const events = [];
+                                if (row.name) {
+                                    patch.name = row.name;
+                                }
+                                if (row.unreadCount != null) {
+                                    patch.unread_count = row.unreadCount;
+                                }
+                                if ('pinned' in row) {
+                                    patch.pinned = row.pinned ?? null;
+                                    events.push(row.pinned != null ? 'chat:pinned' : 'chat:unpinned');
+                                }
+                                if (row.archived !== undefined) {
+                                    patch.archived = row.archived ?? false;
+                                    events.push(row.archived ? 'chat:archived' : 'chat:unarchived');
+                                }
+                                if ('muteEndTime' in row) {
+                                    patch.mute_end_time = row.muteEndTime != null ? Number(row.muteEndTime) : null;
+                                    events.push(patch.mute_end_time != null && patch.mute_end_time > Date.now() ? 'chat:muted' : 'chat:unmuted');
+                                }
+                                if (Object.keys(patch).length > 0) {
+                                    const doc = { ...current, ...patch };
+                                    await engine.set(`/chat/${row.id}`, serialize(doc), doc.activity ?? undefined);
+                                    for (const event of events) {
+                                        this.emit(event, new this.Chat(doc), this);
+                                    }
+                                }
                             }
                         }
-                        catch {
-                            /* media download may fail */
+                    }).catch(() => { });
+                });
+                socket.ev.on('chats.delete', (ids) => {
+                    chain = chain.then(async () => {
+                        for (const cid of ids) {
+                            const doc = deserialize(await engine.get(`/chat/${cid}`)) ?? { id: cid };
+                            await engine.unset(`/chat/${cid}`);
+                            this.emit('chat:deleted', new this.Chat(doc), this);
                         }
-                    }
-                    await this.engine.set(`/status/${mid}`, serialize(feed_raw));
-                    if (content_buf.length > 0) {
-                        await this.#write_content(`/status/${mid}/content`, content_buf);
-                    }
-                    this.emit('feed:created', new Feed(this, feed_raw), this);
-                    continue;
-                }
-                if (content_type === 'pollUpdateMessage') {
-                    const update = msg.message?.pollUpdateMessage;
-                    const creation_key = update?.pollCreationMessageKey;
-                    if (creation_key?.id &&
-                        creation_key.remoteJid &&
-                        update?.vote?.encPayload &&
-                        update.vote.encIv) {
-                        const resolved_cid = (await this.#resolve_jid(creation_key.remoteJid)) ?? creation_key.remoteJid;
-                        const target_mid = creation_key.id;
-                        const poll_doc = deserialize(await this.engine.get(`/chat/${resolved_cid}/message/${target_mid}`));
-                        const secret_raw = poll_doc?.raw.message?.messageContextInfo?.messageSecret;
-                        const message_secret = typeof secret_raw === 'string' ? Buffer.from(secret_raw, 'base64') : secret_raw;
-                        if (poll_doc && message_secret) {
-                            try {
-                                const poll_key = poll_doc.raw.key ?? {};
-                                // La identidad propia del HMAC depende del addressing del chat
-                                // (LID en @lid, PN en @s.whatsapp.net), así que para las posiciones
-                                // fromMe se intenta descifrar con ambas: AES-GCM autentica, la
-                                // clave equivocada lanza y se prueba la siguiente.
-                                // Own HMAC identity depends on chat addressing (LID on @lid, PN on
-                                // @s.whatsapp.net), so fromMe positions try both candidates:
-                                // AES-GCM authenticates, a wrong key throws and the next is tried.
-                                const self_id = this.#internals.socket?.user?.id ?? '';
-                                const self_lid = this.#internals.socket?.user?.lid ?? '';
-                                const selves = [...new Set([self_lid, self_id].filter(Boolean))];
-                                // Candidatos foráneos: todas las formas de identidad del key (LID,
-                                // participant, alt, remoteJid); se prueban todas porque el addressing
-                                // del stanza varía (LID vs PN) según la migración del contacto.
-                                const foreign_of = (k) => [...new Set([k.remoteJid, k.participant, k.remoteJidAlt, k.remoteJid].filter((x) => Boolean(x)))];
-                                const voters = msg.key.fromMe ? selves : foreign_of(msg.key);
-                                const creators = poll_key.fromMe ? selves : foreign_of(poll_key);
-                                let decrypted = null;
-                                for (const voter of voters) {
-                                    for (const creator of creators) {
+                    }).catch(() => { });
+                });
+                socket.ev.on('messages.upsert', ({ messages }) => {
+                    chain = chain.then(async () => {
+                        for (const msg of messages) {
+                            const cid = msg.key?.remoteJidAlt ?? msg.key?.remoteJid;
+                            const mid = msg.key?.id;
+                            if (!cid || !mid) {
+                                continue;
+                            }
+                            const kind = getContentType(msg.message ?? {});
+                            if (kind === 'reactionMessage') {
+                                const target = msg.message?.reactionMessage;
+                                const found = target?.key?.id && target.key.remoteJid ? await locate(target.key.remoteJid, target.key.id) : null;
+                                if (found && target) {
+                                    const author = jidNormalizedUser((msg.key.fromMe ? socket.user?.id : msg.key.participant ?? cid) ?? cid);
+                                    const emoji = target.text ?? '';
+                                    found.doc.reactions = [
+                                        ...(found.doc.reactions ?? []).filter((entry) => entry.author !== author),
+                                        ...(emoji ? [{ author, emoji, at: Date.now() }] : []),
+                                    ];
+                                    await engine.set(found.path, serialize(found.doc), found.doc.created_at);
+                                    const instance = new Message(init, found.doc);
+                                    this.emit('message:reacted', instance, await instance.chat(), emoji, this);
+                                }
+                                continue;
+                            }
+                            if (msg.key.remoteJid === 'status@broadcast') {
+                                const revoked = kind === 'protocolMessage' && msg.message?.protocolMessage?.type === proto.Message.ProtocolMessage.Type.REVOKE
+                                    ? msg.message.protocolMessage.key?.id
+                                    : null;
+                                if (revoked) {
+                                    const gone = deserialize(await engine.get(`/status/${revoked}`));
+                                    if (gone) {
+                                        await engine.unset(`/status/${revoked}`);
+                                        this.emit('feed:deleted', new Feed(init, gone), this);
+                                    }
+                                    continue;
+                                }
+                                const type = { conversation: 'text', extendedTextMessage: 'text', imageMessage: 'image', videoMessage: 'video', audioMessage: 'audio' }[kind ?? ''];
+                                const author = msg.key.participant ?? '';
+                                if (!type || !author) {
+                                    continue;
+                                }
+                                const body = msg.message?.[kind];
+                                const caption = typeof body === 'string' ? body : (body?.caption ?? body?.text ?? '');
+                                const created_at = (Number(msg.messageTimestamp) || Math.floor(Date.now() / 1_000)) * 1_000;
+                                const doc = {
+                                    id: mid,
+                                    author_jid: author,
+                                    type,
+                                    caption,
+                                    mime: type === 'text' ? 'text/plain' : ((typeof body === 'object' && body?.mimetype) || 'application/octet-stream'),
+                                    created_at,
+                                    expires_at: created_at + FEED_TTL_MS,
+                                    viewed: false,
+                                    raw: msg,
+                                };
+                                const binary = type === 'text'
+                                    ? Buffer.from(caption, 'utf-8')
+                                    : await downloadMediaMessage(msg, 'buffer', {}).catch(() => Buffer.alloc(0));
+                                await engine.set(`/status/${mid}`, serialize(doc));
+                                if (binary.length > 0) {
+                                    await (engine.set_buffer?.(`/status/${mid}/content`, binary) ?? engine.set(`/status/${mid}/content`, serialize({ data: binary.toString('base64') })));
+                                }
+                                this.emit('feed:created', new Feed(init, doc), this);
+                                continue;
+                            }
+                            if (kind === 'pollUpdateMessage') {
+                                const key = msg.message?.pollUpdateMessage?.pollCreationMessageKey;
+                                const vote = msg.message?.pollUpdateMessage?.vote;
+                                const found = key?.id && key.remoteJid ? await locate(key.remoteJid, key.id) : null;
+                                const raw_secret = found?.doc.raw.message?.messageContextInfo?.messageSecret;
+                                const secret = typeof raw_secret === 'string' ? Buffer.from(raw_secret, 'base64') : raw_secret;
+                                if (found && secret && vote?.encPayload && vote.encIv) {
+                                    const mine = [socket.user?.lid, socket.user?.id];
+                                    const theirs = (from) => [from.remoteJid, from.participant, from.remoteJidAlt];
+                                    const voters = (msg.key.fromMe ? mine : theirs(msg.key)).filter((id) => Boolean(id));
+                                    const creators = (found.doc.raw.key?.fromMe ? mine : theirs(found.doc.raw.key ?? {})).filter((id) => Boolean(id));
+                                    for (const pair of voters.flatMap((who) => creators.map((creator) => [who, creator]))) {
                                         try {
-                                            decrypted = decryptPollVote({ encPayload: update.vote.encPayload, encIv: update.vote.encIv }, {
-                                                pollCreatorJid: jidNormalizedUser(creator),
-                                                pollMsgId: target_mid,
-                                                pollEncKey: message_secret,
-                                                voterJid: jidNormalizedUser(voter),
+                                            updateMessageWithPollUpdate(found.doc.raw, {
+                                                pollUpdateMessageKey: msg.key,
+                                                vote: decryptPollVote({ encPayload: vote.encPayload, encIv: vote.encIv }, {
+                                                    pollCreatorJid: jidNormalizedUser(pair[1]),
+                                                    pollMsgId: found.doc.id,
+                                                    pollEncKey: secret,
+                                                    voterJid: jidNormalizedUser(pair[0]),
+                                                }),
+                                                senderTimestampMs: Number(msg.messageTimestamp) || Date.now(),
                                             });
+                                            await engine.set(found.path, serialize(found.doc), found.doc.created_at);
+                                            const instance = new Message(init, found.doc);
+                                            this.emit('message:updated', instance, await instance.chat(), this);
                                             break;
                                         }
                                         catch {
-                                            /* identidad equivocada: probar la siguiente */
+                                            /* identidad equivocada / wrong identity */
                                         }
                                     }
-                                    if (decrypted) {
-                                        break;
-                                    }
                                 }
-                                if (decrypted) {
-                                    updateMessageWithPollUpdate(poll_doc.raw, {
-                                        pollUpdateMessageKey: msg.key,
-                                        vote: decrypted,
-                                        senderTimestampMs: Number(msg.messageTimestamp) || Date.now(),
-                                    });
-                                    await this.engine.set(`/chat/${resolved_cid}/message/${target_mid}`, serialize(poll_doc), poll_doc.created_at);
-                                    const msg_instance = message(this, poll_doc);
-                                    this.emit('message:updated', msg_instance, await msg_instance.chat(), this);
+                                continue;
+                            }
+                            if (kind === 'protocolMessage') {
+                                const protocol = msg.message?.protocolMessage;
+                                const found = protocol?.key?.id ? await locate(protocol.key.remoteJid ?? cid, protocol.key.id) : null;
+                                if (found && protocol?.type === proto.Message.ProtocolMessage.Type.MESSAGE_EDIT && protocol.editedMessage) {
+                                    found.doc.raw.message = protocol.editedMessage;
+                                    found.doc.edited = true;
+                                    found.doc.caption = new Message(init, found.doc.raw).caption;
+                                    await engine.set(found.path, serialize(found.doc), found.doc.created_at);
+                                    const instance = new Message(init, found.doc);
+                                    this.emit('message:updated', instance, await instance.chat(), this);
+                                }
+                                else if (found && protocol?.type === proto.Message.ProtocolMessage.Type.REVOKE) {
+                                    await engine.unset(found.path);
+                                    const instance = new Message(init, found.doc);
+                                    this.emit('message:deleted', instance, await instance.chat(), this);
                                 }
+                                continue;
                             }
-                            catch {
-                                /* decrypt may fail */
+                            const doc = new Message(init, msg)._raw;
+                            const stored = deserialize(await engine.get(`/chat/${cid}/message/${mid}`));
+                            if (stored) {
+                                doc.multiple = typeof stored.multiple === 'boolean' ? stored.multiple : doc.multiple;
+                                doc.reactions = stored.reactions ?? doc.reactions;
+                                const advanced = doc.status > stored.status;
+                                doc.status = Math.max(stored.status, doc.status);
+                                if (!advanced && stored.caption === doc.caption && stored.edited === doc.edited && stored.starred === doc.starred) {
+                                    continue;
+                                }
                             }
-                        }
-                    }
-                    continue;
-                }
-                if (content_type === 'protocolMessage') {
-                    const protocol = msg.message?.protocolMessage;
-                    if (protocol?.key?.id) {
-                        const target_mid = protocol.key.id;
-                        const target_cid = protocol.key.remoteJid ?? cid;
-                        const doc = deserialize(await this.engine.get(`/chat/${target_cid}/message/${target_mid}`));
-                        if (protocol.type === proto.Message.ProtocolMessage.Type.MESSAGE_EDIT &&
-                            protocol.editedMessage &&
-                            doc) {
-                            doc.raw.message = protocol.editedMessage;
-                            doc.edited = true;
-                            doc.caption = message(this, doc.raw).caption;
-                            await this.engine.set(`/chat/${target_cid}/message/${target_mid}`, serialize(doc), doc.created_at);
-                            const msg_instance = message(this, doc);
-                            this.emit('message:updated', msg_instance, await msg_instance.chat(), this);
-                        }
-                        else if (protocol.type === proto.Message.ProtocolMessage.Type.REVOKE) {
-                            await this.engine.unset(`/chat/${target_cid}/message/${target_mid}`);
-                            if (doc) {
-                                const msg_instance = message(this, doc);
-                                this.emit('message:deleted', msg_instance, await msg_instance.chat(), this);
+                            if (!stored && !doc.me) {
+                                const known = deserialize(await engine.get(`/contact/${doc.author}`));
+                                if (doc.author && !(known?.name ?? known?.notify ?? known?.verified_name)) {
+                                    socket.ev.emit('contacts.upsert', [{
+                                            id: doc.author,
+                                            lid: msg.key.remoteJid?.endsWith('@lid') ? msg.key.remoteJid : undefined,
+                                            notify: msg.pushName ?? undefined,
+                                            verifiedName: msg.verifiedBizName ?? undefined,
+                                        }]);
+                                }
+                                if (!(await engine.get(`/chat/${cid}`))) {
+                                    const owner = { id: cid, name: cid.endsWith('@g.us') ? null : msg.pushName ?? null, activity: doc.created_at };
+                                    await engine.set(`/chat/${cid}`, serialize(owner), doc.created_at);
+                                    this.emit('chat:created', new this.Chat(owner), this);
+                                }
+                            }
+                            await engine.set(`/chat/${cid}/message/${mid}`, serialize(doc), doc.created_at);
+                            const owner = deserialize(await engine.get(`/chat/${cid}`));
+                            if (owner && doc.created_at > (owner.activity ?? 0)) {
+                                owner.activity = doc.created_at;
+                                await engine.set(`/chat/${cid}`, serialize(owner), doc.created_at);
+                            }
+                            if (!stored) {
+                                const place = msg.message?.locationMessage ?? msg.message?.liveLocationMessage;
+                                const poll = msg.message?.pollCreationMessage ?? msg.message?.pollCreationMessageV2 ?? msg.message?.pollCreationMessageV3;
+                                const cards = msg.message?.contactsArrayMessage?.contacts ?? (msg.message?.contactMessage ? [msg.message.contactMessage] : []);
+                                const body = doc.type === 'text' ? doc.caption
+                                    : doc.type === 'location' ? JSON.stringify({ lat: place?.degreesLatitude, lng: place?.degreesLongitude })
+                                        : doc.type === 'poll' ? JSON.stringify({ content: poll?.name ?? '', options: poll?.options?.map((option) => ({ content: option.optionName })) ?? [] })
+                                            : doc.type === 'vcard' ? cards.map((card) => card.vcard ?? '').join('\n')
+                                                : doc.type === 'event' ? JSON.stringify(msg.message?.eventMessage ?? {})
+                                                    : null;
+                                const binary = body !== null
+                                    ? Buffer.from(body, 'utf-8')
+                                    : ['image', 'video', 'audio', 'document'].includes(doc.type)
+                                        ? await downloadMediaMessage(msg, 'buffer', {}).catch(() => Buffer.alloc(0))
+                                        : Buffer.alloc(0);
+                                if (binary.length > 0) {
+                                    await (engine.set_buffer?.(`/chat/${cid}/message/${mid}/content`, binary) ?? engine.set(`/chat/${cid}/message/${mid}/content`, serialize({ data: binary.toString('base64') })));
+                                }
+                            }
+                            const instance = new Message(init, doc);
+                            const owner_chat = await instance.chat();
+                            this.emit('message:created', instance, owner_chat, this);
+                            if (doc.forwarded) {
+                                this.emit('message:forwarded', instance, owner_chat, this);
                             }
                         }
-                    }
-                    continue;
-                }
-                const doc = message(this, msg)._raw;
-                // Cada reconexión re-entrega el historial completo: reescribir documentos
-                // idénticos contamina la cronología, re-descarga la media y spamea eventos,
-                // así que un doc ya persistido sin cambios visibles se salta entero.
-                // Every reconnect re-delivers the full history: rewriting identical documents
-                // pollutes chronology, re-downloads media and spams events, so an already
-                // persisted doc without visible changes is skipped entirely.
-                const existing_doc = deserialize(await this.engine.get(`/chat/${cid}/message/${mid}`));
-                if (existing_doc) {
-                    if (typeof existing_doc.multiple === 'boolean') {
-                        doc.multiple = existing_doc.multiple;
-                    }
-                    if (existing_doc.reactions) {
-                        doc.reactions = existing_doc.reactions;
-                    }
-                    // El historial reporta el estado que tenía al sincronizarse: si acá se reescribe
-                    // por otro cambio (edición, destacado), el estado ya conocido se conserva.
-                    // History reports the state it had when synced: if the doc gets rewritten here
-                    // for another change (edit, star), the state already known is kept.
-                    if (existing_doc.status > doc.status) {
-                        doc.status = existing_doc.status;
-                    }
-                    if (existing_doc.status >= doc.status &&
-                        existing_doc.caption === doc.caption &&
-                        existing_doc.edited === doc.edited &&
-                        existing_doc.starred === doc.starred) {
-                        continue;
-                    }
-                }
-                // Autocreación de contacto/chat desde pushName cuando baileys no emite upsert previo
-                if (!existing_doc && !doc.me) {
-                    const push_name = msg.pushName ?? null;
-                    const is_group = cid.endsWith('@g.us');
-                    // El contacto se completa cuando no existe y también cuando existe sin ningún
-                    // nombre: el mensaje trae el pushName y el nombre del negocio verificado, que
-                    // es lo único que queda si un re-sync anterior dejó la ficha en blanco.
-                    // The contact is filled in when missing and also when it exists with no name at
-                    // all: the message carries the pushName and the verified business name, the only
-                    // thing left when an earlier re-sync blanked the card.
-                    if (doc.author) {
-                        const known = deserialize(await this.engine.get(`/contact/${doc.author}`));
-                        if (!known || !(known.name ?? known.notify ?? known.verified_name)) {
-                            await this.#persist_contact({
-                                id: doc.author,
-                                lid: msg.key.remoteJid?.endsWith('@lid') ? msg.key.remoteJid : null,
-                                name: null,
-                                notify: push_name,
-                                verified_name: msg.verifiedBizName ?? null,
-                                img_url: null,
-                                status: null,
-                            });
+                    }).catch(() => { });
+                });
+                socket.ev.on('messages.update', (updates) => {
+                    chain = chain.then(async () => {
+                        for (const { key, update } of updates) {
+                            const found = key.remoteJid && key.id && key.remoteJid !== 'status@broadcast'
+                                ? await locate(key.remoteJid, key.id)
+                                : null;
+                            if (found) {
+                                const { path, doc } = found;
+                                const patch = update;
+                                const raw = doc.raw ?? { key };
+                                if (patch.message) {
+                                    const edited = patch.message.editedMessage?.message;
+                                    raw.message = edited ?? { ...raw.message, ...patch.message };
+                                    doc.edited = doc.edited || Boolean(edited);
+                                    doc.caption = new Message(init, raw).caption;
+                                    doc.raw = raw;
+                                    await engine.set(path, serialize(doc), doc.created_at);
+                                    const instance = new Message(init, doc);
+                                    this.emit('message:updated', instance, await instance.chat(), this);
+                                }
+                                else if (patch.starred !== undefined) {
+                                    doc.starred = patch.starred === true;
+                                    raw.starred = doc.starred;
+                                    doc.raw = raw;
+                                    await engine.set(path, serialize(doc), doc.created_at);
+                                    const instance = new Message(init, doc);
+                                    this.emit(doc.starred ? 'message:starred' : 'message:unstarred', instance, await instance.chat(), this);
+                                }
+                                else if (patch.status !== undefined && (patch.status > doc.status || patch.status === proto.WebMessageInfo.Status.ERROR)) {
+                                    raw.status = patch.status;
+                                    doc.status = patch.status;
+                                    raw.messageStubParameters = patch.messageStubParameters ?? raw.messageStubParameters;
+                                    doc.raw = raw;
+                                    await engine.set(path, serialize(doc), doc.created_at);
+                                    const instance = new Message(init, doc);
+                                    this.emit('message:updated', instance, await instance.chat(), this);
+                                }
+                            }
                         }
-                    }
-                    if (!(await this.engine.get(`/chat/${cid}`))) {
-                        const chat_raw = {
-                            id: cid,
-                            name: is_group ? null : push_name,
-                            activity: doc.created_at,
-                        };
-                        await this.engine.set(`/chat/${cid}`, serialize(chat_raw), doc.created_at);
-                        this.emit('chat:created', new this.Chat(chat_raw), this);
-                    }
-                }
-                await this.engine.set(`/chat/${cid}/message/${mid}`, serialize(doc), doc.created_at);
-                // El mensaje más nuevo define la posición del chat en la lista; un mensaje viejo
-                // que llega en un re-sync no la altera.
-                // The newest message defines the chat's position in the list; an old message
-                // arriving in a re-sync does not move it.
-                const chat_doc = deserialize(await this.engine.get(`/chat/${cid}`));
-                if (chat_doc && doc.created_at > (chat_doc.activity ?? 0)) {
-                    chat_doc.activity = doc.created_at;
-                    await this.engine.set(`/chat/${cid}`, serialize(chat_doc), doc.created_at);
-                }
-                // El binario solo se materializa en la primera entrega; en re-syncs ya vive en el engine.
-                // The binary is only materialized on first delivery; on re-syncs it already lives in the engine.
-                let content_buf = Buffer.alloc(0);
-                if (existing_doc) {
-                    /* ya materializado / already materialized */
-                }
-                else if (doc.type === 'text') {
-                    content_buf = Buffer.from(doc.caption, 'utf-8');
-                }
-                else if (doc.type === 'location') {
-                    const loc = msg.message?.locationMessage ?? msg.message?.liveLocationMessage;
-                    content_buf = Buffer.from(JSON.stringify({ lat: loc?.degreesLatitude, lng: loc?.degreesLongitude }), 'utf-8');
-                }
-                else if (doc.type === 'poll') {
-                    const poll = msg.message?.pollCreationMessage ??
-                        msg.message?.pollCreationMessageV2 ??
-                        msg.message?.pollCreationMessageV3;
-                    content_buf = Buffer.from(JSON.stringify({
-                        content: poll?.name ?? '',
-                        options: poll?.options?.map((o) => ({ content: o.optionName })) ?? [],
-                    }), 'utf-8');
-                }
-                else if (doc.type === 'vcard') {
-                    const cards = msg.message?.contactsArrayMessage?.contacts ?? (msg.message?.contactMessage ? [msg.message.contactMessage] : []);
-                    content_buf = Buffer.from(cards.map((c) => c.vcard ?? '').join('\n'), 'utf-8');
-                }
-                else if (doc.type === 'event') {
-                    content_buf = Buffer.from(JSON.stringify(msg.message?.eventMessage ?? {}), 'utf-8');
-                }
-                else if (this.#internals.socket && ['image', 'video', 'audio', 'document'].includes(doc.type)) {
-                    try {
-                        const buffer = await downloadMediaMessage(msg, 'buffer', {});
-                        if (Buffer.isBuffer(buffer)) {
-                            content_buf = buffer;
+                    }).catch(() => { });
+                });
+                socket.ev.on('message-receipt.update', (updates) => {
+                    chain = chain.then(async () => {
+                        for (const { key, receipt } of updates) {
+                            if (key.remoteJid === 'status@broadcast' && key.id) {
+                                const doc = deserialize(await engine.get(`/status/${key.id}`));
+                                if (doc && !doc.viewed) {
+                                    doc.viewed = true;
+                                    await engine.set(`/status/${key.id}`, serialize(doc));
+                                    this.emit('feed:updated', new Feed(init, doc), this);
+                                }
+                                continue;
+                            }
+                            const played = receipt.playedTimestamp != null;
+                            const found = (played || receipt.readTimestamp != null) && key.remoteJid && key.id
+                                ? await locate(key.remoteJid, key.id)
+                                : null;
+                            if (found) {
+                                const next = played ? proto.WebMessageInfo.Status.PLAYED : proto.WebMessageInfo.Status.READ;
+                                if (found.doc.status < next) {
+                                    found.doc.status = next;
+                                    found.doc.raw.status = next;
+                                    await engine.set(found.path, serialize(found.doc), found.doc.created_at);
+                                }
+                                const instance = new Message(init, found.doc);
+                                this.emit('message:seen', instance, await instance.chat(), this);
+                            }
                         }
-                    }
-                    catch {
-                        /* media download may fail */
-                    }
+                    }).catch(() => { });
+                });
+            };
+            this.#close = async (quiet) => {
+                intentional = true;
+                silent = quiet;
+                if (timer) {
+                    clearTimeout(timer);
+                    timer = null;
                 }
-                if (content_buf.length > 0) {
-                    await this.#write_content(`/chat/${cid}/message/${mid}/content`, content_buf);
+                try {
+                    alive?.end(Object.assign(new Error('intentional close'), { output: { statusCode: DisconnectReason.connectionClosed } }));
                 }
-                const instance = message(this, doc);
-                const chat_instance = await instance.chat();
-                this.emit('message:created', instance, chat_instance, this);
-                if (doc.forwarded) {
-                    this.emit('message:forwarded', instance, chat_instance, this);
+                catch {
+                    /* el socket ya estaba cerrado / socket already closed */
                 }
-            }
-        }
+                alive = null;
+            };
+            start().catch(reject);
+        });
     }
     /**
-     * Ubica el documento de un mensaje partiendo del chat crudo del key. Los updates y
-     * receipts llegan direccionados por LID —con o sin dispositivo— mientras el documento
-     * vive bajo el JID con el que se guardó, así que se prueban ambas formas.
-     * Locates a message document from the raw chat in the key. Updates and receipts arrive
-     * LID-addressed —with or without device— while the document lives under the JID it was
-     * stored with, so both forms are tried.
+     * Cierra la sesión: cancela el reintento pendiente y termina el socket.
+     * Closes the session: cancels the pending retry and ends the socket.
      *
-     * @param cid - Chat tal como viene en el key / Chat as it comes in the key
-     * @param mid - Identificador del mensaje / Message identifier
-     * @returns Ruta y documento, o null si no existe / Path and document, or null when missing
-     * @internal
+     * @param options - `silent` calla el evento `disconnected`; `destroy` vacía el engine / `silent` mutes the `disconnected` event; `destroy` clears the engine
      */
-    async #locate(cid, mid) {
-        const tried = new Set();
-        for (const candidate of [await this.#resolve_jid(cid), cid, jidNormalizedUser(cid)]) {
-            if (candidate && !tried.has(candidate)) {
-                tried.add(candidate);
-                const path = `/chat/${candidate}/message/${mid}`;
-                const doc = deserialize(await this.engine.get(path));
-                if (doc) {
-                    return { path, doc };
-                }
-            }
-        }
-        return null;
-    }
-    /** @internal */
-    async #handle_messages_update(updates) {
-        for (const { key, update: upd } of updates) {
-            if (key.remoteJid && key.id) {
-                // Updates sobre `status@broadcast` se descartan: el feed sólo se
-                // muta vía reacciones (`messages.reaction`), `Feed.view()` o REVOKE.
-                // Updates on `status@broadcast` are discarded: feed mutates only via
-                // reactions, `Feed.view()` or REVOKE.
-                if (key.remoteJid === 'status@broadcast') {
-                    continue;
-                }
-                const found = await this.#locate(key.remoteJid, key.id);
-                if (found) {
-                    const { path, doc } = found;
-                    const raw = doc.raw ?? { key };
-                    const upd_any = upd;
-                    const edited_message = upd_any.message?.editedMessage?.message;
-                    const content_update = upd_any.message;
-                    const status = upd_any.status;
-                    const starred_changed = upd_any.starred !== undefined;
-                    if (edited_message) {
-                        raw.message = edited_message;
-                        doc.raw = raw;
-                        doc.edited = true;
-                        doc.caption = message(this, raw).caption;
-                        await this.engine.set(path, serialize(doc), doc.created_at);
-                        const msg_instance = message(this, doc);
-                        this.emit('message:updated', msg_instance, await msg_instance.chat(), this);
-                    }
-                    else if (content_update) {
-                        // Actualización de contenido (ej: live location). Mergea sobre el raw existente.
-                        raw.message = { ...raw.message, ...content_update };
-                        doc.raw = raw;
-                        doc.caption = message(this, raw).caption;
-                        await this.engine.set(path, serialize(doc), doc.created_at);
-                        const msg_instance = message(this, doc);
-                        this.emit('message:updated', msg_instance, await msg_instance.chat(), this);
-                    }
-                    else if (starred_changed) {
-                        doc.starred = upd_any.starred === true;
-                        raw.starred = doc.starred;
-                        doc.raw = raw;
-                        await this.engine.set(path, serialize(doc), doc.created_at);
-                        const msg_instance = message(this, doc);
-                        this.emit(doc.starred ? 'message:starred' : 'message:unstarred', msg_instance, await msg_instance.chat(), this);
-                        // WhatsApp reemite los acks desordenados al reconectar (un `sent` después
-                        // de un `delivered`), así que el estado solo avanza; el rechazo (`error`)
-                        // es terminal y sí puede pisar lo que hubiera.
-                        // WhatsApp re-emits acks out of order on reconnect (a `sent` after a
-                        // `delivered`), so the state only moves forward; a rejection (`error`) is
-                        // terminal and may override whatever was there.
-                    }
-                    else if (status !== undefined && (status > doc.status || status === ERROR)) {
-                        raw.status = status;
-                        doc.status = status;
-                        // El rechazo del servidor viaja como stub del update; sin persistirlo el
-                        // mensaje queda en error sin decir por qué.
-                        // The server rejection travels as an update stub; without persisting it the
-                        // message stays in error without saying why.
-                        if (upd_any.messageStubParameters) {
-                            raw.messageStubParameters = upd_any.messageStubParameters;
-                        }
-                        doc.raw = raw;
-                        await this.engine.set(path, serialize(doc), doc.created_at);
-                        const msg_instance = message(this, doc);
-                        this.emit('message:updated', msg_instance, await msg_instance.chat(), this);
-                    }
-                }
-            }
-        }
-    }
-    /** @internal */
-    async #handle_messages_reaction(reactions) {
-        for (const { key, reaction } of reactions) {
-            if (key.remoteJid && key.id) {
-                // Reacciones sobre status@broadcast → feed:updated (no message:reacted).
-                // Reactions on status@broadcast → feed:updated (not message:reacted).
-                if (key.remoteJid === 'status@broadcast') {
-                    const feed_raw = deserialize(await this.engine.get(`/status/${key.id}`));
-                    if (feed_raw) {
-                        this.emit('feed:updated', new Feed(this, feed_raw), this);
-                    }
-                    continue;
-                }
-                const found = await this.#locate(key.remoteJid, key.id);
-                if (found) {
-                    const { path, doc } = found;
-                    const reactor = jidNormalizedUser(key.participant ?? key.remoteJid);
-                    const emoji = reaction.text ?? '';
-                    doc.reactions = [
-                        ...(doc.reactions ?? []).filter((r) => r.author !== reactor),
-                        ...(emoji ? [{ author: reactor, emoji, at: Date.now() }] : []),
-                    ];
-                    await this.engine.set(path, serialize(doc), doc.created_at);
-                    const msg_instance = message(this, doc);
-                    this.emit('message:reacted', msg_instance, await msg_instance.chat(), reaction.text ?? '', this);
-                }
-            }
+    async disconnect(options = {}) {
+        await this.#close?.(options.silent === true);
+        if (options.destroy) {
+            await this.engine.clear();
         }
     }
 }
-export default WhatsApp;