@arcaelas/whatsapp 3.1.1 → 3.3.0

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

@@ -0,0 +1,882 @@
+"use strict";
+/**
+ * @file whatsapp/index.ts
+ * @description Orquestador principal del cliente WhatsApp v3.
+ * Main orchestrator of the WhatsApp v3 client.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WhatsApp = void 0;
+const baileys_1 = require("baileys");
+const node_events_1 = require("node:events");
+const pino_1 = __importDefault(require("pino"));
+const QRCode = __importStar(require("qrcode"));
+const chat_1 = require("../../lib/chat");
+const contact_1 = require("../../lib/contact");
+const message_1 = require("../../lib/message");
+const status_1 = __importStar(require("../../lib/status"));
+const store_1 = require("../../lib/store");
+/**
+ * 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: 584144709840 });
+ * wa.on('message:created', (msg) => console.log(msg.caption));
+ * await wa.connect((code) => console.log(code));
+ */
+class WhatsApp {
+    constructor(options) {
+        /** @internal */
+        this._socket = null;
+        this._intentional_close = false;
+        this._has_connected = false;
+        this._retry_timer = null;
+        this._retry_count = 0;
+        this.engine = options.engine;
+        this._phone =
+            options.phone !== undefined ? String(options.phone).replace(/\D+/g, '') : undefined;
+        this._autoclean = options.autoclean ?? true;
+        this._sync = options.sync ?? false;
+        this._reconnect = this._parse_reconnect(options.reconnect);
+        this._event = new node_events_1.EventEmitter();
+        this.Contact = (0, contact_1.contact)(this);
+        this.Chat = (0, chat_1.chat)(this);
+        this.Message = (0, message_1.message)(this);
+    }
+    /** @internal */
+    _parse_reconnect(option) {
+        if (option === false) {
+            return { max: 0, interval_ms: 60_000 };
+        }
+        if (option === undefined || option === true) {
+            return { max: null, interval_ms: 60_000 };
+        }
+        if (typeof option === 'number') {
+            return { max: option, interval_ms: 60_000 };
+        }
+        return {
+            max: option.max ?? null,
+            interval_ms: (option.interval ?? 60) * 1000,
+        };
+    }
+    /**
+     * 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.
+     * Uso interno de la librería — no forma parte de la API pública.
+     */
+    async _resolve_jid(uid) {
+        let result = null;
+        if (uid.endsWith('@g.us') || uid.endsWith('@s.whatsapp.net')) {
+            result = uid;
+        }
+        else if (uid.endsWith('@lid')) {
+            const direct = (0, store_1.deserialize)(await this.engine.get(`/lid/${uid}`));
+            if (direct) {
+                result = direct.includes('@') ? direct : `${direct}@s.whatsapp.net`;
+            }
+            else {
+                const reverse = (0, store_1.deserialize)(await this.engine.get(`/lid/${uid.split('@')[0]}_reverse`));
+                if (reverse != null) {
+                    result = `${reverse}@s.whatsapp.net`;
+                }
+            }
+        }
+        else {
+            const cleaned = uid.replace(/\D/g, '');
+            if (cleaned) {
+                result = `${cleaned}@s.whatsapp.net`;
+            }
+        }
+        return result;
+    }
+    /**
+     * 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) {
+        const { version } = await (0, baileys_1.fetchLatestBaileysVersion)();
+        this._intentional_close = false;
+        this._has_connected = false;
+        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 = (0, store_1.deserialize)(stored) ?? (0, baileys_1.initAuthCreds)();
+                this._socket = (0, baileys_1.makeWASocket)({
+                    version,
+                    auth: {
+                        creds,
+                        keys: {
+                            get: async (type, ids) => {
+                                const data = {};
+                                for (const id of ids) {
+                                    const value = (0, store_1.deserialize)(await this.engine.get(`/session/${type}/${id}`));
+                                    if (value) {
+                                        data[id] =
+                                            type === 'app-state-sync-key'
+                                                ? baileys_1.proto.Message.AppStateSyncKeyData.create(value)
+                                                : value;
+                                    }
+                                }
+                                return data;
+                            },
+                            set: async (data) => {
+                                for (const category in data) {
+                                    for (const id in data[category]) {
+                                        const value = data[category][id];
+                                        if (value != null) {
+                                            await this.engine.set(`/session/${category}/${id}`, (0, store_1.serialize)(value));
+                                        }
+                                        else {
+                                            await this.engine.unset(`/session/${category}/${id}`);
+                                        }
+                                    }
+                                }
+                            },
+                        },
+                    },
+                    browser: baileys_1.Browsers.windows('Chrome'),
+                    printQRInTerminal: false,
+                    logger: (0, pino_1.default)({ level: 'silent' }),
+                    syncFullHistory: this._sync,
+                    markOnlineOnConnect: false,
+                });
+                const socket = this._socket;
+                socket.ev.on('creds.update', () => this.engine.set('/session/creds', (0, store_1.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ó.
+                        if (this._phone) {
+                            await callback(await socket.requestPairingCode(this._phone));
+                        }
+                        else {
+                            await callback(await QRCode.toBuffer(qr, { type: 'png', margin: 2 }));
+                        }
+                    }
+                    if (connection === 'open') {
+                        this._has_connected = true;
+                        this._retry_count = 0;
+                        this._event.emit('connected', this);
+                        resolve();
+                    }
+                    else if (connection === 'close') {
+                        this._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 === baileys_1.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 === baileys_1.DisconnectReason.loggedOut) {
+                            if (this._autoclean) {
+                                await this.engine.clear();
+                            }
+                            else {
+                                await this.engine.unset('/session/creds');
+                            }
+                        }
+                        if (this._has_connected && !is_transient) {
+                            this._event.emit('disconnected', this);
+                        }
+                        if (!this._intentional_close) {
+                            if (status_code === baileys_1.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++;
+                                    }
+                                    const delay = is_transient ? 0 : this._reconnect.interval_ms;
+                                    this._retry_timer = setTimeout(() => {
+                                        this._retry_timer = null;
+                                        start().catch(reject);
+                                    }, delay);
+                                }
+                            }
+                        }
+                    }
+                });
+                this._attach_business_handlers(socket);
+            };
+            start().catch(reject);
+        });
+    }
+    /**
+     * 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;
+        // 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._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: baileys_1.DisconnectReason.connectionClosed },
+                });
+                this._socket.end(intentional);
+            }
+            catch {
+                /* socket may already be closed */
+            }
+            this._socket = null;
+        }
+        if (options.destroy) {
+            await this.engine.clear();
+        }
+        void options.silent;
+    }
+    /**
+     * 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', async ({ chats, contacts, messages }) => {
+            await this._handle_contacts_upsert(contacts);
+            await this._handle_chats_upsert(chats);
+            await this._handle_messages_upsert(messages);
+        });
+        socket.ev.on('contacts.upsert', (contacts) => {
+            void this._handle_contacts_upsert(contacts);
+        });
+        socket.ev.on('contacts.update', (contacts) => {
+            void this._handle_contacts_update(contacts);
+        });
+        socket.ev.on('contacts.delete', (ids) => { void this._handle_contacts_delete(ids); });
+        socket.ev.on('lid-mapping.update', ({ lid, pn }) => {
+            void this._handle_lid_mapping(lid, pn);
+        });
+        socket.ev.on('chats.upsert', (chats) => {
+            void this._handle_chats_upsert(chats);
+        });
+        socket.ev.on('chats.update', (chats) => {
+            void this._handle_chats_update(chats);
+        });
+        socket.ev.on('chats.delete', (ids) => {
+            void this._handle_chats_delete(ids);
+        });
+        socket.ev.on('messages.upsert', ({ messages }) => {
+            void this._handle_messages_upsert(messages);
+        });
+        socket.ev.on('messages.update', (updates) => {
+            void this._handle_messages_update(updates);
+        });
+        socket.ev.on('message-receipt.update', (updates) => {
+            void 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);
+        // });
+    }
+    /** @internal */
+    async _handle_contacts_upsert(contacts) {
+        for (const c of contacts) {
+            if (c.id) {
+                const existing = await this.engine.get(`/contact/${c.id}`);
+                const raw = {
+                    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,
+                };
+                await this.engine.set(`/contact/${c.id}`, (0, store_1.serialize)(raw));
+                if (raw.lid) {
+                    await this.engine.set(`/lid/${raw.lid}`, (0, store_1.serialize)(raw.id));
+                }
+                if (existing === null) {
+                    const cached_chat = (0, store_1.deserialize)(await this.engine.get(`/chat/${raw.id}`));
+                    const chat_instance = new this.Chat(cached_chat ?? { id: raw.id, name: raw.name ?? raw.notify ?? raw.id.split('@')[0] });
+                    this._event.emit('contact:created', new this.Contact(raw, chat_instance), chat_instance, this);
+                }
+            }
+        }
+    }
+    /** @internal */
+    async _handle_contacts_update(contacts) {
+        for (const c of contacts) {
+            if (c.id) {
+                const current = (0, store_1.deserialize)(await this.engine.get(`/contact/${c.id}`));
+                if (current) {
+                    const patch = {};
+                    if (c.notify) {
+                        patch.notify = c.notify;
+                    }
+                    if (c.name) {
+                        patch.name = c.name;
+                    }
+                    if (c.imgUrl) {
+                        patch.img_url = c.imgUrl;
+                    }
+                    if (c.status) {
+                        patch.status = c.status;
+                    }
+                    if (c.lid) {
+                        patch.lid = c.lid;
+                    }
+                    if (Object.keys(patch).length > 0) {
+                        const merged = { ...current, ...patch };
+                        await this.engine.set(`/contact/${c.id}`, (0, store_1.serialize)(merged));
+                        if (patch.lid) {
+                            await this.engine.set(`/lid/${patch.lid}`, (0, store_1.serialize)(c.id));
+                        }
+                        const cached_chat = (0, store_1.deserialize)(await this.engine.get(`/chat/${c.id}`));
+                        const chat_instance = new this.Chat(cached_chat ?? { id: c.id, name: merged.name ?? merged.notify ?? c.id.split('@')[0] });
+                        this._event.emit('contact:updated', new this.Contact(merged, chat_instance), chat_instance, this);
+                    }
+                }
+            }
+        }
+    }
+    /** @internal */
+    async _handle_lid_mapping(lid, pn) {
+        await this.engine.set(`/lid/${lid}`, (0, store_1.serialize)(pn));
+        await this.engine.set(`/lid/${pn}`, (0, store_1.serialize)(lid));
+    }
+    /** @internal */
+    async _handle_chats_upsert(chats) {
+        for (const ch of chats) {
+            if (ch.id) {
+                const current = (0, store_1.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,
+                    read_only: ch.readOnly ?? null,
+                };
+                if (ch.name) {
+                    raw.name = ch.name;
+                }
+                await this.engine.set(`/chat/${ch.id}`, (0, store_1.serialize)(raw));
+                if (current === null) {
+                    this._event.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 = (0, store_1.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 };
+                    await this.engine.set(`/chat/${ch.id}`, (0, store_1.serialize)(merged));
+                    if (pinned_changed) {
+                        this._event.emit(ch.pinned != null ? 'chat:pinned' : 'chat:unpinned', new this.Chat(merged), this);
+                    }
+                    if (archived_changed) {
+                        this._event.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._event.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 = (0, store_1.deserialize)(await this.engine.get(`/chat/${cid}`)) ?? { id: cid };
+            await this.engine.unset(`/chat/${cid}`);
+            this._event.emit('chat:deleted', new this.Chat(raw), this);
+        }
+    }
+    /** @internal */
+    async _handle_contacts_delete(ids) {
+        for (const id of ids) {
+            const raw = (0, store_1.deserialize)(await this.engine.get(`/contact/${id}`));
+            await this.engine.unset(`/contact/${id}`);
+            if (raw) {
+                const cached_chat = (0, store_1.deserialize)(await this.engine.get(`/chat/${id}`));
+                const chat_instance = new this.Chat(cached_chat ?? { id, name: raw.name ?? raw.notify ?? id.split('@')[0] });
+                this._event.emit('contact:deleted', new this.Contact(raw, chat_instance), chat_instance, 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 = (0, store_1.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}`, (0, store_1.serialize)(feed_raw));
+                    this._event.emit('feed:updated', new status_1.default({ wa: this, doc: feed_raw }), this);
+                }
+                continue;
+            }
+            if (key.remoteJid && key.id && (receipt.readTimestamp != null || receipt.playedTimestamp != null)) {
+                const doc = (0, store_1.deserialize)(await this.engine.get(`/chat/${key.remoteJid}/message/${key.id}`));
+                if (doc) {
+                    const msg_instance = await this.Message.build_instance(doc);
+                    this._event.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 = (0, baileys_1.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 },
+                                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 === baileys_1.proto.Message.ProtocolMessage.Type.REVOKE &&
+                            protocol.key?.id) {
+                            const feed_raw = (0, store_1.deserialize)(await this.engine.get(`/status/${protocol.key.id}`));
+                            if (feed_raw) {
+                                await this.engine.unset(`/status/${protocol.key.id}`);
+                                this._event.emit('feed:deleted', new status_1.default({ wa: this, doc: feed_raw }), 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 + status_1.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._socket) {
+                        try {
+                            const buf = await (0, baileys_1.downloadMediaMessage)(msg, 'buffer', {});
+                            if (Buffer.isBuffer(buf)) {
+                                content_buf = buf;
+                            }
+                        }
+                        catch {
+                            /* media download may fail */
+                        }
+                    }
+                    await this.engine.set(`/status/${mid}`, (0, store_1.serialize)(feed_raw));
+                    if (content_buf.length > 0) {
+                        await this.engine.set(`/status/${mid}/content`, (0, store_1.serialize)({ data: content_buf.toString('base64') }));
+                    }
+                    this._event.emit('feed:created', new status_1.default({ wa: this, doc: 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 = (0, store_1.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 ?? {};
+                                // WhatsApp moderno usa LID normalizado para identidad del HMAC
+                                // tanto en votos propios (echo) como foráneos. Espejo del fix de
+                                // `Poll.select()` (ver `src/lib/message`).
+                                // Modern WhatsApp uses normalized LID identity for HMAC on both
+                                // own-vote echoes and foreign votes. Mirrors the `Poll.select()` fix.
+                                const self_id = this._socket?.user?.id ?? '';
+                                const self_lid = this._socket?.user?.lid ?? '';
+                                const voter_raw = msg.key.fromMe
+                                    ? (self_lid || self_id)
+                                    : msg.key.remoteJid?.endsWith('@lid')
+                                        ? msg.key.remoteJid
+                                        : msg.key.participant ||
+                                            msg.key.remoteJidAlt ||
+                                            msg.key.remoteJid ||
+                                            '';
+                                const creator_raw = poll_key.fromMe
+                                    ? (self_lid || self_id)
+                                    : poll_key.remoteJid?.endsWith('@lid')
+                                        ? poll_key.remoteJid
+                                        : poll_key.participant ||
+                                            poll_key.remoteJidAlt ||
+                                            poll_key.remoteJid ||
+                                            '';
+                                const voter_jid = (0, baileys_1.jidNormalizedUser)(voter_raw);
+                                const poll_creator_jid = (0, baileys_1.jidNormalizedUser)(creator_raw);
+                                const decrypted = (0, baileys_1.decryptPollVote)({ encPayload: update.vote.encPayload, encIv: update.vote.encIv }, {
+                                    pollCreatorJid: poll_creator_jid,
+                                    pollMsgId: target_mid,
+                                    pollEncKey: message_secret,
+                                    voterJid: voter_jid,
+                                });
+                                (0, baileys_1.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}`, (0, store_1.serialize)(poll_doc));
+                                const msg_instance = await this.Message.build_instance(poll_doc);
+                                this._event.emit('message:updated', msg_instance, await msg_instance.chat(), this);
+                            }
+                            catch {
+                                /* decrypt may fail */
+                            }
+                        }
+                    }
+                    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 = (0, store_1.deserialize)(await this.engine.get(`/chat/${target_cid}/message/${target_mid}`));
+                        if (protocol.type === baileys_1.proto.Message.ProtocolMessage.Type.MESSAGE_EDIT &&
+                            protocol.editedMessage &&
+                            doc) {
+                            doc.raw.message = protocol.editedMessage;
+                            doc.edited = true;
+                            doc.caption = this.Message.build_message_doc(doc.raw, this._socket?.user?.id, true).caption;
+                            await this.engine.set(`/chat/${target_cid}/message/${target_mid}`, (0, store_1.serialize)(doc));
+                            const msg_instance = await this.Message.build_instance(doc);
+                            this._event.emit('message:updated', msg_instance, await msg_instance.chat(), this);
+                        }
+                        else if (protocol.type === baileys_1.proto.Message.ProtocolMessage.Type.REVOKE) {
+                            await this.engine.unset(`/chat/${target_cid}/message/${target_mid}`);
+                            if (doc) {
+                                const msg_instance = await this.Message.build_instance(doc);
+                                this._event.emit('message:deleted', msg_instance, await msg_instance.chat(), this);
+                            }
+                        }
+                    }
+                    continue;
+                }
+                const doc = this.Message.build_message_doc(msg, this._socket?.user?.id);
+                // Autocreación de contacto/chat desde pushName cuando baileys no emite upsert previo
+                if (!doc.me) {
+                    const push_name = msg.pushName ?? null;
+                    const is_group = cid.endsWith('@g.us');
+                    if (doc.author && !(await this.engine.get(`/contact/${doc.author}`))) {
+                        const lid_key = msg.key.remoteJid?.endsWith('@lid') ? msg.key.remoteJid : null;
+                        const contact_raw = {
+                            id: doc.author,
+                            lid: lid_key,
+                            name: null,
+                            notify: is_group ? null : push_name,
+                            verified_name: msg.verifiedBizName ?? null,
+                            img_url: null,
+                            status: null,
+                        };
+                        await this.engine.set(`/contact/${doc.author}`, (0, store_1.serialize)(contact_raw));
+                        if (lid_key) {
+                            await this.engine.set(`/lid/${lid_key}`, (0, store_1.serialize)(doc.author));
+                        }
+                        const cached_chat = (0, store_1.deserialize)(await this.engine.get(`/chat/${doc.author}`));
+                        const author_chat = new this.Chat(cached_chat ?? { id: doc.author, name: push_name ?? doc.author.split('@')[0] });
+                        this._event.emit('contact:created', new this.Contact(contact_raw, author_chat), author_chat, this);
+                    }
+                    if (!(await this.engine.get(`/chat/${cid}`))) {
+                        const chat_raw = {
+                            id: cid,
+                            name: is_group ? null : push_name,
+                        };
+                        await this.engine.set(`/chat/${cid}`, (0, store_1.serialize)(chat_raw));
+                        this._event.emit('chat:created', new this.Chat(chat_raw), this);
+                    }
+                }
+                // Preservar flags explícitos persistidos por el send (ej: `multiple` en polls
+                // auto-emitidos, donde el echo de WhatsApp pierde el discriminador del proto).
+                // Preserve send-time flags (e.g. `multiple` on own polls, since WhatsApp drops
+                // the proto discriminator on echo).
+                const existing_doc = (0, store_1.deserialize)(await this.engine.get(`/chat/${cid}/message/${mid}`));
+                if (existing_doc && typeof existing_doc.multiple === 'boolean') {
+                    doc.multiple = existing_doc.multiple;
+                }
+                await this.engine.set(`/chat/${cid}/message/${mid}`, (0, store_1.serialize)(doc));
+                let content_buf = Buffer.alloc(0);
+                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 (this._socket && ['image', 'video', 'audio'].includes(doc.type)) {
+                    try {
+                        const buffer = await (0, baileys_1.downloadMediaMessage)(msg, 'buffer', {});
+                        if (Buffer.isBuffer(buffer)) {
+                            content_buf = buffer;
+                        }
+                    }
+                    catch {
+                        /* media download may fail */
+                    }
+                }
+                if (content_buf.length > 0) {
+                    await this.engine.set(`/chat/${cid}/message/${mid}/content`, (0, store_1.serialize)({ data: content_buf.toString('base64') }));
+                }
+                const instance = await this.Message.build_instance(doc);
+                const chat_instance = await instance.chat();
+                this._event.emit('message:created', instance, chat_instance, this);
+                if (doc.forwarded) {
+                    this._event.emit('message:forwarded', instance, chat_instance, this);
+                }
+            }
+        }
+    }
+    /** @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 doc = (0, store_1.deserialize)(await this.engine.get(`/chat/${key.remoteJid}/message/${key.id}`));
+                if (doc) {
+                    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 = this.Message.build_message_doc(raw, this._socket?.user?.id, true).caption;
+                        await this.engine.set(`/chat/${key.remoteJid}/message/${key.id}`, (0, store_1.serialize)(doc));
+                        const msg_instance = await this.Message.build_instance(doc);
+                        this._event.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 = this.Message.build_message_doc(raw, this._socket?.user?.id, doc.edited).caption;
+                        await this.engine.set(`/chat/${key.remoteJid}/message/${key.id}`, (0, store_1.serialize)(doc));
+                        const msg_instance = await this.Message.build_instance(doc);
+                        this._event.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(`/chat/${key.remoteJid}/message/${key.id}`, (0, store_1.serialize)(doc));
+                        const msg_instance = await this.Message.build_instance(doc);
+                        this._event.emit(doc.starred ? 'message:starred' : 'message:unstarred', msg_instance, await msg_instance.chat(), this);
+                    }
+                    else if (status !== undefined) {
+                        raw.status = status;
+                        doc.status = status;
+                        doc.raw = raw;
+                        await this.engine.set(`/chat/${key.remoteJid}/message/${key.id}`, (0, store_1.serialize)(doc));
+                        const msg_instance = await this.Message.build_instance(doc);
+                        this._event.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 = (0, store_1.deserialize)(await this.engine.get(`/status/${key.id}`));
+                    if (feed_raw) {
+                        this._event.emit('feed:updated', new status_1.default({ wa: this, doc: feed_raw }), this);
+                    }
+                    continue;
+                }
+                const doc = (0, store_1.deserialize)(await this.engine.get(`/chat/${key.remoteJid}/message/${key.id}`));
+                if (doc) {
+                    const msg_instance = await this.Message.build_instance(doc);
+                    this._event.emit('message:reacted', msg_instance, await msg_instance.chat(), reaction.text ?? '', this);
+                }
+            }
+        }
+    }
+}
+exports.WhatsApp = WhatsApp;
+exports.default = WhatsApp;
+//# sourceMappingURL=index.js.map