@arcaelas/whatsapp 7.4.2 → 8.2.0

package/build/cjs/index.d.ts

@@ -7,7 +7,7 @@ import WhatsApp from './lib/whatsapp';
 export { WhatsApp };
 export default WhatsApp;
 export type IWhatsApp = ConstructorParameters<typeof WhatsApp>[0];
-export type { Farewell } from './lib/whatsapp';
+export type { ChatWatch, ContactWatch, Farewell, MessageWatch, Presence, WatchEvent } from './lib/whatsapp';
 export type DisconnectOptions = NonNullable<Parameters<WhatsApp['disconnect']>[0]>;
 export type ReconnectOption = NonNullable<IWhatsApp['reconnect']>;
 export { FileSystemEngine, RedisEngine, S3Engine, SQLiteEngine, serialize, deserialize } from './lib/store';

package/build/cjs/lib/chat/index.d.ts

@@ -4,10 +4,10 @@
  * Chat entity — individual and group conversations.
  */
 import type { WASocket } from 'baileys';
-import type Contact from '../../lib/contact';
 import type Message from '../../lib/message';
 import { type Engine } from '../../lib/store';
 import type WhatsApp from '../../lib/whatsapp';
+import type { ChatWatch, WatchEvent } from '../../lib/whatsapp';
 /**
  * Chat: recibe el raw y deriva todo con getters.
  * Chat: receives the raw and derives everything via getters.
@@ -86,7 +86,7 @@ export declare function chat(init: {
          * @param limit - Tamaño de página / Page size
          * @returns Página de contactos / Contact page
          */
-        members(offset?: number, limit?: number): Promise<Contact[]>;
+        members(offset?: number, limit?: number): Promise<InstanceType<typeof init.wa.Contact>[]>;
         /**
          * Descripción: el asunto del grupo o, en un 1:1, la bio del contacto. Es asíncrono
          * porque ninguna de las dos vive en el documento del chat.
@@ -147,6 +147,23 @@ export declare function chat(init: {
          * Marca el chat completo como leído en la cuenta.
          * Marks the whole chat as read on the account.
          */
+        /**
+         * Supervisa la conversación entera: lo que hace la persona al otro lado —entra, sale,
+         * escribe, graba, deja de escribir, deja de grabar— y los mensajes que van llegando.
+         *
+         * No reimplementa nada: monta el `watch` del contacto dueño del chat y le suma los
+         * mensajes nuevos. En un grupo no hay una sola persona a la que seguir, así que sólo
+         * quedan los mensajes.
+         * Watches the whole conversation: what the person on the other end does —comes in, leaves,
+         * types, records, stops typing, stops recording— and the messages arriving.
+         *
+         * It reimplements nothing: it sets up the watch of the chat's owning contact and adds new
+         * messages to it. In a group there is no single person to follow, so only messages remain.
+         *
+         * @param handler - Recibe cada acción y cada mensaje / Receives every action and every message
+         * @returns Función para dejar de supervisar / Function to stop watching
+         */
+        watch(handler: (event: WatchEvent<ChatWatch, InstanceType<typeof init.wa.Contact> | Message>) => void): Promise<() => void>;
         seen(): Promise<boolean>;
         /**
          * Vacía los mensajes del chat en la cuenta y en el engine, conservando el chat.
@@ -203,7 +220,7 @@ export declare function chat(init: {
          * @param limit - Tamaño de página / Page size
          * @returns Página de contactos / Contact page
          */
-        members(offset?: number, limit?: number): Promise<Contact[]>;
+        members(offset?: number, limit?: number): Promise<InstanceType<typeof init.wa.Contact>[]>;
         /**
          * Descripción: el asunto del grupo o, en un 1:1, la bio del contacto. Es asíncrono
          * porque ninguna de las dos vive en el documento del chat.
@@ -264,6 +281,23 @@ export declare function chat(init: {
          * Marca el chat completo como leído en la cuenta.
          * Marks the whole chat as read on the account.
          */
