@arcaelas/whatsapp 6.2.0 → 7.0.1

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

@@ -1,676 +1,338 @@
 /**
  * @file message/index.ts
- * @description Entidad Message — clase base con getters puros y subclases por tipo
- * (Text, Image, Video, Audio, Sticker, Document, Location, Poll, VCard, Event);
- * `message(wa, raw)` evalúa el tipo y retorna la instancia correcta.
- * Message entity — pure-getter base class with per-type subclasses;
- * `message(wa, raw)` evaluates the type and returns the right instance.
+ * @description Entidad Message — clase base con getters puros y subclases por tipo;
+ * `message(init)` devuelve la clase ligada a la sesión con los envíos y lecturas.
+ * Message entity — pure-getter base class with per-type subclasses; `message(init)`
+ * returns the session-bound class with sends and reads.
  */
 import { aesEncryptGCM, downloadMediaMessage, generateForwardMessageContent, generateMessageID, generateWAMessageFromContent, getAggregateVotesInPollMessage, getContentType, getKeyAuthor, hmacSign, jidNormalizedUser, proto, sha256, updateMessageWithPollUpdate, } from 'baileys';
 import { randomBytes } from 'node:crypto';
 import { Readable } from 'node:stream';
-import { internals } from '../../lib/internal.js';
-import { Chat } from '../../lib/chat/index.js';
-import { deserialize, serialize } from '../../lib/store/index.js';
+import Chat from '../../lib/chat/index.js';
+import { deserialize, jid_of, serialize } from '../../lib/store/index.js';
 /** Estados legibles indexados por el status numérico de baileys. / Readable states indexed by the baileys numeric status. */
 const STATUS = ['error', 'pending', 'sent', 'delivered', 'read', 'played'];
+/** Desenvuelve los wrappers de contenido (view-once, documento con caption). / Unwraps content wrappers (view-once, captioned document). */
+const unwrap = (msg) => msg.viewOnceMessage?.message ?? msg.viewOnceMessageV2?.message ?? msg.viewOnceMessageV2Extension?.message ?? msg.documentWithCaptionMessage?.message ?? msg;
+/** Bytes del proto (Uint8Array en runtime, base64 tras el engine) como Buffer. / Proto bytes (runtime Uint8Array, post-engine base64) as a Buffer. */
+const to_buffer = (value) => value instanceof Uint8Array && value.length ? Buffer.from(value) : typeof value === 'string' && value ? Buffer.from(value, 'base64') : null;
 /**
- * Motivos legibles de los códigos con los que el servidor rechaza un mensaje. `restricted`
- * es la cuenta limitada por WhatsApp: puede seguir chats existentes pero no abrir nuevos.
- * Readable reasons for the codes the server rejects a message with. `restricted` is an
- * account limited by WhatsApp: it can continue existing chats but not open new ones.
+ * Envío base: resuelve el destino, cita si hay `mid`, marca view-once, persiste el documento
+ * con su binario y retorna la instancia del tipo correcto. La cita viaja en las opciones del
+ * socket: dentro del contenido baileys la ignora.
+ * Base send: resolves the target, quotes when `mid` is given, flags view-once, persists the
+ * document with its binary and returns the right-type instance. The quote travels in the
+ * socket options: inside the content baileys ignores it.
  */
