@arcaelas/whatsapp 7.0.1 → 7.2.0

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

@@ -45,10 +45,26 @@ const contact_1 = require("../../lib/contact");
 const message_1 = __importStar(require("../../lib/message"));
 const status_1 = require("../../lib/status");
 const store_1 = require("../../lib/store");
+/**
+ * WhatsApp devuelve el nombre de la propia cuenta enmascarado —«+58∙∙∙∙∙∙∙∙40»— cuando el perfil
+ * no viajó completo. Eso no es un nombre: aceptarlo tapa al verdadero, que sí está guardado en
+ * la ficha del contacto propio.
+ * WhatsApp returns the own account name masked —«+58∙∙∙∙∙∙∙∙40»— when the profile did not travel
+ * whole. That is not a name: taking it hides the real one, which is stored on the own contact
+ * card.
+ */
+const readable = (value) => (value && !/^\+?[\d\s·•∙⋅]+$/.test(value) ? value : null);
 class WhatsApp {
     #event = new node_events_1.EventEmitter();
     #options;
     #close = null;
+    /**
+     * Cierre completo: desvincula del teléfono y termina el socket. Es distinto de `#close`,
+     * que sólo cuelga —lo que hace falta al reconectar, donde desvincular sería absurdo—.
+     * Full close: unlinks from the phone and ends the socket. Distinct from `#close`, which
+     * merely hangs up —what reconnecting needs, where unlinking would be absurd—.
+     */
+    #unlink = null;
     constructor(options) {
         this.engine = options.engine;
         this.#options = options;
@@ -70,7 +86,7 @@ class WhatsApp {
     }
     async connect(callback) {
         const { engine } = this;
-        const { phone, method, autoclean = true, sync = true, reconnect = true } = this.#options;
+        const { phone, method, autoclean = true, sync = true, reconnect = true, device } = this.#options;
         const digits = phone !== undefined ? String(phone).replace(/\D+/g, '') : '';
         const budget = reconnect === false ? 0 : reconnect === true ? null : typeof reconnect === 'number' ? reconnect : reconnect.max ?? null;
         const wait = typeof reconnect === 'object' ? (reconnect.interval ?? 60) * 1_000 : 60_000;
@@ -110,7 +126,7 @@ class WhatsApp {
                             },
                         },
                     },
-                    browser: baileys_1.Browsers.windows('Chrome'),
+                    browser: baileys_1.Browsers.appropriate(device ?? 'Orchestrator'),
                     logger: (0, pino_1.default)({ level: 'silent' }),
                     syncFullHistory: sync,
                     shouldSyncHistoryMessage: ({ syncType }) => sync || syncType !== baileys_1.proto.HistorySync.HistorySyncType.FULL,
@@ -136,16 +152,29 @@ class WhatsApp {
                     if (!user)
                         return null;
                     const id = (0, baileys_1.jidNormalizedUser)(user.id);
+                    // La cuenta propia también se guarda por LID cuando el teléfono se anuncia
+                    // así, y entonces la ficha del JID viene vacía: se leen las dos y gana la
+                    // que tenga el dato.
+                    // The own account is stored by LID too when the phone announces itself that
+                    // way, and then the JID card comes back empty: both are read and whichever
+                    // holds the data wins.
                     const card = (0, store_1.deserialize)(await engine.get(`/contact/${id}`));
+                    const alias = user.lid ? (0, store_1.deserialize)(await engine.get(`/contact/${(0, baileys_1.jidNormalizedUser)(user.lid)}`)) : null;
                     return new contact_1.Account(init, {
                         id,
                         phone_number: id,
-                        lid: user.lid ?? card?.lid ?? null,
-                        name: user.name ?? card?.name ?? null,
-                        notify: card?.notify ?? null,
-                        verified_name: card?.verified_name ?? null,
-                        img_url: (await socket.profilePictureUrl(id, 'image').catch(() => null)) ?? card?.img_url ?? null,
-                        status: card?.status ?? null,
+                        lid: user.lid ?? card?.lid ?? alias?.lid ?? null,
+                        // `verified_name` es el nombre de una cuenta de empresa y `notify` el
+                        // que la propia línea difunde en sus mensajes: cualquiera de los dos es
+                        // el nombre real de la cuenta cuando el perfil no viajó en el login.
+                        // `verified_name` is a business account's name and `notify` the one the
+                        // line itself broadcasts in its messages: either is the account's real
+                        // name when the profile did not travel in the login.
+                        name: readable(user.name) ?? readable(card?.name) ?? readable(alias?.name) ?? card?.verified_name ?? alias?.verified_name ?? card?.notify ?? alias?.notify ?? null,
+                        notify: card?.notify ?? alias?.notify ?? null,
+                        verified_name: card?.verified_name ?? alias?.verified_name ?? null,
+                        img_url: (await socket.profilePictureUrl(id, 'image').catch(() => null)) ?? card?.img_url ?? alias?.img_url ?? null,
+                        status: card?.status ?? alias?.status ?? null,
                     });
                 };
                 const locate = async (cid, mid) => {
@@ -160,6 +189,89 @@ class WhatsApp {
                     }
                     return null;
                 };
+                /**
+                 * Identidad con la que se guarda a alguien. El mismo contacto llega unas veces
+                 * por teléfono y otras por LID, y tratar ambos como distintos le abre dos fichas
+                 * y dos chats. El teléfono manda; el LID sólo se conserva cuando aún no hay
+                 * forma de traducirlo.
+                 * The identity someone is stored under. The same contact arrives sometimes by
+                 * phone and sometimes by LID, and treating both as distinct opens two cards and
+                 * two chats for them. The phone wins; the LID is only kept while there is still
+                 * no way to translate it.
+                 */
+                const canonical = async (uid) => (uid.endsWith('@lid') ? await (0, store_1.jid_of)(engine, uid, socket).catch(() => null) : null) ?? uid;
+                /** Índice LID↔teléfono, sólo cuando traduce de verdad. / LID↔phone index, only when it actually translates. */
+                const remember = async (lid, jid) => {
+                    if (lid && !jid.endsWith('@lid')) {
+                        await engine.set(`/lid/${lid}`, (0, store_1.serialize)(jid));
+                        await engine.set(`/lid/${jid}`, (0, store_1.serialize)(lid));
+                    }
+                };
+                /**
+                 * Vuelca sobre el teléfono lo que se había guardado bajo el LID —ficha, chat y
+                 * mensajes— y borra el duplicado. Los campos ya presentes en el destino ganan:
+                 * son los que la cuenta viene usando.
+                 * Pours whatever was stored under the LID —card, chat and messages— onto the
+                 * phone and drops the duplicate. Fields already present on the target win: those
+                 * are the ones the account has been using.
+                 */
+                const absorb = async (lid, pn) => {
+                    const [from, to] = [(0, baileys_1.jidNormalizedUser)(lid), (0, baileys_1.jidNormalizedUser)(pn)];
+                    if (from !== to) {
+                        const stale = (0, store_1.deserialize)(await engine.get(`/contact/${from}`));
+                        if (stale) {
+                            const target = (0, store_1.deserialize)(await engine.get(`/contact/${to}`));
+                            await engine.set(`/contact/${to}`, (0, store_1.serialize)({ ...stale, ...target, id: to, lid: from }));
+                            await engine.unset(`/contact/${from}`);
+                        }
+                        const orphan = (0, store_1.deserialize)(await engine.get(`/chat/${from}`));
+                        if (orphan) {
+                            const target = (0, store_1.deserialize)(await engine.get(`/chat/${to}`));
+                            for (const raw of await engine.list(`/chat/${from}/message`, 0, 10_000)) {
+                                const msg = (0, store_1.deserialize)(raw);
+                                if (msg) {
+                                    await engine.set(`/chat/${to}/message/${msg.id}`, (0, store_1.serialize)({ ...msg, cid: to }), msg.created_at);
+                                    await engine.unset(`/chat/${from}/message/${msg.id}`);
+                                }
+                            }
+                            const doc = { ...orphan, ...target, id: to, activity: Math.max(orphan.activity ?? 0, target?.activity ?? 0) || null };
+                            await engine.set(`/chat/${to}`, (0, store_1.serialize)(doc), doc.activity ?? 0);
+                            await engine.unset(`/chat/${from}`);
+                            // Para quien escucha, el duplicado desaparece y el bueno aparece: es
+                            // literalmente lo que pasó, y deja la lista sin la fila fantasma.
+                            // To a listener the duplicate goes away and the good one shows up:
+                            // that is literally what happened, and it leaves the list without
+                            // the ghost row.
+                            this.emit('chat:deleted', new this.Chat(orphan), this);
+                            if (!target) {
+                                this.emit('chat:created', new this.Chat(doc), this);
+                            }
+                        }
+                    }
+                };
+                /**
+                 * Pasa por todo lo guardado bajo un LID y lo une a su teléfono. Cubre lo que se
+                 * escribió antes de que el mapeo existiera —o antes de que la librería supiera
+                 * unirlo—, que es lo que deja la lista con el mismo contacto dos veces: una con
+                 * su nombre y otra como un número largo sin sentido.
+                 * Walks everything stored under a LID and joins it to its phone. It covers what
+                 * was written before the mapping existed —or before the library knew how to join
+                 * it—, which is what leaves the same contact twice in the list: once with a name
+                 * and once as a long meaningless number.
+                 */
+                const reconcile = async () => {
+                    for (const path of ['/contact', '/chat']) {
+                        for (const raw of await engine.list(path, 0, 10_000)) {
+                            const id = (0, store_1.deserialize)(raw)?.id;
+                            if (id?.endsWith('@lid')) {
+                                const jid = await (0, store_1.jid_of)(engine, id, socket).catch(() => null);
+                                if (jid) {
+                                    await absorb(id, jid);
+                                }
+                            }
+                        }
+                    }
+                };
                 socket.ev.on('creds.update', () => engine.set('/session/creds', (0, store_1.serialize)(creds)));
                 socket.ev.on('connection.update', async ({ connection, lastDisconnect, qr }) => {
                     if (qr && !creds.registered) {
@@ -170,6 +282,13 @@ class WhatsApp {
                     if (connection === 'open') {
                         connected = true;
                         retries = 0;
+                        // Los mapeos que faltaban ya viajaron en el handshake: recién ahora se
+                        // puede unir lo que quedó partido en sesiones anteriores, cuando esos
+                        // LID todavía eran intraducibles.
+                        // The missing mappings already travelled in the handshake: only now can
+                        // whatever stayed split in earlier sessions be joined, back when those
+                        // LIDs were still untranslatable.
+                        chain = chain.then(reconcile).catch(() => { });
                         this.emit('connected', this);
                         resolve();
                     }
@@ -209,10 +328,11 @@ class WhatsApp {
                     chain = chain.then(async () => {
                         for (const row of rows) {
                             if (row.id) {
-                                const current = (0, store_1.deserialize)(await engine.get(`/contact/${row.id}`));
+                                const id = await canonical(row.id);
+                                const current = (0, store_1.deserialize)(await engine.get(`/contact/${id}`));
                                 const doc = {
-                                    id: row.id,
-                                    lid: row.lid ?? current?.lid ?? null,
+                                    id,
+                                    lid: row.lid ?? (row.id.endsWith('@lid') ? row.id : null) ?? current?.lid ?? null,
                                     name: row.name ?? current?.name ?? null,
                                     notify: row.notify ?? current?.notify ?? null,
                                     verified_name: row.verifiedName ?? current?.verified_name ?? null,
@@ -220,13 +340,11 @@ class WhatsApp {
                                     status: row.status ?? current?.status ?? null,
                                 };
                                 if (!current || JSON.stringify(current) !== JSON.stringify(doc)) {
-                                    await engine.set(`/contact/${row.id}`, (0, store_1.serialize)(doc));
-                                    if (doc.lid) {
-                                        await engine.set(`/lid/${doc.lid}`, (0, store_1.serialize)(doc.id));
-                                    }
+                                    await engine.set(`/contact/${id}`, (0, store_1.serialize)(doc));
+                                    await remember(doc.lid, id);
                                     const person = new this.Contact(doc);
-                                    const owner = (0, store_1.deserialize)(await engine.get(`/chat/${doc.id}`));
-                                    this.emit(current ? 'contact:updated' : 'contact:created', person, new this.Chat(owner ?? { id: doc.id, name: person.name }), this);
+                                    const owner = (0, store_1.deserialize)(await engine.get(`/chat/${id}`));
+                                    this.emit(current ? 'contact:updated' : 'contact:created', person, new this.Chat(owner ?? { id, name: person.name }), this);
                                 }
                             }
                         }
@@ -235,38 +353,44 @@ class WhatsApp {
                 socket.ev.on('contacts.update', (rows) => {
                     chain = chain.then(async () => {
                         for (const row of rows) {
-                            const current = row.id ? (0, store_1.deserialize)(await engine.get(`/contact/${row.id}`)) : null;
+                            const id = row.id ? await canonical(row.id) : '';
+                            const current = id ? (0, store_1.deserialize)(await engine.get(`/contact/${id}`)) : null;
                             const patch = {
                                 ...(row.notify && { notify: row.notify }),
                                 ...(row.name && { name: row.name }),
                                 ...(row.verifiedName && { verified_name: row.verifiedName }),
                                 ...(typeof row.imgUrl === 'string' && { img_url: row.imgUrl }),
                                 ...(row.status && { status: row.status }),
-                                ...(row.lid && { lid: row.lid }),
+                                ...((row.lid ?? (row.id?.endsWith('@lid') ? row.id : null)) && { lid: row.lid ?? row.id }),
                             };
-                            if (current && row.id && Object.keys(patch).length > 0) {
+                            if (current && Object.keys(patch).length > 0) {
                                 const doc = { ...current, ...patch };
-                                await engine.set(`/contact/${row.id}`, (0, store_1.serialize)(doc));
-                                if (patch.lid) {
-                                    await engine.set(`/lid/${patch.lid}`, (0, store_1.serialize)(row.id));
-                                }
+                                await engine.set(`/contact/${id}`, (0, store_1.serialize)(doc));
+                                await remember(patch.lid, id);
                                 const person = new this.Contact(doc);
-                                const owner = (0, store_1.deserialize)(await engine.get(`/chat/${row.id}`));
-                                this.emit('contact:updated', person, new this.Chat(owner ?? { id: row.id, name: person.name }), this);
+                                const owner = (0, store_1.deserialize)(await engine.get(`/chat/${id}`));
+                                this.emit('contact:updated', person, new this.Chat(owner ?? { id, name: person.name }), this);
                             }
                         }
                     }).catch(() => { });
                 });
                 socket.ev.on('lid-mapping.update', ({ lid, pn }) => {
                     chain = chain.then(async () => {
-                        await engine.set(`/lid/${lid}`, (0, store_1.serialize)(pn));
-                        await engine.set(`/lid/${pn}`, (0, store_1.serialize)(lid));
+                        await remember(lid, pn);
+                        // El mapeo recién llega: lo que se guardó bajo el LID mientras era
+                        // irresoluble se une ahora a su teléfono, o el contacto queda partido
+                        // en dos fichas y dos chats que nunca se vuelven a encontrar.
+                        // The mapping just arrived: whatever was stored under the LID while it
+                        // was unresolvable now joins its phone, or the contact stays split into
+                        // two cards and two chats that never meet again.
+                        await absorb(lid, pn);
                     }).catch(() => { });
                 });
                 socket.ev.on('chats.upsert', (rows) => {
                     chain = chain.then(async () => {
-                        for (const row of rows) {
-                            if (row.id) {
+                        for (const raw of rows) {
+                            if (raw.id) {
+                                const row = { ...raw, id: await canonical(raw.id) };
                                 const current = (0, store_1.deserialize)(await engine.get(`/chat/${row.id}`));
                                 const doc = current ?? {
                                     id: row.id,
@@ -437,7 +561,13 @@ class WhatsApp {
                             }
                             if (kind === 'protocolMessage') {
                                 const protocol = msg.message?.protocolMessage;
-                                const found = protocol?.key?.id ? await locate(protocol.key.remoteJid ?? cid, protocol.key.id) : null;
+                                // El aviso puede venir direccionado por LID y el documento estar bajo el JID
+                                // (o al revés): se busca por el chat que nombra el protocolo y por el del sobre.
+                                // The notice may be LID-addressed while the document lives under the JID (or the
+                                // other way around): it is looked up by the protocol's chat and by the envelope's.
+                                const found = protocol?.key?.id
+                                    ? (await locate(protocol.key.remoteJid ?? cid, protocol.key.id)) ?? (await locate(cid, protocol.key.id))
+                                    : null;
                                 if (found && protocol?.type === baileys_1.proto.Message.ProtocolMessage.Type.MESSAGE_EDIT && protocol.editedMessage) {
                                     found.doc.raw.message = protocol.editedMessage;
                                     found.doc.edited = true;
@@ -447,7 +577,12 @@ class WhatsApp {
                                     this.emit('message:updated', instance, await instance.chat(), this);
                                 }
                                 else if (found && protocol?.type === baileys_1.proto.Message.ProtocolMessage.Type.REVOKE) {
-                                    await engine.unset(found.path);
+                                    // El mensaje retirado no se borra: se marca, y así la interfaz puede
+                                    // mostrar «se eliminó este mensaje» donde estaba en vez de un hueco.
+                                    // A revoked message is not removed: it gets flagged, so the interface can
+                                    // show "this message was deleted" in its place instead of a gap.
+                                    found.doc.revoked_at = Date.now();
+                                    await engine.set(found.path, (0, store_1.serialize)(found.doc), found.doc.created_at);
                                     const instance = new message_1.default(init, found.doc);
                                     this.emit('message:deleted', instance, await instance.chat(), this);
                                 }
@@ -458,24 +593,40 @@ class WhatsApp {
                             if (stored) {
                                 doc.multiple = typeof stored.multiple === 'boolean' ? stored.multiple : doc.multiple;
                                 doc.reactions = stored.reactions ?? doc.reactions;
+                                doc.revoked_at = stored.revoked_at ?? doc.revoked_at;
                                 const advanced = doc.status > stored.status;
                                 doc.status = Math.max(stored.status, doc.status);
                                 if (!advanced && stored.caption === doc.caption && stored.edited === doc.edited && stored.starred === doc.starred) {
                                     continue;
                                 }
                             }
+                            if (!stored && doc.me && msg.pushName && socket.user) {
+                                // Un mensaje propio lleva el nombre con el que la cuenta se
+                                // anuncia al mundo. Cuando el perfil no viajó en el login —una
+                                // reconexión, por ejemplo— esta es la única vía para conocerlo,
+                                // y sin ella la línea se ve a sí misma como un número.
+                                // An own message carries the name the account announces itself
+                                // with. When the profile did not travel in the login —a
+                                // reconnection, say— this is the only way to learn it, and
+                                // without it the line sees itself as a number.
+                                const own = (0, baileys_1.jidNormalizedUser)(socket.user.id);
+                                const known = (0, store_1.deserialize)(await engine.get(`/contact/${own}`));
+                                if (!(known?.name ?? known?.notify ?? known?.verified_name)) {
+                                    socket.ev.emit('contacts.upsert', [{ id: own, lid: socket.user.lid, notify: readable(msg.pushName) ?? undefined }]);
+                                }
+                            }
                             if (!stored && !doc.me) {
                                 const known = (0, store_1.deserialize)(await engine.get(`/contact/${doc.author}`));
                                 if (doc.author && !(known?.name ?? known?.notify ?? known?.verified_name)) {
                                     socket.ev.emit('contacts.upsert', [{
                                             id: doc.author,
                                             lid: msg.key.remoteJid?.endsWith('@lid') ? msg.key.remoteJid : undefined,
-                                            notify: msg.pushName ?? undefined,
+                                            notify: readable(msg.pushName) ?? undefined,
                                             verifiedName: msg.verifiedBizName ?? undefined,
                                         }]);
                                 }
                                 if (!(await engine.get(`/chat/${cid}`))) {
-                                    const owner = { id: cid, name: cid.endsWith('@g.us') ? null : msg.pushName ?? null, activity: doc.created_at };
+                                    const owner = { id: cid, name: cid.endsWith('@g.us') ? null : readable(msg.pushName), activity: doc.created_at };
                                     await engine.set(`/chat/${cid}`, (0, store_1.serialize)(owner), doc.created_at);
                                     this.emit('chat:created', new this.Chat(owner), this);
                                 }
@@ -585,6 +736,34 @@ class WhatsApp {
                     }).catch(() => { });
                 });
             };
+            this.#unlink = async (quiet) => {
+                intentional = true;
+                silent = quiet;
+                if (timer) {
+                    clearTimeout(timer);
+                    timer = null;
+                }
+                try {
+                    // `logout` avisa al teléfono y termina el socket; la promesa no resuelve
+                    // hasta que el teléfono acusa, que es cuando el dispositivo ya no existe.
+                    // `logout` notifies the phone and ends the socket; the promise does not
+                    // settle until the phone acknowledges, which is when the device is gone.
+                    await alive?.logout();
+                }
+                catch {
+                    // Sin red o con el socket ya muerto no hay a quién avisar: se cierra de
+                    // este lado para no dejar el proceso colgado de una sesión que no existe.
+                    // With no network or an already dead socket there is nobody to notify: it
+                    // closes on this side so the process is not left hanging on a dead session.
+                    try {
+                        alive?.end(Object.assign(new Error('intentional close'), { output: { statusCode: baileys_1.DisconnectReason.connectionClosed } }));
+                    }
+                    catch {
+                        /* el socket ya estaba cerrado / socket already closed */
+                    }
+                }
+                alive = null;
+            };
             this.#close = async (quiet) => {
                 intentional = true;
                 silent = quiet;
@@ -604,16 +783,34 @@ class WhatsApp {
         });
     }
     /**
-     * Cierra la sesión: cancela el reintento pendiente y termina el socket.
-     * Closes the session: cancels the pending retry and ends the socket.
+     * Cierra la sesión de verdad: desvincula el dispositivo del teléfono y termina el socket.
+     * La promesa no resuelve hasta que todo eso ocurrió.
+     *
+     * Los dos flags modulan efectos secundarios, nunca si la sesión muere: `silent` sólo calla
+     * el evento `disconnected` local, y `destroy` decide si el engine se vacía o conserva
+     * chats, mensajes y contactos para estudiarlos después. Las credenciales se borran en los
+     * dos casos: el dispositivo ya no existe, así que reconectar con ellas sólo devolvería un
+     * `loggedOut`.
+     *
+     * Closes the session for real: unlinks the device from the phone and ends the socket. The
+     * promise does not settle until all of that happened.
+     *
+     * Both flags modulate side effects, never whether the session dies: `silent` only mutes the
+     * local `disconnected` event, and `destroy` decides whether the engine is wiped or keeps
+     * chats, messages and contacts for later study. Credentials go in both cases: the device no
+     * longer exists, so reconnecting with them would only return a `loggedOut`.
+     *
+     * @param options - `silent` calla el evento; `destroy` vacía el engine entero / `silent` mutes the event; `destroy` wipes the whole engine
      *
-     * @param options - `silent` calla el evento `disconnected`; `destroy` vacía el engine / `silent` mutes the `disconnected` event; `destroy` clears the engine
+     * @example
+     * await wa.disconnect();                     // desvincula y conserva el historial
+     * await wa.disconnect({ destroy: true });    // desvincula y no queda nada
      */
     async disconnect(options = {}) {
-        await this.#close?.(options.silent === true);
-        if (options.destroy) {
-            await this.engine.clear();
-        }
+        await this.#unlink?.(options.silent === true);
+        this.#unlink = null;
+        this.#close = null;
+        await (options.destroy ? this.engine.clear() : this.engine.unset('/session'));
     }
 }
 exports.default = WhatsApp;

package/build/esm/lib/message/index.d.ts

@@ -54,6 +54,8 @@ export default class Message {
         mime: string;
         caption: string;
         edited: boolean;
+        /** Momento en que se retiró para todos, o null si sigue vigente / When it was revoked for everyone, or null while it stands */
+        revoked_at?: number | null;
         multiple?: boolean;
         reactions?: {
             author: string;
@@ -96,6 +98,15 @@ export default class Message {
     get forwarded(): boolean;
     /** true si fue editado. / true when edited. */
     get edited(): boolean;
+    /**
+     * true si se retiró para todos. El documento no se borra: el mensaje sigue en su sitio
+     * para que la interfaz muestre «se eliminó este mensaje» en vez de un hueco.
+     * true when revoked for everyone. The document is not removed: the message stays in place
+     * so the interface can show "this message was deleted" instead of a gap.
+     */
+    get revoked(): boolean;
+    /** Fecha del retiro en ISO UTC, o null. / Revocation date as ISO UTC, or null. */
+    get revoked_at(): string | null;
     /** Fecha de creación en ISO UTC. / Creation date as ISO UTC. */
     get created_at(): string;
     /** Vencimiento del mensaje temporal en ISO UTC, o null. / Ephemeral expiration as ISO UTC, or null. */
@@ -106,7 +117,13 @@ export default class Message {
     get reason(): string | null;
     /** Nombre del negocio verificado que firma el mensaje, o null. / Verified business name signing the message, or null. */
     get business(): string | null;
-    /** true si es de una sola lectura (view-once). / true when view-once. */
+    /**
+     * true si es de una sola lectura (view-once). La marca vive en tres sitios según quién
+     * lo envió: la llave del sobre, el propio nodo del media (forma actual) o el wrapper
+     * heredado.
+     * true when view-once. The flag lives in three places depending on the sender: the key,
+     * the media node itself (current form) or the legacy wrapper.
+     */
     get once(): boolean;
     /** Contacto autor, desde el engine (ficha mínima si no está persistido). / Author contact, from the engine (minimal card when not persisted). */
     author(): Promise<InstanceType<WhatsApp['Contact']>>;
@@ -403,6 +420,8 @@ export declare function message(init: Init): {
             mime: string;
             caption: string;
             edited: boolean;
+            /** Momento en que se retiró para todos, o null si sigue vigente / When it was revoked for everyone, or null while it stands */
+            revoked_at?: number | null;
             multiple?: boolean;
             reactions?: {
                 author: string;
@@ -436,6 +455,15 @@ export declare function message(init: Init): {
         get forwarded(): boolean;
         /** true si fue editado. / true when edited. */
         get edited(): boolean;
+        /**
+         * true si se retiró para todos. El documento no se borra: el mensaje sigue en su sitio
+         * para que la interfaz muestre «se eliminó este mensaje» en vez de un hueco.
+         * true when revoked for everyone. The document is not removed: the message stays in place
+         * so the interface can show "this message was deleted" instead of a gap.
+         */
+        get revoked(): boolean;
+        /** Fecha del retiro en ISO UTC, o null. / Revocation date as ISO UTC, or null. */
+        get revoked_at(): string | null;
         /** Fecha de creación en ISO UTC. / Creation date as ISO UTC. */
         get created_at(): string;
         /** Vencimiento del mensaje temporal en ISO UTC, o null. / Ephemeral expiration as ISO UTC, or null. */
@@ -446,7 +474,13 @@ export declare function message(init: Init): {
         get reason(): string | null;
         /** Nombre del negocio verificado que firma el mensaje, o null. / Verified business name signing the message, or null. */
         get business(): string | null;
-        /** true si es de una sola lectura (view-once). / true when view-once. */
+        /**
+         * true si es de una sola lectura (view-once). La marca vive en tres sitios según quién
+         * lo envió: la llave del sobre, el propio nodo del media (forma actual) o el wrapper
+         * heredado.
+         * true when view-once. The flag lives in three places depending on the sender: the key,
+         * the media node itself (current form) or the legacy wrapper.
+         */
         get once(): boolean;
         /** Contacto autor, desde el engine (ficha mínima si no está persistido). / Author contact, from the engine (minimal card when not persisted). */
         author(): Promise<InstanceType<WhatsApp["Contact"]>>;

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

@@ -5,7 +5,7 @@
  * 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 { aesEncryptGCM, downloadMediaMessage, generateForwardMessageContent, generateMessageID, generateWAMessage, generateWAMessageFromContent, getAggregateVotesInPollMessage, getContentType, getKeyAuthor, hmacSign, jidNormalizedUser, proto, sha256, updateMessageWithPollUpdate, } from 'baileys';
 import { randomBytes } from 'node:crypto';
 import { Readable } from 'node:stream';
 import Chat from '../../lib/chat/index.js';
@@ -16,6 +16,40 @@ const STATUS = ['error', 'pending', 'sent', 'delivered', 'read', 'played'];
 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;
+/**
+ * Envío de vista única con el proto que WhatsApp entrega: se genera el contenido normal (media
+ * plano, sin wrapper), se marca `viewOnce` en el propio nodo del media y `isViewOnce` en la
+ * llave, y se transmite tal cual.
+ * View-once send with the proto WhatsApp actually delivers: the regular content is generated
+ * (flat media, no wrapper), `viewOnce` is flagged on the media node itself and `isViewOnce` on
+ * the key, and it is relayed as is.
+ *
+ * @param init - Sesión activa / Active session
+ * @param jid - Destino resuelto / Resolved target
+ * @param content - Contenido proto / Proto content
+ * @param quoted - Mensaje citado / Quoted message
+ * @returns Mensaje transmitido / Relayed message
+ */
+const once_of = async (init, jid, content, quoted) => {
+    const full = await generateWAMessage(jid, content, {
+        logger: init.socket.logger,
+        userJid: init.socket.user.id,
+        upload: init.socket.waUploadToServer,
+        ...(quoted && { quoted }),
+    });
+    // El media queda al nivel superior; sólo hay que marcarlo. / The media stays top level; it only needs flagging.
+    for (const node of Object.values(full.message ?? {}))
+        if (node && typeof node === 'object' && 'mimetype' in node)
+            node.viewOnce = true;
+    full.key.isViewOnce = true;
+    await init.socket.relayMessage(jid, full.message, { messageId: full.key.id });
+    // El relay no publica el mensaje: se emite el upsert que `sendMessage` haría, para que el
+    // resto de la sesión (eventos, cachés de los consumidores) lo vea como cualquier envío.
+    // The relay does not publish the message: the upsert `sendMessage` would emit is fired, so
+    // the rest of the session (events, consumer caches) sees it like any other send.
+    init.socket.ev.emit('messages.upsert', { messages: [full], type: 'append' });
+    return full;
+};
 /**
  * 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
@@ -29,7 +63,17 @@ const send = async (init, cid, content, binary, extra = {}, overrides) => {
     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 }) });
+    // La vista única viaja como la manda WhatsApp: el media PLANO con `viewOnce` en su propio
+    // nodo y el sobre marcado con `isViewOnce`, sin envolverlo en `viewOnceMessage(V2)` —el
+    // wrapper que arma baileys con `viewOnce: true` queda en «enviado» y no se entrega.
+    // Comprobado contra el proto de un view-once entrante real.
+    // View-once travels the way WhatsApp sends it: the media FLAT with `viewOnce` on its own
+    // node and the key flagged `isViewOnce`, never wrapped in `viewOnceMessage(V2)` —the
+    // wrapper baileys builds from `viewOnce: true` stalls at "sent" and is never delivered.
+    // Checked against the proto of a real incoming view-once.
+    const raw = extra.once
+        ? await once_of(init, jid, content, quoted)
+        : await init.socket.sendMessage(jid, content, { ...(quoted && { quoted }) });
     if (!raw?.key?.id)
         return null;
     const sent = new Message(init, raw);
@@ -147,6 +191,15 @@ export default class Message {
     get forwarded() { return this._raw.forwarded; }
     /** true si fue editado. / true when edited. */
     get edited() { return this._raw.edited; }
+    /**
+     * true si se retiró para todos. El documento no se borra: el mensaje sigue en su sitio
+     * para que la interfaz muestre «se eliminó este mensaje» en vez de un hueco.
+     * true when revoked for everyone. The document is not removed: the message stays in place
+     * so the interface can show "this message was deleted" instead of a gap.
+     */
+    get revoked() { return this._raw.revoked_at != null; }
+    /** Fecha del retiro en ISO UTC, o null. / Revocation date as ISO UTC, or null. */
+    get revoked_at() { return this._raw.revoked_at != null ? new Date(this._raw.revoked_at).toISOString() : null; }
     /** 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. */
@@ -165,10 +218,18 @@ export default class Message {
     }
     /** 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 es de una sola lectura (view-once). / true when view-once. */
+    /**
+     * true si es de una sola lectura (view-once). La marca vive en tres sitios según quién
+     * lo envió: la llave del sobre, el propio nodo del media (forma actual) o el wrapper
+     * heredado.
+     * true when view-once. The flag lives in three places depending on the sender: the key,
+     * the media node itself (current form) or the legacy wrapper.
+     */
     get once() {
         const msg = this._raw.raw.message;
-        return Boolean(msg?.viewOnceMessage ?? msg?.viewOnceMessageV2 ?? msg?.viewOnceMessageV2Extension);
+        const body = msg ? unwrap(msg) : {};
+        const media = body[getContentType(body)];
+        return Boolean(this._raw.raw.key?.isViewOnce ?? media?.viewOnce ?? msg?.viewOnceMessage ?? msg?.viewOnceMessageV2 ?? msg?.viewOnceMessageV2Extension);
     }
     /** Contacto autor, desde el engine (ficha mínima si no está persistido). / Author contact, from the engine (minimal card when not persisted). */
     async author() {
@@ -299,11 +360,19 @@ export default class Message {
      */
     async delete(all = false) {
         const doc = this._raw;
-        if (all)
+        // Retirar para todos deja el mensaje en su sitio, marcado; borrarlo solo para uno lo
+        // saca del historial local, que es lo que significa cada acción en WhatsApp.
+        // Revoking for everyone leaves the message in place, flagged; deleting it just for
+        // oneself drops it from the local history, which is what each action means on WhatsApp.
+        if (all) {
             await this._init.socket.sendMessage(doc.cid, { delete: { remoteJid: doc.cid, id: doc.id, fromMe: doc.me } });
-        else
+            doc.revoked_at = Date.now();
+            await this._init.engine.set(`/chat/${doc.cid}/message/${doc.id}`, serialize(doc), doc.created_at);
+        }
+        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}`);
+            await this._init.engine.unset(`/chat/${doc.cid}/message/${doc.id}`);
+        }
         return true;
     }
     /** Responde con texto. / Replies with text. */