+        /**
+         * Supervisa la conversación entera: lo que hace la persona al otro lado —entra, sale,
+         * escribe, graba, deja de escribir, deja de grabar— y los mensajes que van llegando.
+         *
+         * No reimplementa nada: monta el `watch` del contacto dueño del chat y le suma los
+         * mensajes nuevos. En un grupo no hay una sola persona a la que seguir, así que sólo
+         * quedan los mensajes.
+         * Watches the whole conversation: what the person on the other end does —comes in, leaves,
+         * types, records, stops typing, stops recording— and the messages arriving.
+         *
+         * It reimplements nothing: it sets up the watch of the chat's owning contact and adds new
+         * messages to it. In a group there is no single person to follow, so only messages remain.
+         *
+         * @param handler - Recibe cada acción y cada mensaje / Receives every action and every message
+         * @returns Función para dejar de supervisar / Function to stop watching
+         */
+        watch(handler: (event: WatchEvent<ChatWatch, InstanceType<typeof init.wa.Contact> | Message>) => void): Promise<() => void>;
         seen(): Promise<boolean>;
         /**
          * Vacía los mensajes del chat en la cuenta y en el engine, conservando el chat.
@@ -319,7 +353,7 @@ export declare function chat(init: {
          * @param limit - Tamaño de página / Page size
          * @returns Página de contactos / Contact page
          */
-        members(offset?: number, limit?: number): Promise<Contact[]>;
+        members(offset?: number, limit?: number): Promise<InstanceType<typeof init.wa.Contact>[]>;
         /**
          * Descripción: el asunto del grupo o, en un 1:1, la bio del contacto. Es asíncrono
          * porque ninguna de las dos vive en el documento del chat.
@@ -380,6 +414,23 @@ export declare function chat(init: {
          * Marca el chat completo como leído en la cuenta.
          * Marks the whole chat as read on the account.
          */
+        /**
+         * Supervisa la conversación entera: lo que hace la persona al otro lado —entra, sale,
+         * escribe, graba, deja de escribir, deja de grabar— y los mensajes que van llegando.
+         *
+         * No reimplementa nada: monta el `watch` del contacto dueño del chat y le suma los
+         * mensajes nuevos. En un grupo no hay una sola persona a la que seguir, así que sólo
+         * quedan los mensajes.
+         * Watches the whole conversation: what the person on the other end does —comes in, leaves,
+         * types, records, stops typing, stops recording— and the messages arriving.
+         *
+         * It reimplements nothing: it sets up the watch of the chat's owning contact and adds new
+         * messages to it. In a group there is no single person to follow, so only messages remain.
+         *
+         * @param handler - Recibe cada acción y cada mensaje / Receives every action and every message
+         * @returns Función para dejar de supervisar / Function to stop watching
+         */
+        watch(handler: (event: WatchEvent<ChatWatch, InstanceType<typeof init.wa.Contact> | Message>) => void): Promise<() => void>;
         seen(): Promise<boolean>;
         /**
          * Vacía los mensajes del chat en la cuenta y en el engine, conservando el chat.

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

@@ -213,6 +213,37 @@ function chat(init) {
          * Marca el chat completo como leído en la cuenta.
          * Marks the whole chat as read on the account.
          */