-const REASON = {
-    463: 'restricted',
-    479: 'invalid-session',
+const send = async (init, cid, content, binary, extra = {}, overrides) => {
+    const jid = await jid_of(init.engine, cid, init.socket);
+    if (!jid)
+        return null;
+    const quoted = extra.mid ? deserialize(await init.engine.get(`/chat/${jid}/message/${extra.mid}`))?.raw : undefined;
+    const raw = await init.socket.sendMessage(jid, { ...content, ...(extra.once && { viewOnce: true }) }, { ...(quoted && { quoted }) });
+    if (!raw?.key?.id)
+        return null;
+    const sent = new Message(init, raw);
+    Object.assign(sent._raw, overrides);
+    await init.engine.set(`/chat/${jid}/message/${raw.key.id}`, serialize(sent._raw), sent._raw.created_at);
+    const path = `/chat/${jid}/message/${raw.key.id}/content`;
+    if (binary)
+        await (init.engine.set_buffer?.(path, binary) ?? init.engine.set(path, serialize({ data: binary.toString('base64') })));
+    return sent;
 };
-const MESSAGE_TYPE_MAP = {
-    conversation: 'text',
-    extendedTextMessage: 'text',
-    imageMessage: 'image',
-    videoMessage: 'video',
-    audioMessage: 'audio',
-    stickerMessage: 'sticker',
-    locationMessage: 'location',
-    liveLocationMessage: 'location',
-    pollCreationMessage: 'poll',
-    pollCreationMessageV2: 'poll',
-    pollCreationMessageV3: 'poll',
-    documentMessage: 'document',
-    documentWithCaptionMessage: 'document',
-    contactMessage: 'vcard',
-    contactsArrayMessage: 'vcard',
-    eventMessage: 'event',
+/** Contenido proto de una encuesta. / Poll proto content. */
+const poll_of = (input, multiple) => ({ poll: { name: input.content, values: input.options.map((option) => option.content), selectableCount: multiple ? 0 : 1 } });
+/** Contenido y binario de las tarjetas de contacto. / Contact cards content and binary. */
+const vcards_of = (contacts) => {
+    const cards = contacts.map((entry) => ({
+        displayName: entry.name,
+        vcard: `BEGIN:VCARD\nVERSION:3.0\nFN:${entry.name}\nTEL;type=CELL;waid=${entry.phone.replace(/\D+/g, '')}:${entry.phone}\nEND:VCARD`,
+    }));
+    return { content: { contacts: { contacts: cards } }, binary: Buffer.from(cards.map((entry) => entry.vcard).join('\n'), 'utf-8') };
 };
+/** Contenido y binario del evento. / Event content and binary. */
+const event_of = (data) => ({
+    content: {
+        event: {
+            name: data.name,
+            description: data.caption,
+            startDate: data.start,
+            endDate: data.end,
+            location: data.place ? { degreesLatitude: data.place.lat, degreesLongitude: data.place.lng } : undefined,
+        },
+    },
+    binary: Buffer.from(JSON.stringify({ name: data.name, caption: data.caption, start: data.start.getTime(), end: data.end?.getTime() ?? null }), 'utf-8'),
+});
 /**
- * Desenvuelve los wrappers de contenido (view-once, documento con caption).
- * Unwraps content wrappers (view-once, captioned document).
- */
-function unwrap(msg) {
-    return (msg.viewOnceMessage?.message ??
-        msg.viewOnceMessageV2?.message ??
-        msg.viewOnceMessageV2Extension?.message ??
-        msg.documentWithCaptionMessage?.message ??
-        msg);
-}
-/**
- * Convierte un número o Long del proto a number plano.
- * Converts a proto number or Long into a plain number.
- */
-function to_number(value) {
-    return Number(value?.toString() ?? 0);
-}
-/**
- * Convierte los bytes del proto (Uint8Array runtime o base64 post-engine) a Buffer.
- * Converts proto bytes (runtime Uint8Array or post-engine base64) into a Buffer.
- */
-function to_buffer(value) {
-    if (value instanceof Uint8Array && value.length > 0)
-        return Buffer.from(value);
-    if (typeof value === 'string' && value.length > 0)
-        return Buffer.from(value, 'base64');
-    return null;
-}
-/**
- * Envío base: resuelve el destino, cita si hay `mid`, marca view-once, persiste el doc
- * (con su binario cuando aplica) y retorna la instancia del mensaje enviado.
- * Base send: resolves the target, quotes when `mid` is given, flags view-once, persists
- * the doc (with its binary when it applies) and returns the sent message instance.
- */
-async function send(wa, cid, content, binary, extra = {}, doc_overrides) {
-    let result = null;
-    const jid = await internals(wa).resolve_jid(cid);
-    const socket = internals(wa).socket;
-    if (jid && socket) {
-        const quoted = extra.mid
-            ? (deserialize(await wa.engine.get(`/chat/${jid}/message/${extra.mid}`))?.raw ?? undefined)
-            : undefined;
-        // La cita viaja en las opciones del socket, no en el contenido: dentro del contenido
-        // baileys la ignora y el mensaje sale sin `contextInfo`.
-        // The quote travels in the socket options, not in the content: inside the content
-        // baileys ignores it and the message goes out without `contextInfo`.
-        const raw = await socket.sendMessage(jid, { ...content, ...(extra.once && { viewOnce: true }) }, { ...(quoted && { quoted }) });
-        const sent_id = raw?.key?.id;
-        if (raw && sent_id) {
-            const instance = message(wa, raw);
-            if (doc_overrides) {
-                Object.assign(instance._raw, doc_overrides);
-            }
-            await wa.engine.set(`/chat/${jid}/message/${sent_id}`, serialize(instance._raw), instance._raw.created_at);
-            if (binary) {
-                await write_content(wa, `/chat/${jid}/message/${sent_id}/content`, binary);
-            }
-            result = instance;
-        }
-    }
-    return result;
-}
-/**
- * Binario persistido de un documento: primero el crudo del engine y, si el driver no soporta
- * binarios o el dato viene de una sesión anterior, el documento JSON con base64.
- * A document's persisted binary: the engine's raw one first and, when the driver lacks binary
- * support or the data comes from an older session, the base64 JSON document.
- *
- * @param wa - Cliente dueño / Owner client
- * @param path - Ruta del contenido / Content path
- * @returns Binario o null / Binary or null
+ * Mensaje: recibe la sesión y el documento, deriva el estado con getters y opera contra
+ * WhatsApp con sus métodos. Los de respuesta citan automáticamente este mensaje.
+ * Message: receives the session and the document, derives state via getters and operates
+ * against WhatsApp with its methods. Reply methods quote this message automatically.
  */
-async function read_content(wa, path) {
-    const raw = await wa.engine.get_buffer?.(path);
-    if (raw?.length) {
-        return raw;
-    }
-    const legacy = deserialize(await wa.engine.get(path));
-    return legacy?.data ? Buffer.from(legacy.data, 'base64') : null;
-}
-/**
- * Persiste el binario de un documento: crudo cuando el driver lo soporta, JSON con base64
- * en caso contrario.
- * Persists a document's binary: raw when the driver supports it, base64 JSON otherwise.
- *
- * @param wa - Cliente dueño / Owner client
- * @param path - Ruta del contenido / Content path
- * @param data - Binario a guardar / Binary to store
- */
-async function write_content(wa, path, data) {
-    if (wa.engine.set_buffer) {
-        await wa.engine.set_buffer(path, data);
-    }
-    else {
-        await wa.engine.set(path, serialize({ data: data.toString('base64') }));
-    }
-}
-/**
- * Stream del binario del mensaje: cache del engine o descarga de baileys.
- * Message binary stream: engine cache or baileys download.
- */
-async function media_stream(wa, doc) {
-    const cached = await read_content(wa, `/chat/${doc.cid}/message/${doc.id}/content`);
-    if (cached) {
-        return Readable.from(cached);
-    }
-    const socket = internals(wa).socket;
-    if (socket) {
-        try {
-            return (await downloadMediaMessage(doc.raw, 'stream', {}));
-        }
-        catch {
-            /* media may be expired */
-        }
-    }
-    return Readable.from(Buffer.alloc(0));
-}
-/**
- * Acumula un Readable en Buffer.
- * Drains a Readable into a Buffer.
- */
-async function drain(readable) {
-    const chunks = [];
-    for await (const chunk of readable) {
-        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-    }
-    return Buffer.concat(chunks);
-}
-/**
- * Clase base del mensaje: recibe el cliente y el raw, deriva el estado con getters y
- * opera contra WhatsApp con sus métodos. Los estáticos reciben el cliente como primer
- * argumento (`Message.text(wa, cid, …)`).
- * Base message class: receives the client and the raw, derives state via getters and
- * operates against WhatsApp with its methods. Statics take the client as their first
- * argument (`Message.text(wa, cid, …)`).
- */
-export class Message {
+export default class Message {
     /**
-     * @internal Cliente dueño y documento persistido. `status`, `created_at` y
-     * `deleted_at` guardan los valores numéricos del protocolo; los getters los
-     * presentan legibles. `viewed` existe únicamente en los status broadcast (Feed).
-     * Owner client and persisted document. `status`, `created_at` and `deleted_at`
-     * keep the protocol numeric values; getters expose them readable. `viewed` only
-     * exists on status broadcasts (Feed).
+     * Recibe la sesión y el documento persistido, o el crudo de baileys: en ese caso el
+     * documento se deriva aquí y se despacha la subclase del tipo — `new Message(init, raw)`
+     * de una encuesta devuelve un `Poll`.
+     * Receives the session and the persisted document, or the baileys raw: in that case the
+     * document is derived here and the per-type subclass is dispatched — `new Message(init,
+     * raw)` of a poll returns a `Poll`.
      */
-    constructor(_wa, _raw) {
-        this._wa = _wa;
-        this._raw = _raw;
+    constructor(init, raw) {
+        let doc = raw;
+        if ('key' in raw) {
+            const key = raw.key ?? {};
+            const unwrapped = unwrap(raw.message ?? {});
+            const kind = getContentType(unwrapped);
+            const type = {
+                conversation: 'text', extendedTextMessage: 'text', imageMessage: 'image', videoMessage: 'video',
+                audioMessage: 'audio', stickerMessage: 'sticker', locationMessage: 'location', liveLocationMessage: 'location',
+                pollCreationMessage: 'poll', pollCreationMessageV2: 'poll', pollCreationMessageV3: 'poll',
+                documentMessage: 'document', documentWithCaptionMessage: 'document', contactMessage: 'vcard',
+                contactsArrayMessage: 'vcard', eventMessage: 'event',
+            }[kind ?? ''] ?? 'text';
+            const content = unwrapped[kind];
+            const context = content?.contextInfo;
+            const ephemeral = raw.ephemeralDuration ?? context?.expiration;
+            doc = {
+                id: key.id ?? '',
+                cid: key.remoteJidAlt ?? key.remoteJid ?? '',
+                mid: context?.stanzaId ?? null,
+                me: key.fromMe ?? false,
+                type,
+                author: key.fromMe && init.socket.user?.id
+                    ? jidNormalizedUser(init.socket.user.id)
+                    : key.participant || key.remoteJidAlt || key.remoteJid || '',
+                status: raw.status ?? 1,
+                starred: raw.starred ?? false,
+                forwarded: context?.isForwarded ?? false,
+                created_at: (Number(raw.messageTimestamp) || Math.floor(Date.now() / 1_000)) * 1_000,
+                deleted_at: raw.ephemeralStartTimestamp != null && ephemeral != null ? (Number(raw.ephemeralStartTimestamp) + ephemeral) * 1_000 : null,
+                mime: typeof content === 'object' && type !== 'text' ? (content?.mimetype ?? 'application/octet-stream') : 'text/plain',
+                caption: typeof content === 'string' ? content
+                    : type === 'event' ? (content?.description ?? '')
+                        : (content?.caption ?? content?.text ?? content?.name ?? content?.displayName ?? ''),
+                edited: false,
+                raw,
+            };
+        }
+        if (new.target === Message) {
+            const kinds = { text: Text, image: Image, video: Video, audio: Audio, sticker: Sticker, document: Document, location: Location, poll: Poll, vcard: VCard, event: Event };
+            return new kinds[doc.type](init, doc);
+        }
+        this._init = init;
+        this._raw = doc;
     }
     /** Identificador del mensaje. / Message identifier. */
-    get id() {
-        return this._raw.id;
-    }
-    /** Identificador del chat del mensaje. / Message chat identifier. */
-    get cid() {
-        return this._raw.cid;
-    }
+    get id() { return this._raw.id; }
+    /** Identificador del chat. / Chat identifier. */
+    get cid() { return this._raw.cid; }
     /** Identificador del mensaje citado, o null. / Quoted message identifier, or null. */
-    get mid() {
-        return this._raw.mid;
-    }
-    /** JID del autor, para acceso síncrono. / Author JID, for sync access. */
-    get from() {
-        return this._raw.author;
-    }
+    get mid() { return this._raw.mid; }
+    /** JID del autor. / Author JID. */
+    get from() { return this._raw.author; }
     /** true si soy el autor. / true when I am the author. */
-    get me() {
-        return this._raw.me;
-    }
+    get me() { return this._raw.me; }
     /** Tipo del mensaje. / Message type. */
-    get type() {
-        return this._raw.type;
-    }
-    /** MIME: text/plain en texto, text/json en poll/location/vcard/event, real en media. / MIME: text/plain for text, text/json for poll/location/vcard/event, actual for media. */
-    get mime() {
-        const { type } = this._raw;
-        if (type === 'text')
-            return 'text/plain';
-        if (type === 'poll' || type === 'location' || type === 'vcard' || type === 'event')
-            return 'text/json';
-        return this._raw.mime;
-    }
+    get type() { return this._raw.type; }
     /** Texto del mensaje o caption del media. / Message text or media caption. */
-    get caption() {
-        return this._raw.caption;
-    }
+    get caption() { return this._raw.caption; }
     /** Estado legible del mensaje. / Readable message state. */
-    get status() {
-        return STATUS[this._raw.status] ?? 'pending';
-    }
+    get status() { return STATUS[this._raw.status] ?? 'pending'; }
     /** true si el mensaje fue visto. / true when the message was seen. */
-    get read() {
-        return this._raw.status >= 4;
+    get read() { return this._raw.status >= proto.WebMessageInfo.Status.READ; }
+    /** true si está destacado. / true when starred. */
+    get starred() { return this._raw.starred; }
+    /** true si fue reenviado. / true when forwarded. */
+    get forwarded() { return this._raw.forwarded; }
+    /** true si fue editado. / true when edited. */
+    get edited() { return this._raw.edited; }
+    /** Fecha de creación en ISO UTC. / Creation date as ISO UTC. */
+    get created_at() { return new Date(this._raw.created_at).toISOString(); }
+    /** Vencimiento del mensaje temporal en ISO UTC, o null. / Ephemeral expiration as ISO UTC, or null. */
+    get expires_at() { return this._raw.deleted_at != null ? new Date(this._raw.deleted_at).toISOString() : null; }
+    /** MIME: text/plain en texto, text/json en poll/location/vcard/event, real en media. / MIME: text/plain for text, text/json for poll/location/vcard/event, actual for media. */
+    get mime() {
+        const { type } = this._raw;
+        return type === 'text' ? 'text/plain' : ['poll', 'location', 'vcard', 'event'].includes(type) ? 'text/json' : this._raw.mime;
     }
-    /** Motivo del rechazo cuando `status` es `error` (`restricted`, `invalid-session`, o el código crudo); null en cualquier otro caso. / Rejection reason when `status` is `error` (`restricted`, `invalid-session`, or the raw code); null otherwise. */
+    /** Motivo del rechazo cuando `status` es `error` (`restricted`, `invalid-session`, o el código crudo); null si no. / Rejection reason when `status` is `error` (`restricted`, `invalid-session`, or the raw code); null otherwise. */
     get reason() {
         const code = this._raw.raw.messageStubParameters?.[0];
-        if (this._raw.status === 0 && code)
-            return REASON[code] ?? code;
-        return null;
+        return this._raw.status === proto.WebMessageInfo.Status.ERROR && code
+            ? { '463': 'restricted', '479': 'invalid-session' }[code] ?? code
+            : null;
     }
     /** Nombre del negocio verificado que firma el mensaje, o null. / Verified business name signing the message, or null. */
-    get business() {
-        return this._raw.raw.verifiedBizName ?? null;
-    }
-    /** true si está destacado. / true when starred. */
-    get starred() {
-        return this._raw.starred;
-    }
-    /** true si fue reenviado. / true when forwarded. */
-    get forwarded() {
-        return this._raw.forwarded;
-    }
-    /** true si fue editado. / true when edited. */
-    get edited() {
-        return this._raw.edited;
-    }
+    get business() { return this._raw.raw.verifiedBizName ?? null; }
     /** true si es de una sola lectura (view-once). / true when view-once. */
     get once() {
         const msg = this._raw.raw.message;
         return Boolean(msg?.viewOnceMessage ?? msg?.viewOnceMessageV2 ?? msg?.viewOnceMessageV2Extension);
     }
-    /** Fecha de creación en ISO UTC. / Creation date as ISO UTC. */
-    get created_at() {
-        return new Date(this._raw.created_at).toISOString();
-    }
-    /** Vencimiento del mensaje temporal en ISO UTC, o null. / Ephemeral expiration as ISO UTC, or null. */
-    get expires_at() {
-        return this._raw.deleted_at != null ? new Date(this._raw.deleted_at).toISOString() : null;
-    }
-    /**
-     * Contacto autor del mensaje, desde el engine (ficha mínima si no está persistido).
-     * Message author contact, from the engine (minimal card when not persisted).
-     *
-     * @returns Contacto / Contact
-     */
+    /** Contacto autor, desde el engine (ficha mínima si no está persistido). / Author contact, from the engine (minimal card when not persisted). */
     async author() {
-        const cached = deserialize(await this._wa.engine.get(`/contact/${this._raw.author}`));
-        return new this._wa.Contact(cached ?? { id: this._raw.author });
+        return new this._init.wa.Contact(deserialize(await this._init.engine.get(`/contact/${this._raw.author}`)) ?? { id: this._raw.author });
     }
-    /**
-     * Chat al que pertenece el mensaje.
-     * Chat the message belongs to.
-     *
-     * @returns Chat / Chat
-     */
+    /** Chat al que pertenece el mensaje. / Chat the message belongs to. */
     async chat() {
-        const cached = deserialize(await this._wa.engine.get(`/chat/${this._raw.cid}`));
-        return new this._wa.Chat(cached ?? { id: this._raw.cid });
+        return new this._init.wa.Chat(deserialize(await this._init.engine.get(`/chat/${this._raw.cid}`)) ?? { id: this._raw.cid });
     }
-    /**
-     * Mensaje citado cuando hay `mid`, o null.
-     * Quoted message when `mid` exists, or null.
-     *
-     * @returns Mensaje citado o null / Quoted message or null
-     */
+    /** Mensaje citado cuando hay `mid`, o null. / Quoted message when `mid` exists, or null. */
     async message() {
-        return this._raw.mid ? Message.get(this._wa, this._raw.cid, this._raw.mid) : null;
+        const doc = this._raw.mid ? deserialize(await this._init.engine.get(`/chat/${this._raw.cid}/message/${this._raw.mid}`)) : null;
+        return doc ? new Message(this._init, doc) : null;
     }
-    /**
-     * Contenido del mensaje: texto como su caption, media como binario, y
-     * poll/location/vcard/event como JSON.
-     * Message content: text as its caption, media as binary, and
-     * poll/location/vcard/event as JSON.
-     *
-     * @returns Buffer del contenido / Content buffer
-     */
+    /** Contenido persistido: texto, JSON del tipo, o binario del media. / Persisted content: text, per-type JSON, or media binary. */
     async content() {
-        return (await read_content(this._wa, `/chat/${this._raw.cid}/message/${this._raw.id}/content`)) ?? Buffer.alloc(0);
-    }
-    /**
-     * Stream del contenido; para media descarga de baileys si el cache falta.
-     * Content stream; media falls back to a baileys download when the cache is missing.
-     *
-     * @returns Readable del contenido / Content readable
-     */
-    async stream() {
-        return media_stream(this._wa, this._raw);
-    }
-    /**
-     * Reacciones del mensaje agrupadas por emoji con su conteo.
-     * Message reactions grouped by emoji with their count.
-     *
-     * @returns Conteo por emoji / Per-emoji count
-     */
+        const path = `/chat/${this._raw.cid}/message/${this._raw.id}/content`;
+        const cached = await this._init.engine.get_buffer?.(path);
+        if (cached?.length)
+            return cached;
+        const legacy = deserialize(await this._init.engine.get(path));
+        return legacy?.data ? Buffer.from(legacy.data, 'base64') : Buffer.alloc(0);
+    }
+    /** Stream del contenido. / Content stream. */
+    async stream() { return Readable.from(await this.content()); }
+    /** Reacciones agrupadas por emoji con su conteo. / Reactions grouped by emoji with their count. */
     async reactions() {
         const counts = new Map();
-        for (const { emoji } of this._raw.reactions ?? []) {
+        for (const { emoji } of this._raw.reactions ?? [])
             counts.set(emoji, (counts.get(emoji) ?? 0) + 1);
-        }
         return [...counts.entries()].map(([emoji, count]) => ({ emoji, count }));
     }
     /**
      * Reacciona al mensaje; el emoji vacío retira la reacción.
-     * Reacts to the message; an empty emoji removes the reaction.
+     * Reacts to the message; an empty emoji removes it.
      *
      * @param emoji - Emoji o '' / Emoji or ''
-     * @returns true si se envió / true when sent
      */
     async react(emoji) {
-        let ok = false;
-        const socket = internals(this._wa).socket;
-        if (socket) {
-            const { cid, id, me, author } = this._raw;
-            await socket.sendMessage(cid, {
-                react: {
-                    text: emoji,
-                    key: { remoteJid: cid, id, fromMe: me, ...(cid.endsWith('@g.us') && !me && { participant: author }) },
-                },
-            });
-            ok = true;
-        }
-        return ok;
+        const { cid, id, me, author } = this._raw;
+        await this._init.socket.sendMessage(cid, {
+            react: { text: emoji, key: { remoteJid: cid, id, fromMe: me, ...(cid.endsWith('@g.us') && !me && { participant: author }) } },
+        });
+        return true;
     }
     /**
-     * Destaca o quita el destacado del mensaje.
+     * Destaca o quita el destacado.
      * Stars or unstars the message.
      *
      * @param value - true destaca / true stars
-     * @returns true si se envió / true when sent
      */
     async star(value) {
-        let ok = false;
-        const socket = internals(this._wa).socket;
-        if (socket) {
-            const doc = this._raw;
-            await socket.chatModify({ star: { messages: [{ id: doc.id, fromMe: doc.me }], star: value } }, doc.cid);
-            doc.starred = value;
-            await this._wa.engine.set(`/chat/${doc.cid}/message/${doc.id}`, serialize(doc), doc.created_at);
-            ok = true;
-        }
-        return ok;
+        const doc = this._raw;
+        await this._init.socket.chatModify({ star: { messages: [{ id: doc.id, fromMe: doc.me }], star: value } }, doc.cid);
+        doc.starred = value;
+        await this._init.engine.set(`/chat/${doc.cid}/message/${doc.id}`, serialize(doc), doc.created_at);
+        return true;
     }
-    /**
-     * Marca el mensaje como leído.
-     * Marks the message as read.
-     *
-     * @returns true si se envió / true when sent
-     */
+    /** Marca el mensaje como leído. / Marks the message as read. */
     async seen() {
-        let ok = false;
-        const socket = internals(this._wa).socket;
-        if (socket) {
-            const { cid, id, author } = this._raw;
-            await socket.readMessages([
-                { remoteJid: cid, id, participant: cid.endsWith('@g.us') ? author : undefined },
-            ]);
-            ok = true;
-        }
-        return ok;
+        const { cid, id, author } = this._raw;
+        await this._init.socket.readMessages([{ remoteJid: cid, id, participant: cid.endsWith('@g.us') ? author : undefined }]);
+        return true;
     }
     /**
      * Edita el caption del mensaje propio (texto, imagen o video).
      * Edits the own message caption (text, image or video).
      *
      * @param caption - Texto nuevo / New text
-     * @returns true si se editó / true when edited
+     * @returns false si el mensaje no es propio o su tipo no se puede editar / false when not own or its type cannot be edited
      */
     async edit(caption) {
         const doc = this._raw;
-        let ok = false;
-        const socket = internals(this._wa).socket;
-        if (socket && doc.me) {
-            if (doc.type === 'text') {
-                await socket.sendMessage(doc.cid, {
-                    text: caption,
-                    edit: { remoteJid: doc.cid, id: doc.id, fromMe: true },
-                });
-                const content_type = getContentType(doc.raw.message ?? {});
-                doc.raw.message =
-                    content_type === 'conversation' ? { conversation: caption } : { extendedTextMessage: { text: caption } };
-                ok = true;
-            }
-            else if (doc.type === 'image' || doc.type === 'video') {
-                const media_key = doc.type === 'image' ? 'imageMessage' : 'videoMessage';
-                const media = doc.raw.message?.[media_key];
-                if (media) {
-                    const edited = { [media_key]: { ...media, caption } };
-                    await socket.relayMessage(doc.cid, {
-                        protocolMessage: {
-                            key: { remoteJid: doc.cid, id: doc.id, fromMe: true },
-                            type: proto.Message.ProtocolMessage.Type.MESSAGE_EDIT,
-                            editedMessage: edited,
-                            timestampMs: Date.now(),
-                        },
-                    }, { messageId: generateMessageID() });
-                    doc.raw.message = { ...doc.raw.message, ...edited };
-                    ok = true;
-                }
-            }
-            if (ok) {
-                doc.caption = caption;
-                doc.edited = true;
-                await this._wa.engine.set(`/chat/${doc.cid}/message/${doc.id}`, serialize(doc), doc.created_at);
-            }
+        const media_key = doc.type === 'image' ? 'imageMessage' : doc.type === 'video' ? 'videoMessage' : null;
+        const media = media_key ? unwrap(doc.raw.message ?? {})[media_key] : null;
+        if (!doc.me || (doc.type !== 'text' && !media))
+            return false;
+        if (doc.type === 'text') {
+            await this._init.socket.sendMessage(doc.cid, { text: caption, edit: { remoteJid: doc.cid, id: doc.id, fromMe: true } });
+            doc.raw.message = getContentType(doc.raw.message ?? {}) === 'conversation' ? { conversation: caption } : { extendedTextMessage: { text: caption } };
+        }
+        else {
+            const edited = { [media_key]: { ...media, caption } };
+            await this._init.socket.relayMessage(doc.cid, {
+                protocolMessage: {
+                    key: { remoteJid: doc.cid, id: doc.id, fromMe: true },
+                    type: proto.Message.ProtocolMessage.Type.MESSAGE_EDIT,
+                    editedMessage: edited,
+                    timestampMs: Date.now(),
+                },
+            }, { messageId: generateMessageID() });
+            doc.raw.message = { ...doc.raw.message, ...edited };
         }
-        return ok;
+        doc.caption = caption;
+        doc.edited = true;
+        await this._init.engine.set(`/chat/${doc.cid}/message/${doc.id}`, serialize(doc), doc.created_at);
+        return true;
     }
     /**
      * Reenvía el mensaje a otro chat.
      * Forwards the message to another chat.
      *
      * @param target - CID, Chat o Contact destino / Target CID, Chat or Contact
-     * @returns true si se reenvió / true when forwarded
+     * @returns false si el destino es irresoluble o el contenido no admite reenvío / false when the target cannot be resolved or the content cannot be forwarded
      */
     async forward(target) {
-        const doc = this._raw;
-        const to_cid = typeof target === 'string' ? target : target instanceof Chat ? target._raw.id : (target.jid ?? target.lid ?? '');
-        let ok = false;
-        const socket = internals(this._wa).socket;
-        if (socket && to_cid) {
-            const jid = await internals(this._wa).resolve_jid(to_cid);
-            if (jid && doc.raw.message) {
-                try {
-                    const wa_msg = generateWAMessageFromContent(jid, generateForwardMessageContent(doc.raw, false), {
-                        userJid: socket.user?.id ?? '',
-                    });
-                    if (wa_msg.message && wa_msg.key?.id) {
-                        await socket.relayMessage(jid, wa_msg.message, { messageId: wa_msg.key.id });
-                        ok = true;
-                    }
-                }
-                catch {
-                    /* forward content may be unsupported */
-                }
-            }
+        const cid = typeof target === 'string' ? target : target instanceof Chat ? target._raw.id : target.jid ?? target.lid ?? '';
+        const jid = cid ? await jid_of(this._init.engine, cid, this._init.socket) : null;
+        if (!jid || !this._raw.raw.message)
+            return false;
+        try {
+            const msg = generateWAMessageFromContent(jid, generateForwardMessageContent(this._raw.raw, false), { userJid: this._init.socket.user?.id ?? '' });
+            if (!msg.message || !msg.key?.id)
+                return false;
+            await this._init.socket.relayMessage(jid, msg.message, { messageId: msg.key.id });
+            return true;
+        }
+        catch {
+            /* contenido no reenviable / non-forwardable content */
+            return false;
         }
-        return ok;
     }
     /**
      * Elimina el mensaje: solo en mi dispositivo por defecto, para todos con `true`.
      * Deletes the message: this device only by default, for everyone with `true`.
      *
      * @param all - true elimina para todos / true deletes for everyone
-     * @returns true si se eliminó / true when deleted
      */
     async delete(all = false) {
         const doc = this._raw;
-        let ok = false;
-        const socket = internals(this._wa).socket;
-        if (socket) {
-            if (all) {
-                await socket.sendMessage(doc.cid, { delete: { remoteJid: doc.cid, id: doc.id, fromMe: doc.me } });
-            }
-            else {
-                await socket.chatModify({
-                    deleteForMe: {
-                        deleteMedia: false,
-                        key: { remoteJid: doc.cid, id: doc.id, fromMe: doc.me },
-                        timestamp: Date.now(),
-                    },
-                }, doc.cid);
-            }
-            await this._wa.engine.unset(`/chat/${doc.cid}/message/${doc.id}`);
-            ok = true;
-        }
-        return ok;
+        if (all)
+            await this._init.socket.sendMessage(doc.cid, { delete: { remoteJid: doc.cid, id: doc.id, fromMe: doc.me } });
+        else
+            await this._init.socket.chatModify({ deleteForMe: { deleteMedia: false, key: { remoteJid: doc.cid, id: doc.id, fromMe: doc.me }, timestamp: Date.now() } }, doc.cid);
+        await this._init.engine.unset(`/chat/${doc.cid}/message/${doc.id}`);
+        return true;
     }
     /** Responde con texto. / Replies with text. */
-    async text(caption, extra = {}) {
-        return Message.text(this._wa, this._raw.cid, caption, { ...extra, mid: this._raw.id });
-    }
+    async text(caption, extra = {}) { return send(this._init, this._raw.cid, { text: caption }, undefined, { ...extra, mid: this._raw.id }); }
     /** Responde con imagen. / Replies with an image. */
-    async image(buf, extra = {}) {
-        return Message.image(this._wa, this._raw.cid, buf, { ...extra, mid: this._raw.id });
-    }
+    async image(buf, extra = {}) { return send(this._init, this._raw.cid, { image: buf, caption: extra.caption }, buf, { ...extra, mid: this._raw.id }); }
     /** Responde con video. / Replies with a video. */
-    async video(buf, extra = {}) {
-        return Message.video(this._wa, this._raw.cid, buf, { ...extra, mid: this._raw.id });
-    }
+    async video(buf, extra = {}) { return send(this._init, this._raw.cid, { video: buf, caption: extra.caption }, buf, { ...extra, mid: this._raw.id }); }
     /** Responde con audio. / Replies with audio. */
-    async audio(buf, extra = {}) {
-        return Message.audio(this._wa, this._raw.cid, buf, { ...extra, mid: this._raw.id });
-    }
+    async audio(buf, extra = {}) { return send(this._init, this._raw.cid, { audio: buf, ptt: extra.ptt ?? true }, buf, { ...extra, mid: this._raw.id }); }
     /** Responde con ubicación. / Replies with a location. */
-    async location(loc, extra = {}) {
-        return Message.location(this._wa, this._raw.cid, loc, { ...extra, mid: this._raw.id });
-    }
+    async location(loc, extra = {}) { return send(this._init, this._raw.cid, { location: { degreesLatitude: loc.lat, degreesLongitude: loc.lng } }, undefined, { ...extra, mid: this._raw.id }); }
     /** Responde con encuesta. / Replies with a poll. */
     async poll(input, extra = {}) {
-        return Message.poll(this._wa, this._raw.cid, input, { ...extra, mid: this._raw.id });
+        return send(this._init, this._raw.cid, poll_of(input, extra.multiple ?? false), undefined, { ...extra, mid: this._raw.id }, { multiple: extra.multiple ?? false });
     }
     /** Responde con documento. / Replies with a document. */
     async document(buf, extra) {
-        return Message.document(this._wa, this._raw.cid, buf, { ...extra, mid: this._raw.id });
+        return send(this._init, this._raw.cid, { document: buf, fileName: extra.file_name, mimetype: extra.mimetype ?? 'application/octet-stream', caption: extra.caption }, buf, { ...extra, mid: this._raw.id });
     }
     /** Responde con tarjeta(s) de contacto. / Replies with contact card(s). */
     async vcard(contacts, extra = {}) {
-        return Message.vcard(this._wa, this._raw.cid, contacts, { ...extra, mid: this._raw.id });
+        const cards = vcards_of(contacts);
+        return send(this._init, this._raw.cid, cards.content, cards.binary, { ...extra, mid: this._raw.id });
     }
     /** Responde con evento. / Replies with an event. */
     async event(data, extra = {}) {
-        return Message.event(this._wa, this._raw.cid, data, { ...extra, mid: this._raw.id });
-    }
-    /**
-     * Obtiene un mensaje por chat y id.
-     * Retrieves a message by chat and id.
-     *
-     * @param wa - Cliente dueño / Owner client
-     * @param cid - Identificador del chat / Chat identifier
-     * @param mid - Identificador del mensaje / Message identifier
-     * @returns Mensaje o null / Message or null
-     */
-    static async get(wa, cid, mid) {
-        const jid = await internals(wa).resolve_jid(cid);
-        if (jid) {
-            const doc = deserialize(await wa.engine.get(`/chat/${jid}/message/${mid}`));
-            if (doc)
-                return message(wa, doc);
-        }
-        return null;
-    }
-    /**
-     * Pagina los mensajes de un chat desde el más reciente.
-     * Paginates chat messages from the most recent one.
-     *
-     * @param wa - Cliente dueño / Owner client
-     * @param cid - Identificador del chat / Chat identifier
-     * @param offset - Desplazamiento / Offset
-     * @param limit - Tamaño de página / Page size
-     * @returns Página de mensajes / Message page
-     */
-    static async list(wa, cid, offset = 0, limit = 50) {
-        const jid = await internals(wa).resolve_jid(cid);
-        if (jid) {
-            return (await wa.engine.list(`/chat/${jid}/message`, offset, limit))
-                .map((raw) => deserialize(raw))
-                .filter((doc) => doc !== null)
-                .map((doc) => message(wa, doc));
-        }
-        return [];
-    }
-    /** Envía texto. / Sends text. */
-    static async text(wa, cid, caption, extra = {}) {
-        return send(wa, cid, { text: caption }, undefined, extra);
-    }
-    /** Envía imagen. / Sends an image. */
-    static async image(wa, cid, buf, extra = {}) {
-        return send(wa, cid, { image: buf, caption: extra.caption }, buf, extra);
-    }
-    /** Envía video. / Sends a video. */
-    static async video(wa, cid, buf, extra = {}) {
-        return send(wa, cid, { video: buf, caption: extra.caption }, buf, extra);
-    }
-    /** Envía audio. / Sends audio. */
-    static async audio(wa, cid, buf, extra = {}) {
-        return send(wa, cid, { audio: buf, ptt: extra.ptt ?? true }, buf, extra);
-    }
-    /** Envía ubicación. / Sends a location. */
-    static async location(wa, cid, loc, extra = {}) {
-        return send(wa, cid, { location: { degreesLatitude: loc.lat, degreesLongitude: loc.lng } }, undefined, extra);
-    }
-    /** Envía encuesta. / Sends a poll. */
-    static async poll(wa, cid, input, extra = {}) {
-        const multiple = extra.multiple ?? false;
-        return send(wa, cid, {
-            poll: {
-                name: input.content,
-                values: input.options.map((option) => option.content),
-                selectableCount: multiple ? 0 : 1,
-            },
-        }, undefined, extra, { multiple });
-    }
-    /** Envía documento. / Sends a document. */
-    static async document(wa, cid, buf, extra) {
-        return send(wa, cid, { document: buf, fileName: extra.file_name, mimetype: extra.mimetype ?? 'application/octet-stream', caption: extra.caption }, buf, extra);
-    }
-    /** Envía tarjeta(s) de contacto. / Sends contact card(s). */
-    static async vcard(wa, cid, contacts, extra = {}) {
-        const built = contacts.map((entry) => ({
-            displayName: entry.name,
-            vcard: [
-                'BEGIN:VCARD',
-                'VERSION:3.0',
-                `FN:${entry.name}`,
-                `TEL;type=CELL;waid=${entry.phone.replace(/\D+/g, '')}:${entry.phone}`,
-                'END:VCARD',
-            ].join('\n'),
-        }));
-        return send(wa, cid, { contacts: { contacts: built } }, Buffer.from(built.map((entry) => entry.vcard).join('\n'), 'utf-8'), extra);
-    }
-    /** Envía evento. / Sends an event. */
-    static async event(wa, cid, data, extra = {}) {
-        const binary = Buffer.from(JSON.stringify({ name: data.name, caption: data.caption, start: data.start.getTime(), end: data.end?.getTime() ?? null }), 'utf-8');
-        return send(wa, cid, {
-            event: {
-                name: data.name,
-                description: data.caption,
-                startDate: data.start,
-                endDate: data.end,
-                location: data.place ? { degreesLatitude: data.place.lat, degreesLongitude: data.place.lng } : undefined,
-            },
-        }, binary, extra);
-    }
-    /** Reacciona a un mensaje por id. / Reacts to a message by id. */
-    static async react(wa, cid, mid, emoji) {
-        const msg = await Message.get(wa, cid, mid);
-        return msg ? msg.react(emoji) : false;
-    }
-    /** Destaca un mensaje por id. / Stars a message by id. */
-    static async star(wa, cid, mid, value) {
-        const msg = await Message.get(wa, cid, mid);
-        return msg ? msg.star(value) : false;
-    }
-    /** Marca un mensaje como leído por id. / Marks a message as read by id. */
-    static async seen(wa, cid, mid) {
-        const msg = await Message.get(wa, cid, mid);
-        return msg ? msg.seen() : false;
-    }
-    /** Edita un mensaje por id. / Edits a message by id. */
-    static async edit(wa, cid, mid, caption) {
-        const msg = await Message.get(wa, cid, mid);
-        return msg ? msg.edit(caption) : false;
-    }
-    /** Reenvía un mensaje por id. / Forwards a message by id. */
-    static async forward(wa, cid, mid, target) {
-        const msg = await Message.get(wa, cid, mid);
-        return msg ? msg.forward(target) : false;
-    }
-    /** Elimina un mensaje por id. / Deletes a message by id. */
-    static async delete(wa, cid, mid, all = false) {
-        const msg = await Message.get(wa, cid, mid);
-        return msg ? msg.delete(all) : false;
-    }
-    /** Reacciones de un mensaje por id. / Reactions of a message by id. */
-    static async reactions(wa, cid, mid) {
-        const msg = await Message.get(wa, cid, mid);
-        return msg ? msg.reactions() : [];
+        const built = event_of(data);
+        return send(this._init, this._raw.cid, built.content, built.binary, { ...extra, mid: this._raw.id });
     }
 }
 /**
@@ -678,214 +340,94 @@ export class Message {
  * Text message; `preview()` exposes the embedded link card.
  */
 export class Text extends Message {
-    /**
-     * Preview del enlace del texto, o null cuando no trae metadata.
-     * Text link preview, or null when it carries no metadata.
-     *
-     * @returns { link, name, content, thumb } o null / { link, name, content, thumb } or null
-     */
+    /** Preview del enlace, o null cuando el texto no trae metadata. / Link preview, or null when the text carries no metadata. */
     async preview() {
         const ext = this._raw.raw.message?.extendedTextMessage;
-        if (ext?.matchedText && (ext.title || ext.description)) {
-            return {
-                link: ext.matchedText,
-                name: ext.title ?? null,
-                content: ext.description ?? null,
-                thumb: to_buffer(ext.jpegThumbnail),
-            };
-        }
-        return null;
+        return ext?.matchedText && (ext.title || ext.description)
+            ? { link: ext.matchedText, name: ext.title ?? null, content: ext.description ?? null, thumb: to_buffer(ext.jpegThumbnail) }
+            : null;
     }
 }
 /**
- * Mensaje de imagen: dimensiones, peso y miniatura.
- * Image message: dimensions, size and thumbnail.
+ * Base de los mensajes con binario: dimensiones, peso, miniatura y descarga.
+ * Base for binary messages: dimensions, size, thumbnail and download.
  */
-export class Image extends Message {
-    /** @internal */
+class Media extends Message {
+    /** @internal Bloque de media del raw, común a los cinco tipos. / Raw media block, shared by the five types. */
     get _media() {
-        return unwrap(this._raw.raw.message ?? {}).imageMessage;
+        const msg = unwrap(this._raw.raw.message ?? {});
+        return (msg.imageMessage ?? msg.videoMessage ?? msg.audioMessage ?? msg.stickerMessage ?? msg.documentMessage ?? null);
     }
     /** Ancho en píxeles. / Width in pixels. */
-    get width() {
-        return this._media?.width ?? 0;
-    }
+    get width() { return this._media?.width ?? 0; }
     /** Alto en píxeles. / Height in pixels. */
-    get height() {
-        return this._media?.height ?? 0;
-    }
+    get height() { return this._media?.height ?? 0; }
     /** Peso en bytes. / Size in bytes. */
-    get size() {
-        return to_number(this._media?.fileLength);
-    }
-    /**
-     * Miniatura JPEG embebida, o null.
-     * Embedded JPEG thumbnail, or null.
-     *
-     * @returns Buffer de la miniatura o null / Thumbnail buffer or null
-     */
-    async thumb() {
-        return to_buffer(this._media?.jpegThumbnail);
-    }
+    get size() { return Number(this._media?.fileLength?.toString() ?? 0); }
+    /** Miniatura JPEG embebida, o null. / Embedded JPEG thumbnail, or null. */
+    async thumb() { return to_buffer(this._media?.jpegThumbnail); }
+    /** Binario del media: el persistido, o la descarga de baileys. / Media binary: the persisted one, or the baileys download. */
     async content() {
-        return drain(await this.stream());
-    }
-}
-/**
- * Mensaje de video: dimensiones, duración, peso y miniatura.
- * Video message: dimensions, duration, size and thumbnail.
- */
-export class Video extends Message {
-    /** @internal */
-    get _media() {
-        return unwrap(this._raw.raw.message ?? {}).videoMessage;
-    }
-    /** Ancho en píxeles. / Width in pixels. */
-    get width() {
-        return this._media?.width ?? 0;
+        const cached = await super.content();
+        if (cached.length)
+            return cached;
+        const raw = await downloadMediaMessage(this._raw.raw, 'buffer', {}).catch(() => Buffer.alloc(0));
+        return Buffer.isBuffer(raw) ? raw : Buffer.alloc(0);
     }
-    /** Alto en píxeles. / Height in pixels. */
-    get height() {
-        return this._media?.height ?? 0;
+    /** Stream del media sin acumularlo cuando hay que descargar. / Media stream without buffering when a download is needed. */
+    async stream() {
+        const cached = await super.content();
+        return cached.length
+            ? Readable.from(cached)
+            : (await downloadMediaMessage(this._raw.raw, 'stream', {}).catch(() => Readable.from(Buffer.alloc(0))));
     }
+}
+/** Mensaje de imagen. / Image message. */
+export class Image extends Media {
+}
+/** Mensaje de video. / Video message. */
+export class Video extends Media {
     /** Duración en segundos. / Duration in seconds. */
-    get duration() {
-        return this._media?.seconds ?? 0;
-    }
-    /** Peso en bytes. / Size in bytes. */
-    get size() {
-        return to_number(this._media?.fileLength);
-    }
-    /**
-     * Miniatura JPEG embebida, o null.
-     * Embedded JPEG thumbnail, or null.
-     *
-     * @returns Buffer de la miniatura o null / Thumbnail buffer or null
-     */
-    async thumb() {
-        return to_buffer(this._media?.jpegThumbnail);
-    }
-    async content() {
-        return drain(await this.stream());
-    }
+    get duration() { return this._media?.seconds ?? 0; }
 }
-/**
- * Mensaje de audio: nota de voz o archivo, con forma de onda del protocolo.
- * Audio message: voice note or file, with the protocol waveform.
- */
-export class Audio extends Message {
-    /** @internal */
-    get _media() {
-        return unwrap(this._raw.raw.message ?? {}).audioMessage;
-    }
+/** Mensaje de audio: nota de voz o archivo. / Audio message: voice note or file. */
+export class Audio extends Media {
     /** true si es nota de voz. / true when push-to-talk. */
-    get ptt() {
-        return this._media?.ptt === true;
-    }
+    get ptt() { return this._media?.ptt === true; }
     /** Duración en segundos. / Duration in seconds. */
-    get duration() {
-        return this._media?.seconds ?? 0;
-    }
-    /** Peso en bytes. / Size in bytes. */
-    get size() {
-        return to_number(this._media?.fileLength);
-    }
+    get duration() { return this._media?.seconds ?? 0; }
     /** Forma de onda 0-100 lista para pintar. / Paint-ready 0-100 waveform. */
-    get waveform() {
-        const wave = this._media?.waveform;
-        const bytes = wave instanceof Uint8Array ? wave : typeof wave === 'string' ? Buffer.from(wave, 'base64') : Buffer.alloc(0);
-        return Array.from(bytes);
-    }
-    async content() {
-        return drain(await this.stream());
-    }
+    get waveform() { return Array.from(to_buffer(this._media?.waveform) ?? []); }
 }
-/**
- * Mensaje de sticker: dimensiones, peso y animación.
- * Sticker message: dimensions, size and animation.
- */
-export class Sticker extends Message {
-    /** @internal */
-    get _media() {
-        return unwrap(this._raw.raw.message ?? {}).stickerMessage;
-    }
-    /** Ancho en píxeles. / Width in pixels. */
-    get width() {
-        return this._media?.width ?? 0;
-    }
-    /** Alto en píxeles. / Height in pixels. */
-    get height() {
-        return this._media?.height ?? 0;
-    }
+/** Mensaje de sticker. / Sticker message. */
+export class Sticker extends Media {
     /** true si el sticker es animado. / true when animated. */
-    get animated() {
-        return this._media?.isAnimated === true;
-    }
-    /** Peso en bytes. / Size in bytes. */
-    get size() {
-        return to_number(this._media?.fileLength);
-    }
-    async content() {
-        return drain(await this.stream());
-    }
+    get animated() { return this._media?.isAnimated === true; }
 }
-/**
- * Mensaje de documento; el MIME real vive en `mime` de la base.
- * Document message; the actual MIME lives in the base `mime`.
- */
-export class Document extends Message {
-    /** @internal */
-    get _media() {
-        return unwrap(this._raw.raw.message ?? {}).documentMessage;
-    }
+/** Mensaje de documento; el MIME real vive en `mime`. / Document message; the actual MIME lives in `mime`. */
+export class Document extends Media {
     /** Nombre del archivo. / File name. */
-    get name() {
-        return this._media?.fileName ?? '';
-    }
+    get name() { return this._media?.fileName ?? ''; }
     /** Número de páginas (PDF); 0 cuando no aplica. / Page count (PDF); 0 when not applicable. */
-    get pages() {
-        return this._media?.pageCount ?? 0;
-    }
-    /** Peso en bytes. / Size in bytes. */
-    get size() {
-        return to_number(this._media?.fileLength);
-    }
-    async content() {
-        return drain(await this.stream());
-    }
+    get pages() { return this._media?.pageCount ?? 0; }
 }
-/**
- * Mensaje de ubicación, fija o en vivo.
- * Location message, static or live.
- */
+/** Mensaje de ubicación, fija o en vivo. / Location message, static or live. */
 export class Location extends Message {
-    /** @internal */
-    get _loc() {
-        return this._raw.raw.message?.locationMessage ?? this._raw.raw.message?.liveLocationMessage;
-    }
     /** Latitud en grados. / Latitude in degrees. */
-    get lat() {
-        return this._loc?.degreesLatitude ?? 0;
-    }
+    get lat() { return (this._raw.raw.message?.locationMessage ?? this._raw.raw.message?.liveLocationMessage)?.degreesLatitude ?? 0; }
     /** Longitud en grados. / Longitude in degrees. */
-    get lng() {
-        return this._loc?.degreesLongitude ?? 0;
-    }
+    get lng() { return (this._raw.raw.message?.locationMessage ?? this._raw.raw.message?.liveLocationMessage)?.degreesLongitude ?? 0; }
     /** true si es ubicación en tiempo real. / true when live location. */
-    get live() {
-        return Boolean(this._raw.raw.message?.liveLocationMessage);
-    }
+    get live() { return Boolean(this._raw.raw.message?.liveLocationMessage); }
     /** URL de Google Maps de la coordenada. / Google Maps URL for the coordinate. */
-    get link() {
-        return `https://www.google.com/maps/@${this.lat},${this.lng},15z`;
-    }
+    get link() { return `https://www.google.com/maps/@${this.lat},${this.lng},15z`; }
 }
 /**
  * Mensaje de encuesta: opciones con conteo, votos por contacto y voto propio.
  * Poll message: options with counts, per-contact votes and self-voting.
  */
 export class Poll extends Message {
-    /** @internal */
+    /** @internal Bloque de la encuesta en el raw. / Raw poll block. */
     get _poll() {
         const msg = this._raw.raw.message;
         return msg?.pollCreationMessage ?? msg?.pollCreationMessageV2 ?? msg?.pollCreationMessageV3;
@@ -894,164 +436,109 @@ export class Poll extends Message {
     get _updates() {
         return (this._raw.raw.pollUpdates ?? []).map((update) => ({
             ...update,
-            vote: update.vote
-                ? {
-                    ...update.vote,
-                    selectedOptions: (update.vote.selectedOptions ?? []).map((option) => typeof option === 'string' ? Buffer.from(option, 'base64') : option),
-                }
-                : update.vote,
+            vote: update.vote && {
+                ...update.vote,
+                selectedOptions: (update.vote.selectedOptions ?? []).map((option) => (typeof option === 'string' ? Buffer.from(option, 'base64') : option)),
+            },
         }));
     }
     /** true si admite varias respuestas. / true when multi-select. */
     get multiple() {
-        if (typeof this._raw.multiple === 'boolean') {
-            return this._raw.multiple;
-        }
-        return (this._poll?.selectableOptionsCount ?? 1) !== 1;
+        return typeof this._raw.multiple === 'boolean' ? this._raw.multiple : (this._poll?.selectableOptionsCount ?? 1) !== 1;
     }
     /** Opciones con su conteo de votos. / Options with their vote counts. */
     get options() {
-        const aggregated = getAggregateVotesInPollMessage({ message: this._raw.raw.message ?? undefined, pollUpdates: this._updates }, internals(this._wa).socket?.user?.id);
+        const aggregated = getAggregateVotesInPollMessage({ message: this._raw.raw.message ?? undefined, pollUpdates: this._updates }, this._init.socket.user?.id);
         const counts = new Map(aggregated.map((entry) => [entry.name, entry.voters.length]));
-        return (this._poll?.options ?? []).map((option) => ({
-            name: option.optionName ?? '',
-            count: counts.get(option.optionName ?? '') ?? 0,
-        }));
+        return (this._poll?.options ?? []).map((option) => ({ name: option.optionName ?? '', count: counts.get(option.optionName ?? '') ?? 0 }));
     }
-    /**
-     * Votos individuales: opción elegida y teléfono del votante.
-     * Individual votes: chosen option and voter phone.
-     *
-     * @returns Lista de votos / Vote list
-     */
+    /** Votos individuales: opción elegida y teléfono del votante. / Individual votes: chosen option and voter phone. */
     async votes() {
-        const aggregated = getAggregateVotesInPollMessage({ message: this._raw.raw.message ?? undefined, pollUpdates: this._updates }, internals(this._wa).socket?.user?.id);
+        const aggregated = getAggregateVotesInPollMessage({ message: this._raw.raw.message ?? undefined, pollUpdates: this._updates }, this._init.socket.user?.id);
         const result = [];
         for (const entry of aggregated) {
             for (const voter of entry.voters) {
-                const jid = await internals(this._wa).resolve_jid(voter);
+                const jid = await jid_of(this._init.engine, voter, this._init.socket);
                 result.push({ name: entry.name, contact: (jid ?? voter).split('@')[0].split(':')[0] });
             }
         }
         return result;
     }
     /**
-     * Vota en la encuesta con uno o varios índices. Cifra el voto (HMAC+AES-GCM) y lo
-     * enruta al chat @lid con la identidad LID propia. Best-effort: el voto entrante
-     * descifra correcto, pero WhatsApp no propaga el voto emitido desde un dispositivo
-     * vinculado (companion).
-     * Votes in the poll with one or more indexes. Encrypts the vote (HMAC+AES-GCM) and
-     * routes it to the @lid chat with the own LID identity. Best-effort: incoming votes
-     * decrypt fine, but WhatsApp does not propagate votes emitted from a linked
-     * (companion) device.
+     * Vota con uno o varios índices: cifra el voto (HMAC+AES-GCM) y lo enruta al chat @lid
+     * con la identidad LID propia. Best-effort: WhatsApp no propaga el voto emitido desde un
+     * dispositivo vinculado.
+     * Votes with one or more indexes: encrypts the vote (HMAC+AES-GCM) and routes it to the
+     * @lid chat with the own LID identity. Best-effort: WhatsApp does not propagate votes
+     * emitted from a linked device.
      *
      * @param index - Índice o índices de la opción / Option index or indexes
      * @returns true si el voto se emitió / true when the vote was relayed
      */
     async select(index) {
+        const { socket, engine } = this._init;
         const doc = this._raw;
-        const opts = this._poll?.options ?? [];
-        const selected_options = (Array.isArray(index) ? index : [index])
-            .filter((i) => i >= 0 && i < opts.length)
-            .map((i) => sha256(Buffer.from(opts[i].optionName ?? '')));
+        const options = this._poll?.options ?? [];
+        const selected = (Array.isArray(index) ? index : [index]).filter((i) => i >= 0 && i < options.length).map((i) => sha256(Buffer.from(options[i].optionName ?? '')));
         const secret_raw = doc.raw.message?.messageContextInfo?.messageSecret;
-        const poll_enc_key = typeof secret_raw === 'string' ? Buffer.from(secret_raw, 'base64') : secret_raw;
-        const socket = internals(this._wa).socket;
-        if (!poll_enc_key || !socket || selected_options.length === 0) {
+        const secret = typeof secret_raw === 'string' ? Buffer.from(secret_raw, 'base64') : secret_raw;
+        if (!secret || selected.length === 0)
             return false;
-        }
-        const poll_key = doc.raw.key ?? {};
-        const self_id = socket.user?.id ?? '';
-        const self_lid = socket.user?.lid ?? '';
-        let dest = doc.cid;
-        if (poll_key.remoteJid?.endsWith('@lid')) {
-            dest = poll_key.remoteJid;
-        }
-        else if (!doc.cid.endsWith('@lid')) {
-            const contact_raw = deserialize(await this._wa.engine.get(`/contact/${doc.cid}`));
-            const mapped = await socket.signalRepository?.lidMapping?.getLIDForPN(doc.cid).catch(() => null);
-            dest = contact_raw?.lid ?? mapped ?? doc.cid;
-        }
-        const self_for_send = dest.endsWith('@lid') && self_lid ? self_lid : self_id;
-        const voter_jid = jidNormalizedUser(self_for_send);
-        const poll_creator_jid = jidNormalizedUser(poll_key.fromMe
-            ? self_for_send
-            : poll_key.remoteJid?.endsWith('@lid')
-                ? poll_key.remoteJid
-                : getKeyAuthor(poll_key, self_id));
-        const sign = Buffer.concat([
-            Buffer.from(doc.id),
-            Buffer.from(poll_creator_jid),
-            Buffer.from(voter_jid),
-            Buffer.from('Poll Vote'),
-            new Uint8Array([1]),
-        ]);
-        const enc_key = hmacSign(sign, hmacSign(poll_enc_key, new Uint8Array(32), 'sha256'), 'sha256');
-        const enc_iv = randomBytes(12);
-        const enc_payload = aesEncryptGCM(proto.Message.PollVoteMessage.encode({ selectedOptions: selected_options }).finish(), enc_key, enc_iv, Buffer.from(`${doc.id}\x00${voter_jid}`));
-        const msg_id = generateMessageID();
+        const key = doc.raw.key ?? {};
+        const self = socket.user?.id ?? '';
+        const dest = key.remoteJid?.endsWith('@lid') ? key.remoteJid
+            : doc.cid.endsWith('@lid') ? doc.cid
+                : deserialize(await engine.get(`/contact/${doc.cid}`))?.lid
+                    ?? await socket.signalRepository?.lidMapping?.getLIDForPN(doc.cid).catch(() => null)
+                    ?? doc.cid;
+        const mine = dest.endsWith('@lid') && socket.user?.lid ? socket.user.lid : self;
+        const voter = jidNormalizedUser(mine);
+        const creator = jidNormalizedUser(key.fromMe ? mine : key.remoteJid?.endsWith('@lid') ? key.remoteJid : getKeyAuthor(key, self));
+        const sign = Buffer.concat([Buffer.from(doc.id), Buffer.from(creator), Buffer.from(voter), Buffer.from('Poll Vote'), new Uint8Array([1])]);
+        const enc_key = hmacSign(sign, hmacSign(secret, new Uint8Array(32), 'sha256'), 'sha256');
+        const iv = randomBytes(12);
+        const payload = aesEncryptGCM(proto.Message.PollVoteMessage.encode({ selectedOptions: selected }).finish(), enc_key, iv, Buffer.from(`${doc.id}\x00${voter}`));
+        const mid = generateMessageID();
         await socket.relayMessage(dest, {
             pollUpdateMessage: {
                 pollCreationMessageKey: dest === doc.cid ? doc.raw.key : { ...doc.raw.key, remoteJid: dest },
-                vote: { encPayload: enc_payload, encIv: enc_iv },
+                vote: { encPayload: payload, encIv: iv },
                 senderTimestampMs: Date.now(),
             },
-        }, { messageId: msg_id });
+        }, { messageId: mid });
         updateMessageWithPollUpdate(doc.raw, {
-            pollUpdateMessageKey: { remoteJid: doc.raw.key?.remoteJid ?? doc.cid, fromMe: true, id: msg_id },
-            vote: { selectedOptions: selected_options },
+            pollUpdateMessageKey: { remoteJid: doc.raw.key?.remoteJid ?? doc.cid, fromMe: true, id: mid },
+            vote: { selectedOptions: selected },
             senderTimestampMs: Date.now(),
         });
-        await this._wa.engine.set(`/chat/${doc.cid}/message/${doc.id}`, serialize(doc), doc.created_at);
-        this._wa.emit('message:updated', this, await this.chat(), this._wa);
+        await engine.set(`/chat/${doc.cid}/message/${doc.id}`, serialize(doc), doc.created_at);
+        this._init.wa.emit('message:updated', this, await this.chat(), this._init.wa);
         return true;
     }
 }
-/**
- * Mensaje de tarjeta(s) de contacto.
- * Contact card(s) message.
- */
+/** Mensaje de tarjeta(s) de contacto. / Contact card(s) message. */
 export class VCard extends Message {
     /** Contactos de la tarjeta. / Card contacts. */
     get contacts() {
         const msg = this._raw.raw.message;
         const raw = msg?.contactsArrayMessage?.contacts ?? (msg?.contactMessage ? [msg.contactMessage] : []);
-        return raw.map((card) => {
-            const tel = (card.vcard ?? '').match(/TEL[^:]*:(.+)/);
-            return { name: card.displayName ?? '', phone: tel ? tel[1].trim() : '' };
-        });
+        return raw.map((card) => ({ name: card.displayName ?? '', phone: (card.vcard ?? '').match(/TEL[^:]*:(.+)/)?.[1].trim() ?? '' }));
     }
 }
-/**
- * Mensaje de evento de calendario.
- * Calendar event message.
- */
+/** Mensaje de evento de calendario. / Calendar event message. */
 export class Event extends Message {
-    /** @internal */
-    get _event() {
-        return this._raw.raw.message?.eventMessage;
-    }
+    /** @internal Bloque del evento en el raw. / Raw event block. */
+    get _event() { return this._raw.raw.message?.eventMessage; }
     /** Nombre del evento. / Event name. */
-    get name() {
-        return this._event?.name ?? '';
-    }
+    get name() { return this._event?.name ?? ''; }
     /** Inicio en ISO UTC. / Start as ISO UTC. */
-    get start() {
-        return new Date(to_number(this._event?.startTime) * 1000).toISOString();
-    }
+    get start() { return new Date(Number(this._event?.startTime?.toString() ?? 0) * 1_000).toISOString(); }
     /** Fin en ISO UTC, o null. / End as ISO UTC, or null. */
-    get end() {
-        const end = this._event?.endTime;
-        return end == null ? null : new Date(to_number(end) * 1000).toISOString();
-    }
+    get end() { return this._event?.endTime == null ? null : new Date(Number(this._event.endTime.toString()) * 1_000).toISOString(); }
     /** true si fue cancelado. / true when canceled. */
-    get canceled() {
-        return this._event?.isCanceled ?? false;
-    }
+    get canceled() { return this._event?.isCanceled ?? false; }
     /** Link de unión, si aplica. / Join link, if any. */
-    get link() {
-        return this._event?.joinLink ?? '';
-    }
+    get link() { return this._event?.joinLink ?? ''; }
     /** Ubicación del evento, o null. / Event location, or null. */
     get place() {
         const loc = this._event?.location;
@@ -1059,74 +546,96 @@ export class Event extends Message {
     }
 }
 /**
- * Factoría de Message: evalúa el tipo y retorna la instancia de la subclase correcta.
- * Acepta el documento persistido o el mensaje crudo de baileys — en ese caso el
- * documento se deriva aquí mismo (id, tipo, autor, caption, mime, fechas).
- * Message factory: evaluates the type and returns the right subclass instance. Accepts
- * the persisted document or the raw baileys message — in that case the document is
- * derived right here (id, type, author, caption, mime, dates).
+ * Mensaje ligado a la sesión viva: la misma clase con los envíos, las lecturas, las acciones
+ * por id y las subclases para `instanceof`.
+ * Message bound to the live session: the same class with sends, reads, by-id actions and the
+ * subclasses for `instanceof`.
  *
- * @param wa - Instancia principal / Main WhatsApp instance
- * @param raw - Documento persistido o WAMessage crudo / Persisted document or raw WAMessage
- * @returns Instancia del tipo correcto / Right-type instance
+ * @param init - Sesión activa: cliente, motor y socket / Active session: client, engine and socket
+ * @returns Clase `Message` con acceso a la sesión / `Message` class with session access
  */
-export function message(wa, raw) {
-    let doc;
-    if ('key' in raw) {
-        const key = raw.key ?? {};
-        const unwrapped = unwrap(raw.message ?? {});
-        const content_type = getContentType(unwrapped);
-        const msg_type = MESSAGE_TYPE_MAP[content_type] ?? 'text';
-        const msg_content = unwrapped[content_type];
-        const context_info = msg_content?.contextInfo;
-        const ephemeral_duration = raw.ephemeralDuration ?? context_info?.expiration;
-        const self_id = internals(wa).socket?.user?.id;
-        doc = {
-            id: key.id ?? '',
-            cid: key.remoteJidAlt ?? key.remoteJid ?? '',
-            mid: context_info?.stanzaId ?? null,
-            me: key.fromMe ?? false,
-            type: msg_type,
-            author: key.fromMe && self_id
-                ? jidNormalizedUser(self_id)
-                : key.participant || key.remoteJidAlt || key.remoteJid || '',
-            status: raw.status ?? 1,
-            starred: raw.starred ?? false,
-            forwarded: context_info?.isForwarded ?? false,
-            created_at: (Number(raw.messageTimestamp) || Math.floor(Date.now() / 1000)) * 1000,
-            deleted_at: raw.ephemeralStartTimestamp != null && ephemeral_duration != null
-                ? (Number(raw.ephemeralStartTimestamp) + ephemeral_duration) * 1000
-                : null,
-            mime: typeof msg_content === 'object' && msg_type !== 'text'
-                ? (msg_content?.mimetype ?? 'application/octet-stream')
-                : 'text/plain',
-            caption: typeof msg_content === 'string'
-                ? msg_content
-                : msg_type === 'event'
-                    ? (msg_content?.description ?? '')
-                    : (msg_content?.caption ??
-                        msg_content?.text ??
-                        msg_content?.name ??
-                        msg_content?.displayName ??
-                        ''),
-            edited: false,
-            raw,
-        };
-    }
-    else {
-        doc = raw;
-    }
-    const types = {
-        text: Text,
-        image: Image,
-        video: Video,
-        audio: Audio,
-        sticker: Sticker,
-        document: Document,
-        location: Location,
-        poll: Poll,
-        vcard: VCard,
-        event: Event,
+export function message(init) {
+    return class extends Message {
+        static { this.Text = Text; }
+        static { this.Image = Image; }
+        static { this.Video = Video; }
+        static { this.Audio = Audio; }
+        static { this.Sticker = Sticker; }
+        static { this.Document = Document; }
+        static { this.Location = Location; }
+        static { this.Poll = Poll; }
+        static { this.VCard = VCard; }
+        static { this.Event = Event; }
+        /**
+         * Mensaje por chat e id.
+         * Message by chat and id.
+         *
+         * @param cid - Teléfono, JID o LID del chat / Chat phone, JID or LID
+         * @param mid - Identificador del mensaje / Message identifier
+         */
+        static async get(cid, mid) {
+            const jid = await jid_of(init.engine, cid, init.socket);
+            const doc = jid ? deserialize(await init.engine.get(`/chat/${jid}/message/${mid}`)) : null;
+            return doc ? new Message(init, doc) : null;
+        }
+        /**
+         * Pagina los mensajes del chat, del más reciente al más antiguo.
+         * Paginates chat messages, from the most recent to the oldest.
+         *
+         * @param cid - Teléfono, JID o LID del chat / Chat phone, JID or LID
+         * @param offset - Desplazamiento / Offset
+         * @param limit - Tamaño de página / Page size
+         */
+        static async list(cid, offset = 0, limit = 50) {
+            const jid = await jid_of(init.engine, cid, init.socket);
+            return jid
+                ? (await init.engine.list(`/chat/${jid}/message`, offset, limit))
+                    .map((raw) => deserialize(raw))
+                    .filter((doc) => doc !== null)
+                    .map((doc) => new Message(init, doc))
+                : [];
+        }
+        /** Envía texto. / Sends text. */
+        static async text(cid, caption, extra = {}) { return send(init, cid, { text: caption }, undefined, extra); }
+        /** Envía imagen. / Sends an image. */
+        static async image(cid, buf, extra = {}) { return send(init, cid, { image: buf, caption: extra.caption }, buf, extra); }
+        /** Envía video. / Sends a video. */
+        static async video(cid, buf, extra = {}) { return send(init, cid, { video: buf, caption: extra.caption }, buf, extra); }
+        /** Envía audio. / Sends audio. */
+        static async audio(cid, buf, extra = {}) { return send(init, cid, { audio: buf, ptt: extra.ptt ?? true }, buf, extra); }
+        /** Envía ubicación. / Sends a location. */
+        static async location(cid, loc, extra = {}) { return send(init, cid, { location: { degreesLatitude: loc.lat, degreesLongitude: loc.lng } }, undefined, extra); }
+        /** Envía encuesta. / Sends a poll. */
+        static async poll(cid, input, extra = {}) {
+            return send(init, cid, poll_of(input, extra.multiple ?? false), undefined, extra, { multiple: extra.multiple ?? false });
+        }
+        /** Envía documento. / Sends a document. */
+        static async document(cid, buf, extra) {
+            return send(init, cid, { document: buf, fileName: extra.file_name, mimetype: extra.mimetype ?? 'application/octet-stream', caption: extra.caption }, buf, extra);
+        }
+        /** Envía tarjeta(s) de contacto. / Sends contact card(s). */
+        static async vcard(cid, contacts, extra = {}) {
+            const cards = vcards_of(contacts);
+            return send(init, cid, cards.content, cards.binary, extra);
+        }
+        /** Envía evento. / Sends an event. */
+        static async event(cid, data, extra = {}) {
+            const built = event_of(data);
+            return send(init, cid, built.content, built.binary, extra);
+        }
+        /** Reacciona a un mensaje por id. / Reacts to a message by id. */
+        static async react(cid, mid, emoji) { return (await this.get(cid, mid))?.react(emoji) ?? false; }
+        /** Destaca un mensaje por id. / Stars a message by id. */
+        static async star(cid, mid, value) { return (await this.get(cid, mid))?.star(value) ?? false; }
+        /** Marca un mensaje como leído por id. / Marks a message as read by id. */
+        static async seen(cid, mid) { return (await this.get(cid, mid))?.seen() ?? false; }
+        /** Edita un mensaje por id. / Edits a message by id. */
+        static async edit(cid, mid, caption) { return (await this.get(cid, mid))?.edit(caption) ?? false; }
+        /** Reenvía un mensaje por id. / Forwards a message by id. */
+        static async forward(cid, mid, target) { return (await this.get(cid, mid))?.forward(target) ?? false; }
+        /** Elimina un mensaje por id. / Deletes a message by id. */
+        static async delete(cid, mid, all = false) { return (await this.get(cid, mid))?.delete(all) ?? false; }
+        /** Reacciones de un mensaje por id. / Reactions of a message by id. */
+        static async reactions(cid, mid) { return (await this.get(cid, mid))?.reactions() ?? []; }
     };
-    return new (types[doc.type] ?? Message)(wa, doc);
 }