+        /**
+         * Supervisa la conversación entera: lo que hace la persona al otro lado —entra, sale,
+         * escribe, graba, deja de escribir, deja de grabar— y los mensajes que van llegando.
+         *
+         * No reimplementa nada: monta el `watch` del contacto dueño del chat y le suma los
+         * mensajes nuevos. En un grupo no hay una sola persona a la que seguir, así que sólo
+         * quedan los mensajes.
+         * Watches the whole conversation: what the person on the other end does —comes in, leaves,
+         * types, records, stops typing, stops recording— and the messages arriving.
+         *
+         * It reimplements nothing: it sets up the watch of the chat's owning contact and adds new
+         * messages to it. In a group there is no single person to follow, so only messages remain.
+         *
+         * @param handler - Recibe cada acción y cada mensaje / Receives every action and every message
+         * @returns Función para dejar de supervisar / Function to stop watching
+         */
+        async watch(handler) {
+            const off_message = init.wa.on('message:created', (msg) => {
+                if (msg.cid === this._raw.id)
+                    handler({ name: 'message', payload: msg });
+            });
+            if (this.type === 'group') {
+                return off_message;
+            }
+            const who = await init.wa.Contact.get(this._raw.id);
+            const off_presence = (await who?.watch((event) => handler(event))) ?? (() => { });
+            return () => {
+                off_message();
+                off_presence();
+            };
+        }
         async seen() {
             const last = await tail(this._raw.id);
             // Marcar leído se acusa con recibos, no con una mutación del estado de la app.

package/build/cjs/lib/contact/index.d.ts

@@ -7,6 +7,7 @@ import { type WASocket } from 'baileys';
 import { Feed } from '../../lib/status';
 import { type Engine } from '../../lib/store';
 import type WhatsApp from '../../lib/whatsapp';
+import type { ContactWatch, WatchEvent } from '../../lib/whatsapp';
 /** Sesión activa que liga la entidad. / Active session binding the entity. */
 type Init = {
     wa: WhatsApp;
@@ -75,6 +76,13 @@ export declare function contact(init: Init): {
         img_url?: string | null;
         status?: string | null;
     }): {
+        /**
+         * true cuando este contacto es la propia cuenta. La comparación cubre JID y LID porque
+         * la cuenta se anuncia por cualquiera de los dos según el chat.
+         * true when this contact is the account itself. The comparison covers JID and LID
+         * because the account announces itself through either depending on the chat.
+         */
+        get me(): boolean;
         /**
          * Chat 1:1 del contacto: el persistido, o una instancia mínima.
          * The contact's 1:1 chat: the persisted one, or a minimal instance.
@@ -82,6 +90,24 @@ export declare function contact(init: Init): {
          * @returns Instancia de Chat / Chat instance
          */
         chat(): Promise<InstanceType<typeof init.wa.Chat>>;
+        /**
+         * Supervisa lo que hace el contacto: entra, sale, escribe, graba, deja de escribir o deja
+         * de grabar. Un aviso por acción, ya filtrado a esta persona.
+         *
+         * WhatsApp no difunde presencia por su cuenta —hay que pedirla contacto por contacto— y
+         * deja de mandarla al reconectar, así que la supervisión se vuelve a montar en cada
+         * sesión nueva.
+         * Watches what the contact does: comes in, leaves, types, records, stops typing or stops
+         * recording. One notice per action, already filtered down to this person.
+         *
+         * WhatsApp does not broadcast presence on its own —it must be asked for contact by
+         * contact— and stops sending it on reconnect, so the watch is set up again on every new
+         * session.
+         *
+         * @param handler - Recibe cada acción / Receives every action
+         * @returns Función para dejar de supervisar / Function to stop watching
+         */
+        watch(handler: (event: WatchEvent<ContactWatch, /*elided*/ any>) => void): Promise<() => void>;
         readonly _raw: {
             id: string;
             lid?: string | null;
@@ -113,6 +139,13 @@ export declare function contact(init: Init): {
      * @returns Contacto, o null si no existe en WhatsApp / Contact, or null when not on WhatsApp
      */
     get(uid: string | number): Promise<{
+        /**
+         * true cuando este contacto es la propia cuenta. La comparación cubre JID y LID porque
+         * la cuenta se anuncia por cualquiera de los dos según el chat.
+         * true when this contact is the account itself. The comparison covers JID and LID
+         * because the account announces itself through either depending on the chat.
+         */
+        get me(): boolean;
         /**
          * Chat 1:1 del contacto: el persistido, o una instancia mínima.
          * The contact's 1:1 chat: the persisted one, or a minimal instance.
@@ -120,6 +153,24 @@ export declare function contact(init: Init): {
          * @returns Instancia de Chat / Chat instance
          */
         chat(): Promise<InstanceType<typeof init.wa.Chat>>;
+        /**
+         * Supervisa lo que hace el contacto: entra, sale, escribe, graba, deja de escribir o deja
+         * de grabar. Un aviso por acción, ya filtrado a esta persona.
+         *
+         * WhatsApp no difunde presencia por su cuenta —hay que pedirla contacto por contacto— y
+         * deja de mandarla al reconectar, así que la supervisión se vuelve a montar en cada
+         * sesión nueva.
+         * Watches what the contact does: comes in, leaves, types, records, stops typing or stops
+         * recording. One notice per action, already filtered down to this person.
+         *
+         * WhatsApp does not broadcast presence on its own —it must be asked for contact by
+         * contact— and stops sending it on reconnect, so the watch is set up again on every new
+         * session.
+         *
+         * @param handler - Recibe cada acción / Receives every action
+         * @returns Función para dejar de supervisar / Function to stop watching
+         */
+        watch(handler: (event: WatchEvent<ContactWatch, /*elided*/ any>) => void): Promise<() => void>;
         readonly _raw: {
             id: string;
             lid?: string | null;
@@ -150,6 +201,13 @@ export declare function contact(init: Init): {
      * @returns Página de contactos / Contact page
      */
     list(offset?: number, limit?: number): Promise<{
+        /**
+         * true cuando este contacto es la propia cuenta. La comparación cubre JID y LID porque
+         * la cuenta se anuncia por cualquiera de los dos según el chat.
+         * true when this contact is the account itself. The comparison covers JID and LID
+         * because the account announces itself through either depending on the chat.
+         */
+        get me(): boolean;
         /**
          * Chat 1:1 del contacto: el persistido, o una instancia mínima.
          * The contact's 1:1 chat: the persisted one, or a minimal instance.
@@ -157,6 +215,24 @@ export declare function contact(init: Init): {
          * @returns Instancia de Chat / Chat instance
          */
         chat(): Promise<InstanceType<typeof init.wa.Chat>>;
+        /**
+         * Supervisa lo que hace el contacto: entra, sale, escribe, graba, deja de escribir o deja
+         * de grabar. Un aviso por acción, ya filtrado a esta persona.
+         *
+         * WhatsApp no difunde presencia por su cuenta —hay que pedirla contacto por contacto— y
+         * deja de mandarla al reconectar, así que la supervisión se vuelve a montar en cada
+         * sesión nueva.
+         * Watches what the contact does: comes in, leaves, types, records, stops typing or stops
+         * recording. One notice per action, already filtered down to this person.
+         *
+         * WhatsApp does not broadcast presence on its own —it must be asked for contact by
+         * contact— and stops sending it on reconnect, so the watch is set up again on every new
+         * session.
+         *
+         * @param handler - Recibe cada acción / Receives every action
+         * @returns Función para dejar de supervisar / Function to stop watching
+         */
+        watch(handler: (event: WatchEvent<ContactWatch, /*elided*/ any>) => void): Promise<() => void>;
         readonly _raw: {
             id: string;
             lid?: string | null;

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

@@ -58,6 +58,17 @@ exports.default = Contact;
  */
 function contact(init) {
     class _Contact extends Contact {
+        /**
+         * true cuando este contacto es la propia cuenta. La comparación cubre JID y LID porque
+         * la cuenta se anuncia por cualquiera de los dos según el chat.
+         * true when this contact is the account itself. The comparison covers JID and LID
+         * because the account announces itself through either depending on the chat.
+         */
+        get me() {
+            const user = init.socket.user;
+            const mine = [user?.id, user?.lid].filter((id) => Boolean(id)).map((id) => (id.split(':')[0] ?? '').split('@')[0]);
+            return [this.jid, this.lid, this._raw.id].some((id) => id && mine.includes((id.split('@')[0] ?? '')));
+        }
         /**
          * Chat 1:1 del contacto: el persistido, o una instancia mínima.
          * The contact's 1:1 chat: the persisted one, or a minimal instance.
@@ -68,6 +79,37 @@ function contact(init) {
             const cid = this.jid ?? this.lid ?? this._raw.id;
             return new init.wa.Chat((0, store_1.deserialize)(await init.engine.get(`/chat/${cid}`)) ?? { id: cid, name: this.name });
         }
+        /**
+         * Supervisa lo que hace el contacto: entra, sale, escribe, graba, deja de escribir o deja
+         * de grabar. Un aviso por acción, ya filtrado a esta persona.
+         *
+         * WhatsApp no difunde presencia por su cuenta —hay que pedirla contacto por contacto— y
+         * deja de mandarla al reconectar, así que la supervisión se vuelve a montar en cada
+         * sesión nueva.
+         * Watches what the contact does: comes in, leaves, types, records, stops typing or stops
+         * recording. One notice per action, already filtered down to this person.
+         *
+         * WhatsApp does not broadcast presence on its own —it must be asked for contact by
+         * contact— and stops sending it on reconnect, so the watch is set up again on every new
+         * session.
+         *
+         * @param handler - Recibe cada acción / Receives every action
+         * @returns Función para dejar de supervisar / Function to stop watching
+         */
+        async watch(handler) {
+            const jid = this.jid ?? this.lid ?? this._raw.id;
+            const mine = (jid.split('@')[0] ?? '').split(':')[0];
+            await init.socket.presenceSubscribe(jid);
+            return init.wa.on('contact:presence', (who, name) => {
+                // El mismo contacto llega unas veces por teléfono y otras por LID: comparar la
+                // parte identificadora es lo único que los reconoce como la misma persona.
+                // The same contact arrives sometimes by phone and sometimes by LID: comparing the
+                // identifying part is the only thing recognising them as the same person.
+                if ([who.jid, who.lid, who._raw.id].some((id) => (id ?? '').startsWith(mine))) {
+                    handler({ name, payload: who });
+                }
+            });
+        }
         /**
          * Contacto por teléfono, JID o LID: primero el engine y, si no está persistido, se
          * descubre por red con su foto y su bio, y se materializa.

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

@@ -11,6 +11,7 @@ import Chat from '../../lib/chat';
 import type Contact from '../../lib/contact';
 import { type Engine } from '../../lib/store';
 import type WhatsApp from '../../lib/whatsapp';
+import type { MessageWatch, WatchEvent } from '../../lib/whatsapp';
 /** Estados legibles indexados por el status numérico de baileys. / Readable states indexed by the baileys numeric status. */
 declare const STATUS: readonly ["error", "pending", "sent", "delivered", "read", "played"];
 /** Sesión activa que liga la entidad. / Active session binding the entity. */
@@ -62,6 +63,12 @@ export default class Message {
             emoji: string;
             at: number;
         }[];
+        responses?: {
+            author: string;
+            response: 'going' | 'not_going' | 'maybe';
+            guests: number;
+            at: number;
+        }[];
         viewed?: boolean | null;
         raw: WAMessage;
     };
@@ -154,6 +161,24 @@ export default class Message {
      * @param value - true destaca / true stars
      */
     star(value: boolean): Promise<boolean>;
+    /**
+     * Supervisa qué le pasa a este mensaje: que lo lean, que reproduzcan su audio o que lo
+     * retiren. Vive en la clase base, así que todo tipo de mensaje lo hereda.
+     *
+     * Por dentro escucha las actualizaciones del mensaje y las traduce: `message:updated` no
+     * distingue leído de reproducido —los dos son un cambio de estado— y quien supervisa un
+     * mensaje quiere saber cuál de los dos ocurrió, no que «algo cambió».
+     * Watches what happens to this message: that it gets read, that its audio gets played, or
+     * that it is retired. It lives on the base class, so every message type inherits it.
+     *
+     * Under the hood it listens to the message's updates and translates them: `message:updated`
+     * does not tell read from played —both are a status change— and whoever watches a message
+     * wants to know which of the two happened, not that «something changed».
+     *
+     * @param handler - Recibe cada cambio / Receives every change
+     * @returns Función para dejar de supervisar / Function to stop watching
+     */
+    watch(handler: (event: WatchEvent<MessageWatch, Message>) => void): () => void;
     /** Marca el mensaje como leído. / Marks the message as read. */
     seen(): Promise<boolean>;
     /**
@@ -292,6 +317,19 @@ export declare class Audio extends Media {
     get duration(): number;
     /** Forma de onda 0-100 lista para pintar. / Paint-ready 0-100 waveform. */
     get waveform(): number[];
+    /** true si ya fue reproducido: el micrófono azul que ve quien lo mandó. / true when already played: the blue mic its sender sees. */
+    get played(): boolean;
+    /**
+     * Acusa el audio como reproducido. Es un aviso aparte del de leído —abrir el chat no
+     * reproduce nada—, y por eso viaja como recibo propio: quien lo mandó ve el micrófono
+     * azul sólo después de esto.
+     * Acknowledges the audio as played. It is separate from the read receipt —opening the chat
+     * plays nothing— and so travels as its own receipt: whoever sent it sees the blue mic only
+     * after this.
+     *
+     * @returns true cuando el acuse salió / true once the receipt left
+     */
+    play(): Promise<boolean>;
 }
 /** Mensaje de sticker. / Sticker message. */
 export declare class Sticker extends Media {
@@ -370,6 +408,20 @@ export declare class VCard extends Message {
 export declare class Event extends Message {
     /** @internal Bloque del evento en el raw. / Raw event block. */
     get _event(): proto.Message.IEventMessage | null | undefined;
+    /** Asistentes confirmados, acompañantes incluidos. / Confirmed attendees, companions included. */
+    get going(): number;
+    /**
+     * Respuestas de asistencia al evento, con el nombre resuelto de cada contacto y en orden
+     * de llegada — la última es la más reciente.
+     * Attendance responses, with each contact's resolved name, in arrival order — the last one
+     * is the most recent.
+     */
+    attendees(): Promise<{
+        name: string;
+        contact: string;
+        response: 'going' | 'not_going' | 'maybe';
+        guests: number;
+    }[]>;
     /** Nombre del evento. / Event name. */
     get name(): string;
     /** Inicio en ISO UTC. / Start as ISO UTC. */
@@ -428,6 +480,12 @@ export declare function message(init: Init): {
                 emoji: string;
                 at: number;
             }[];
+            responses?: {
+                author: string;
+                response: "going" | "not_going" | "maybe";
+                guests: number;
+                at: number;
+            }[];
             viewed?: boolean | null;
             raw: WAMessage;
         };
@@ -511,6 +569,24 @@ export declare function message(init: Init): {
          * @param value - true destaca / true stars
          */
         star(value: boolean): Promise<boolean>;
+        /**
+         * Supervisa qué le pasa a este mensaje: que lo lean, que reproduzcan su audio o que lo
+         * retiren. Vive en la clase base, así que todo tipo de mensaje lo hereda.
+         *
+         * Por dentro escucha las actualizaciones del mensaje y las traduce: `message:updated` no
+         * distingue leído de reproducido —los dos son un cambio de estado— y quien supervisa un
+         * mensaje quiere saber cuál de los dos ocurrió, no que «algo cambió».
+         * Watches what happens to this message: that it gets read, that its audio gets played, or
+         * that it is retired. It lives on the base class, so every message type inherits it.
+         *
+         * Under the hood it listens to the message's updates and translates them: `message:updated`
+         * does not tell read from played —both are a status change— and whoever watches a message
+         * wants to know which of the two happened, not that «something changed».
+         *
+         * @param handler - Recibe cada cambio / Receives every change
+         * @returns Función para dejar de supervisar / Function to stop watching
+         */
+        watch(handler: (event: WatchEvent<MessageWatch, Message>) => void): () => void;
         /** Marca el mensaje como leído. / Marks the message as read. */
         seen(): Promise<boolean>;
         /**

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

@@ -295,6 +295,51 @@ class Message {
         await this._init.engine.set(`/chat/${doc.cid}/message/${doc.id}`, (0, store_1.serialize)(doc), doc.created_at);
         return true;
     }
+    /**
+     * Supervisa qué le pasa a este mensaje: que lo lean, que reproduzcan su audio o que lo
+     * retiren. Vive en la clase base, así que todo tipo de mensaje lo hereda.
+     *
+     * Por dentro escucha las actualizaciones del mensaje y las traduce: `message:updated` no
+     * distingue leído de reproducido —los dos son un cambio de estado— y quien supervisa un
+     * mensaje quiere saber cuál de los dos ocurrió, no que «algo cambió».
+     * Watches what happens to this message: that it gets read, that its audio gets played, or
+     * that it is retired. It lives on the base class, so every message type inherits it.
+     *
+     * Under the hood it listens to the message's updates and translates them: `message:updated`
+     * does not tell read from played —both are a status change— and whoever watches a message
+     * wants to know which of the two happened, not that «something changed».
+     *
+     * @param handler - Recibe cada cambio / Receives every change
+     * @returns Función para dejar de supervisar / Function to stop watching
+     */
+    watch(handler) {
+        const { wa } = this._init;
+        let seen = this._raw.status;
+        const off_updated = wa.on('message:updated', (msg) => {
+            if (msg.id === this._raw.id) {
+                const status = msg._raw.status;
+                // Sólo los avances cuentan: un mismo estado repetido no es una noticia, y sin
+                // este corte cada acuse reenviado por WhatsApp se contaría como una lectura más.
+                // Only advances count: a repeated status is not news, and without this cut every
+                // acknowledgement WhatsApp resends would count as another read.
+                if (status > seen) {
+                    seen = status;
+                    if (status >= baileys_1.proto.WebMessageInfo.Status.PLAYED)
+                        handler({ name: 'played', payload: msg });
+                    else if (status >= baileys_1.proto.WebMessageInfo.Status.READ)
+                        handler({ name: 'read', payload: msg });
+                }
+            }
+        });
+        const off_deleted = wa.on('message:deleted', (msg) => {
+            if (msg.id === this._raw.id)
+                handler({ name: 'deleted', payload: msg });
+        });
+        return () => {
+            off_updated();
+            off_deleted();
+        };
+    }
     /** Marca el mensaje como leído. / Marks the message as read. */
     async seen() {
         const { cid, id, author } = this._raw;
@@ -478,6 +523,23 @@ class Audio extends Media {
     get duration() { return this._media?.seconds ?? 0; }
     /** Forma de onda 0-100 lista para pintar. / Paint-ready 0-100 waveform. */
     get waveform() { return Array.from(to_buffer(this._media?.waveform) ?? []); }
+    /** true si ya fue reproducido: el micrófono azul que ve quien lo mandó. / true when already played: the blue mic its sender sees. */
+    get played() { return this._raw.status >= baileys_1.proto.WebMessageInfo.Status.PLAYED; }
+    /**
+     * Acusa el audio como reproducido. Es un aviso aparte del de leído —abrir el chat no
+     * reproduce nada—, y por eso viaja como recibo propio: quien lo mandó ve el micrófono
+     * azul sólo después de esto.
+     * Acknowledges the audio as played. It is separate from the read receipt —opening the chat
+     * plays nothing— and so travels as its own receipt: whoever sent it sees the blue mic only
+     * after this.
+     *
+     * @returns true cuando el acuse salió / true once the receipt left
+     */
+    async play() {
+        const { cid, id, author } = this._raw;
+        await this._init.socket.sendReceipt(cid, cid.endsWith('@g.us') ? author : undefined, [id], 'played');
+        return true;
+    }
 }
 exports.Audio = Audio;
 /** Mensaje de sticker. / Sticker message. */
@@ -615,6 +677,25 @@ exports.VCard = VCard;
 class Event extends Message {
     /** @internal Bloque del evento en el raw. / Raw event block. */
     get _event() { return this._raw.raw.message?.eventMessage; }
+    /** Asistentes confirmados, acompañantes incluidos. / Confirmed attendees, companions included. */
+    get going() {
+        return (this._raw.responses ?? []).filter((entry) => entry.response === 'going').reduce((sum, entry) => sum + 1 + entry.guests, 0);
+    }
+    /**
+     * Respuestas de asistencia al evento, con el nombre resuelto de cada contacto y en orden
+     * de llegada — la última es la más reciente.
+     * Attendance responses, with each contact's resolved name, in arrival order — the last one
+     * is the most recent.
+     */
+    async attendees() {
+        const rows = [];
+        for (const entry of this._raw.responses ?? []) {
+            const who = await this._init.wa.Contact.get(entry.author).catch(() => null);
+            const contact = (who?.phone ?? entry.author.split('@')[0].split(':')[0]);
+            rows.push({ name: who?.name ?? contact, contact, response: entry.response, guests: entry.guests });
+        }
+        return rows;
+    }
     /** Nombre del evento. / Event name. */
     get name() { return this._event?.name ?? ''; }
     /** Inicio en ISO UTC. / Start as ISO UTC. */

package/build/cjs/lib/whatsapp/index.d.ts

@@ -3,6 +3,33 @@ import { Account, contact } from '../../lib/contact';
 import Message, { message } from '../../lib/message';
 import { Feed } from '../../lib/status';
 import { type Engine } from '../../lib/store';
+/**
+ * Lo que hace alguien al otro lado, en los términos en los que se mira: WhatsApp distingue
+ * «disponible» de «escribiendo» y de «grabando», y esa distinción es justo la que interesa
+ * vigilar. `paused` no se propaga: es dejar de escribir, no un estado en sí.
+ * What someone is doing on the other end, in the terms one watches it: WhatsApp tells «available»
+ * from «typing» and from «recording», and that distinction is exactly what is worth watching.
+ * `paused` is not propagated: it is stopping typing, not a state of its own.
+ */
+export type Presence = 'online' | 'offline' | 'typing' | 'recording';
+/**
+ * Lo que se supervisa con `watch()`, en un solo sobre: `name` dice qué pasó y `payload` trae la
+ * instancia a la que le pasó, ya resuelta. Quien escucha no tiene que volver a buscar de quién
+ * se trata ni filtrar lo que no le toca.
+ * What `watch()` supervises, in a single envelope: `name` says what happened and `payload` brings
+ * the already-resolved instance it happened to. Whoever listens does not have to look up who it
+ * was nor filter out what does not concern them.
+ */
+export interface WatchEvent<N extends string, P> {
+    name: N;
+    payload: P;
+}
+/** Cada acción de alguien al otro lado, incluido dejar de escribir o de grabar. / Every action from the other end, including stopping typing or recording. */
+export type ContactWatch = 'online' | 'offline' | 'typing' | 'recording' | 'stopped-typing' | 'stopped-recording';
+/** Lo que le puede pasar a un mensaje ya enviado. / What can happen to an already-sent message. */
+export type MessageWatch = 'read' | 'played' | 'deleted';
+/** Un chat mezcla lo que hace la persona con lo que llega a la conversación. / A chat mixes what the person does with what arrives in the conversation. */
+export type ChatWatch = ContactWatch | 'message';
 type ChatInstance = InstanceType<ReturnType<typeof chat>>;
 type ContactInstance = InstanceType<ReturnType<typeof contact>>;
 interface Options {
@@ -63,8 +90,14 @@ export interface Farewell {
 interface EventMap {
     connected: [WhatsApp];
     disconnected: [WhatsApp, Farewell];
+    /** Fallo que no tumba la conexión pero que quien la abrió necesita saber. / A failure that does not drop the connection but whoever opened it needs to know. */
+    error: [Error & {
+        code?: string;
+    }, WhatsApp];
     'contact:created': [ContactInstance, ChatInstance, WhatsApp];
     'contact:updated': [ContactInstance, ChatInstance, WhatsApp];
+    /** Alguien entró, salió, escribe o graba. Sólo llega de quien se esté vigilando con `Contact.watch()`. / Someone came in, left, is typing or recording. Only arrives for whoever is being watched with `Contact.watch()`. */
+    'contact:presence': [ContactInstance, ContactWatch, WhatsApp];
     'chat:created': [ChatInstance, WhatsApp];
     'chat:deleted': [ChatInstance, WhatsApp];
     'chat:pinned': [ChatInstance, WhatsApp];
@@ -76,7 +109,7 @@ interface EventMap {
     'message:created': [Message, ChatInstance, WhatsApp];
     'message:updated': [Message, ChatInstance, WhatsApp];
     'message:deleted': [Message, ChatInstance, WhatsApp];
-    'message:reacted': [Message, ChatInstance, string, WhatsApp];
+    'message:reacted': [Message, ChatInstance, string, ContactInstance, WhatsApp];
     'message:starred': [Message, ChatInstance, WhatsApp];
     'message:unstarred': [Message, ChatInstance, WhatsApp];
     'message:forwarded': [Message, ChatInstance, WhatsApp];