@ezychat/wa 0.1.68 → 0.1.70

package/dist/baileys/adapter.d.ts

@@ -1,7 +1,7 @@
 import { EventEmitter } from 'node:events';
 import { type BaileysEventMap, type MessageUpsertType, type MessageUserReceiptUpdate, type WAMessageUpdate, type WAMessage } from 'baileys';
 import type { WaStatus } from '@ezychat/shared';
-import { type SendResult, type WaAdapter, type WaAdapterEvents, type WaAdapterOptions, type WaContactAlias, type WaGroupInfo, type WaMessageStatusUpdate, type WaReactionTarget, type WaSendFile, type WaSendOptions } from '../types.js';
+import { type SendResult, type WaAdapter, type WaAdapterEvents, type WaAdapterOptions, type WaContactAlias, type WaGroupInfo, type WaMessageStatusUpdate, type WaMessageTarget, type WaReactionTarget, type WaSendFile, type WaSendOptions } from '../types.js';
 /** True when a send error means "the connection went away" (retry later) rather than a real rejection. */
 export declare function isConnectionError(err: unknown): boolean;
 /** Per-participant group receipt → our status (read wins over delivered). */
@@ -25,6 +25,11 @@ export declare class BaileysAdapter extends EventEmitter implements WaAdapter {
     private readonly logger;
     private readonly historyDaysOpt;
     private raw;
+    /**
+     * Target ids of edits and deletes this adapter sent → when: WhatsApp echoes them back like the
+     * phone's own, and the core already recorded them with the teammate who made them.
+     */
+    private readonly ownChanges;
     private attempt;
     private reconnectTimer;
     /** true when the socket was closed on purpose (disconnect/logout/replaced/blocked). */
@@ -87,7 +92,17 @@ export declare class BaileysAdapter extends EventEmitter implements WaAdapter {
     private send;
     sendText(chatJid: string, text: string, opts?: WaSendOptions): Promise<SendResult>;
     sendMedia(chatJid: string, file: WaSendFile, opts?: WaSendOptions): Promise<SendResult>;
+    /** The key WhatsApp matches a message by; the cached key carries the group author as delivered. */
+    private targetKey;
     sendReaction(chatJid: string, target: WaReactionTarget, emoji: string): Promise<SendResult>;
+    /** Remember an edit/delete we send, so its echo is not reported as the phone's. */
+    private markOwnChange;
+    /** True (and forgotten) when a fromMe change of `targetId` is the echo of our own. */
+    private takeOwnChange;
+    private sendChange;
+    editText(chatJid: string, target: WaMessageTarget, text: string): Promise<SendResult>;
+    deleteForEveryone(chatJid: string, target: WaMessageTarget): Promise<SendResult>;
+    deleteForMe(chatJid: string, target: WaMessageTarget, timestamp: number): Promise<void>;
     markRead(chatJid: string, messageIds: string[]): Promise<void>;
     sendPresence(chatJid: string, presence: 'composing' | 'paused'): Promise<void>;
     downloadMedia(messageId: string): Promise<Buffer | null>;

package/dist/baileys/adapter.js

@@ -5,14 +5,22 @@ import { WaUnavailableError, } from '../types.js';
 import { createAuthStore } from './auth-store.js';
 import { backoffMs, classifyDisconnect } from './disconnect.js';
 import { Lru } from './lru.js';
+import { createWaVersionSource } from './wa-version.js';
 import { jidType, mapStoredReactions, mapWAMessage, mapWAReaction, toMs } from './mapping.js';
 import { quotedForChat, quotedFromRef } from './quoted.js';
+import { mapWAProtocol } from './protocol.js';
 import { contactAliasPair, normalizeContactJid } from './contact-aliases.js';
 import { checkedNumberJid } from './number-check.js';
 import { profilePhoto } from './photos.js';
 import { aboutFromStatusResult, mapGroupMetadata } from './groups.js';
 const RAW_CACHE_MAX = 2000;
+/** How long an edit or delete this adapter sent waits for WhatsApp's echo of it. */
+const OWN_CHANGE_TTL_MS = 60_000;
 const DAY_MS = 86_400_000;
+/** One per process: every inbox and reconnect shares the looked-up WhatsApp Web version. */
+const waVersion = createWaVersionSource({
+    fetchLatest: () => fetchLatestBaileysVersion(),
+});
 /** Boom status codes Baileys uses when the socket is closed / lost / replaced / unavailable. */
 const CONNECTION_STATUS_CODES = new Set([408, 428, 440, 503]);
 /** True when a send error means "the connection went away" (retry later) rather than a real rejection. */
@@ -75,6 +83,11 @@ export class BaileysAdapter extends EventEmitter {
     logger;
     historyDaysOpt;
     raw = new Lru(RAW_CACHE_MAX);
+    /**
+     * Target ids of edits and deletes this adapter sent → when: WhatsApp echoes them back like the
+     * phone's own, and the core already recorded them with the teammate who made them.
+     */
+    ownChanges = new Map();
     attempt = 0;
     reconnectTimer = null;
     /** true when the socket was closed on purpose (disconnect/logout/replaced/blocked). */
@@ -231,14 +244,12 @@ export class BaileysAdapter extends EventEmitter {
     async open() {
         this.setStatus({ state: 'connecting', qr: null });
         const { state, saveCreds } = await this.auth.load();
-        let version;
-        try {
-            const latest = await fetchLatestBaileysVersion();
-            version = latest.version;
-        }
-        catch (err) {
-            this.logger.warn({ err }, 'could not fetch latest WA version; using bundled default');
-        }
+        // Never wait for the GitHub lookup: connect with the version we have, refresh it for next time.
+        const version = waVersion.current();
+        void waVersion.refresh().then(({ error }) => {
+            if (error)
+                this.logger.warn({ err: error }, 'could not fetch latest WA version');
+        });
         if (this.stopped)
             return; // disconnect() was called while loading
         const blog = this.logger.child({ module: 'baileys' });
@@ -407,8 +418,15 @@ export class BaileysAdapter extends EventEmitter {
             if (!key.id || !key.remoteJid || !key.fromMe)
                 continue;
             const status = mapAck(update.status);
-            if (status)
-                this.emitTyped('messageStatus', { id: key.id, chatJid: key.remoteJid, status });
+            if (!status)
+                continue;
+            const code = status === 'failed' ? update.messageStubParameters?.[0] : undefined;
+            this.emitTyped('messageStatus', {
+                id: key.id,
+                chatJid: key.remoteJid,
+                status,
+                ...(typeof code === 'string' && code ? { error: code } : {}),
+            });
         }
     }
     /** @internal exposed for tests */
@@ -439,6 +457,21 @@ export class BaileysAdapter extends EventEmitter {
             this.emitTyped('reaction', reaction, { source });
             return;
         }
+        // Edits and deletes arrive as protocol messages naming the changed message. Baileys also
+        // reports them as messages.update; only this path is read, so each change counts once.
+        const change = mapWAProtocol(m);
+        if (change) {
+            const { targetId, fromMe, timestamp } = change.kind === 'edit' ? change.edit : change.revoke;
+            if (source === 'history' && timestamp < this.historyCutoff())
+                return;
+            if (fromMe && this.takeOwnChange(targetId))
+                return;
+            if (change.kind === 'edit')
+                this.emitTyped('messageEdited', change.edit, { source });
+            else
+                this.emitTyped('messageDeleted', change.revoke, { source });
+            return;
+        }
         if (m.message)
             this.raw.set(id, m);
         // History sync keeps earlier reactions on the reacted message itself.
@@ -613,7 +646,11 @@ export class BaileysAdapter extends EventEmitter {
                 : undefined;
         let res;
         try {
-            res = await sock.sendMessage(chatJid, content, quoted ? { quoted } : undefined);
+            const options = {
+                ...(quoted ? { quoted } : {}),
+                ...(opts?.messageId ? { messageId: opts.messageId } : {}),
+            };
+            res = await sock.sendMessage(chatJid, content, Object.keys(options).length ? options : undefined);
         }
         catch (err) {
             // connection dropped mid-send: report as unavailable so the queue keeps the job pending
@@ -666,16 +703,77 @@ export class BaileysAdapter extends EventEmitter {
         }
         return this.send(chatJid, content, opts);
     }
-    sendReaction(chatJid, target, emoji) {
-        // The cached key carries the group author exactly as WhatsApp delivered it.
+    /** The key WhatsApp matches a message by; the cached key carries the group author as delivered. */
+    targetKey(chatJid, target) {
         const participant = this.raw.get(target.id)?.key?.participant ?? target.participant;
-        const key = {
+        return {
             remoteJid: chatJid,
             id: target.id,
             fromMe: target.fromMe,
             ...(participant && chatJid.endsWith('@g.us') ? { participant } : {}),
         };
-        return this.send(chatJid, { react: { text: emoji, key } }, undefined, false);
+    }
+    sendReaction(chatJid, target, emoji) {
+        return this.send(chatJid, { react: { text: emoji, key: this.targetKey(chatJid, target) } }, undefined, false);
+    }
+    /** Remember an edit/delete we send, so its echo is not reported as the phone's. */
+    markOwnChange(targetId) {
+        const t = Date.now();
+        for (const [id, at] of this.ownChanges)
+            if (t - at > OWN_CHANGE_TTL_MS)
+                this.ownChanges.delete(id);
+        this.ownChanges.set(targetId, t);
+    }
+    /** True (and forgotten) when a fromMe change of `targetId` is the echo of our own. */
+    takeOwnChange(targetId) {
+        const at = this.ownChanges.get(targetId);
+        if (at === undefined)
+            return false;
+        this.ownChanges.delete(targetId);
+        return Date.now() - at <= OWN_CHANGE_TTL_MS;
+    }
+    async sendChange(chatJid, target, content) {
+        this.markOwnChange(target.id);
+        try {
+            return await this.send(chatJid, content, undefined, false);
+        }
+        catch (err) {
+            this.ownChanges.delete(target.id);
+            throw err;
+        }
+    }
+    editText(chatJid, target, text) {
+        const key = this.targetKey(chatJid, target);
+        const cached = this.raw.get(target.id);
+        return this.sendChange(chatJid, target, { text, edit: key }).then((r) => {
+            // Later quotes of the message show the new text.
+            const m = cached?.message;
+            if (m?.conversation != null)
+                m.conversation = text;
+            else if (m?.extendedTextMessage)
+                m.extendedTextMessage.text = text;
+            return r;
+        });
+    }
+    deleteForEveryone(chatJid, target) {
+        return this.sendChange(chatJid, target, { delete: this.targetKey(chatJid, target) });
+    }
+    async deleteForMe(chatJid, target, timestamp) {
+        const sock = this.requireOpen();
+        try {
+            await sock.chatModify({
+                deleteForMe: {
+                    deleteMedia: true,
+                    key: this.targetKey(chatJid, target),
+                    timestamp: Math.floor(timestamp / 1000),
+                },
+            }, chatJid);
+        }
+        catch (err) {
+            if (isConnectionError(err) || this.sock !== sock || this._status.state !== 'open')
+                throw new WaUnavailableError(`WhatsApp connection lost: ${String(err?.message ?? err)}`);
+            throw err;
+        }
     }
     async markRead(chatJid, messageIds) {
         const sock = this.requireOpen();

package/dist/baileys/protocol.d.ts

@@ -0,0 +1,16 @@
+import { proto } from 'baileys';
+import type { WaMessageEdit, WaMessageRevoke } from '../types.js';
+export type WaProtocolChange = {
+    kind: 'edit';
+    edit: WaMessageEdit;
+} | {
+    kind: 'revoke';
+    revoke: WaMessageRevoke;
+};
+/**
+ * An edit (`MESSAGE_EDIT`) or a delete for everyone (`REVOKE`) as WhatsApp delivers it: a
+ * `protocolMessage` whose `key` names the changed message, sent by whoever changed it (the outer
+ * key: the DM partner, a group participant or the linked number). Null for every other message,
+ * for changes without a target or author, and for status/broadcast/newsletter chats.
+ */
+export declare function mapWAProtocol(msg: proto.IWebMessageInfo): WaProtocolChange | null;

package/dist/baileys/protocol.js

@@ -0,0 +1,67 @@
+import { normalizeMessageContent, proto } from 'baileys';
+import { normalizeContactJid } from './contact-aliases.js';
+import { jidType, toMs } from './mapping.js';
+/** The text or caption of an edited message (what `MESSAGE_EDIT` carries), or null. */
+function editedText(message) {
+    const m = normalizeMessageContent(message);
+    if (!m)
+        return null;
+    if (m.conversation != null)
+        return m.conversation;
+    return (m.extendedTextMessage?.text ??
+        m.imageMessage?.caption ??
+        m.videoMessage?.caption ??
+        m.documentMessage?.caption ??
+        null);
+}
+function millis(ts) {
+    if (ts == null)
+        return null;
+    if (typeof ts === 'number')
+        return ts;
+    if ('toNumber' in ts && typeof ts.toNumber === 'function')
+        return ts.toNumber();
+    if ('low' in ts)
+        return (ts.high >>> 0) * 2 ** 32 + (ts.low >>> 0);
+    return null;
+}
+/**
+ * An edit (`MESSAGE_EDIT`) or a delete for everyone (`REVOKE`) as WhatsApp delivers it: a
+ * `protocolMessage` whose `key` names the changed message, sent by whoever changed it (the outer
+ * key: the DM partner, a group participant or the linked number). Null for every other message,
+ * for changes without a target or author, and for status/broadcast/newsletter chats.
+ */
+export function mapWAProtocol(msg) {
+    const key = msg.key;
+    const chatJid = key?.remoteJid;
+    if (!key || !chatJid || jidType(chatJid) === 'other')
+        return null;
+    const protocol = normalizeMessageContent(msg.message)?.protocolMessage;
+    const targetId = protocol?.key?.id;
+    if (!protocol || !targetId)
+        return null;
+    const isGroup = jidType(chatJid) === 'group';
+    const fromMe = !!key.fromMe;
+    const senderJid = fromMe
+        ? null
+        : isGroup
+            ? normalizeContactJid(key.participant)
+            : (normalizeContactJid(chatJid) ?? chatJid);
+    if (!fromMe && !senderJid)
+        return null;
+    const senderJidAlt = !fromMe && isGroup ? normalizeContactJid(key.participantAlt) : null;
+    const alt = isGroup ? null : normalizeContactJid(key.remoteJidAlt);
+    const chatJidAlt = alt && alt.endsWith('@lid') !== chatJid.endsWith('@lid') ? alt : null;
+    const sent = toMs(msg.messageTimestamp);
+    const base = { targetId, chatJid, chatJidAlt, senderJid, senderJidAlt, fromMe };
+    if (protocol.type === proto.Message.ProtocolMessage.Type.REVOKE)
+        return { kind: 'revoke', revoke: { ...base, timestamp: sent } };
+    if (protocol.type === proto.Message.ProtocolMessage.Type.MESSAGE_EDIT) {
+        const body = editedText(protocol.editedMessage);
+        if (body === null)
+            return null;
+        const at = millis(protocol.timestampMs) ?? sent;
+        return { kind: 'edit', edit: { ...base, body, timestamp: at } };
+    }
+    return null;
+}

package/dist/baileys/wa-version.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The WhatsApp Web version to announce. WhatsApp refuses clients whose version is too old, so Baileys
+ * suggests looking up the newest one from its GitHub copy on every connect. That lookup has no
+ * timeout, and awaiting it before the socket held every connect (and every new QR) at "connecting"
+ * while GitHub was slow or blocked. A connect never waits for it now: it uses the last version
+ * looked up (or Baileys' bundled one) at once, and the lookup refreshes in the background, bounded
+ * by `timeoutMs` and cached, so a connect WhatsApp refused for an old version retries with the new one.
+ */
+export type WaVersion = [number, number, number];
+export interface WaVersionSourceOptions {
+    fetchLatest: () => Promise<{
+        version: WaVersion;
+    }>;
+    timeoutMs?: number;
+    /** How long a fetched version is reused before the next lookup. */
+    ttlMs?: number;
+    /** How long to skip the lookup after a failure or timeout. */
+    failureTtlMs?: number;
+    now?: () => number;
+}
+export declare const WA_VERSION_TIMEOUT_MS = 10000;
+export interface WaVersionRefresh {
+    version: WaVersion | undefined;
+    /** Set when this refresh tried the lookup and it failed or timed out. */
+    error?: unknown;
+}
+export interface WaVersionSource {
+    /** The version to connect with now: the last one looked up, else undefined (Baileys' bundled one). */
+    current(): WaVersion | undefined;
+    /** Looks the version up unless a recent result is cached; never rejects, one lookup at a time. */
+    refresh(): Promise<WaVersionRefresh>;
+}
+export declare function createWaVersionSource(opts: WaVersionSourceOptions): WaVersionSource;

package/dist/baileys/wa-version.js

@@ -0,0 +1,44 @@
+export const WA_VERSION_TIMEOUT_MS = 10_000;
+const WA_VERSION_TTL_MS = 6 * 60 * 60_000;
+const WA_VERSION_FAILURE_TTL_MS = 10 * 60_000;
+export function createWaVersionSource(opts) {
+    const timeoutMs = opts.timeoutMs ?? WA_VERSION_TIMEOUT_MS;
+    const ttlMs = opts.ttlMs ?? WA_VERSION_TTL_MS;
+    const failureTtlMs = opts.failureTtlMs ?? WA_VERSION_FAILURE_TTL_MS;
+    const now = opts.now ?? Date.now;
+    let version;
+    let nextLookupAt = 0;
+    let inflight = null;
+    const lookup = async () => {
+        let timer;
+        try {
+            const timeout = new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new Error(`WA version lookup timed out after ${timeoutMs} ms`)), timeoutMs);
+                timer.unref?.();
+            });
+            ({ version } = await Promise.race([opts.fetchLatest(), timeout]));
+            nextLookupAt = now() + ttlMs;
+            return { version };
+        }
+        catch (error) {
+            nextLookupAt = now() + failureTtlMs;
+            return { version, error };
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    };
+    return {
+        current: () => version,
+        refresh() {
+            if (inflight)
+                return inflight;
+            if (now() < nextLookupAt)
+                return Promise.resolve({ version });
+            inflight = lookup().finally(() => {
+                inflight = null;
+            });
+            return inflight;
+        },
+    };
+}

package/dist/fake/fake-adapter.d.ts

@@ -1,6 +1,6 @@
 import { EventEmitter } from 'node:events';
 import type { WaStatus } from '@ezychat/shared';
-import { type SendResult, type WaAdapter, type WaAdapterEvents, type WaCapabilities, type WaContactAlias, type WaGroupInfo, type WaIncomingMessage, type WaReaction, type WaReactionTarget, type WaSendFile, type WaSendOptions, type WaTemplate, type WaTemplateSend } from '../types.js';
+import { type SendResult, type WaAdapter, type WaAdapterEvents, type WaCapabilities, type WaContactAlias, type WaGroupInfo, type WaIncomingMessage, type WaMessageEdit, type WaMessageRevoke, type WaMessageTarget, type WaReaction, type WaReactionTarget, type WaSendFile, type WaSendOptions, type WaTemplate, type WaTemplateSend } from '../types.js';
 export interface FakeSentRecord {
     chatJid: string;
     text?: string;
@@ -25,6 +25,7 @@ export declare class FakeWaAdapter extends EventEmitter implements WaAdapter {
     private inCounter;
     private outCounter;
     private nextSendError;
+    private skipDelivery;
     private readonly media;
     private readonly groups;
     private readonly abouts;
@@ -38,6 +39,22 @@ export declare class FakeWaAdapter extends EventEmitter implements WaAdapter {
         target: WaReactionTarget;
         emoji: string;
     }>;
+    /** Every edit, delete for everyone and delete for me sent (`editText`, `deleteFor…`). */
+    readonly changes: Array<{
+        kind: 'edit';
+        chatJid: string;
+        target: WaMessageTarget;
+        text: string;
+    } | {
+        kind: 'deleteForEveryone';
+        chatJid: string;
+        target: WaMessageTarget;
+    } | {
+        kind: 'deleteForMe';
+        chatJid: string;
+        target: WaMessageTarget;
+        timestamp: number;
+    }>;
     readonly reads: Array<{
         chatJid: string;
         messageIds: string[];
@@ -101,6 +118,10 @@ export declare class FakeWaAdapter extends EventEmitter implements WaAdapter {
     sendMedia(chatJid: string, file: WaSendFile, opts?: WaSendOptions): Promise<SendResult>;
     /** Like WhatsApp, the linked number's own reaction comes back as a `reaction` event first. */
     sendReaction(chatJid: string, target: WaReactionTarget, emoji: string): Promise<SendResult>;
+    /** Unlike reactions, WhatsApp's echo of our own edit or delete is never reported (as Baileys). */
+    editText(chatJid: string, target: WaMessageTarget, text: string): Promise<SendResult>;
+    deleteForEveryone(chatJid: string, target: WaMessageTarget): Promise<SendResult>;
+    deleteForMe(chatJid: string, target: WaMessageTarget, timestamp: number): Promise<void>;
     markRead(chatJid: string, messageIds: string[]): Promise<void>;
     sendPresence(chatJid: string, presence: 'composing' | 'paused'): Promise<void>;
     downloadMedia(messageId: string): Promise<Buffer | null>;
@@ -140,7 +161,24 @@ export declare class FakeWaAdapter extends EventEmitter implements WaAdapter {
         targetId: string;
         emoji: string;
     }, source?: 'live' | 'history'): WaReaction;
+    /**
+     * Emit an edit (live unless `source` says history). In a DM the editor defaults to the chat
+     * partner; `fromMe` means the linked phone edited.
+     */
+    simulateEdit(p: Partial<WaMessageEdit> & {
+        chatJid: string;
+        targetId: string;
+        body: string;
+    }, source?: 'live' | 'history'): WaMessageEdit;
+    /** Emit a delete for everyone (live unless `source` says history), as `simulateEdit`. */
+    simulateRevoke(p: Partial<WaMessageRevoke> & {
+        chatJid: string;
+        targetId: string;
+    }, source?: 'live' | 'history'): WaMessageRevoke;
+    private changeAuthor;
     simulateStatus(s: Partial<WaStatus>): void;
+    /** The next send gets its server ack but no delivered receipt (no phone took it). */
+    skipNextDelivery(): void;
     failNextSend(err?: Error): void;
     setConnected(connected: boolean): void;
 }

package/dist/fake/fake-adapter.js

@@ -15,6 +15,7 @@ export class FakeWaAdapter extends EventEmitter {
     inCounter = 0;
     outCounter = 0;
     nextSendError = null;
+    skipDelivery = false;
     media = new Map();
     groups = new Map();
     abouts = new Map();
@@ -24,6 +25,8 @@ export class FakeWaAdapter extends EventEmitter {
     aboutCalls = [];
     sent = [];
     reactions = [];
+    /** Every edit, delete for everyone and delete for me sent (`editText`, `deleteFor…`). */
+    changes = [];
     reads = [];
     presences = [];
     /** Every template sent (adapters given `templates`). */
@@ -132,12 +135,15 @@ export class FakeWaAdapter extends EventEmitter {
     afterSend(chatJid, id) {
         const timestamp = Date.now();
         this.emitTyped('messageStatus', { id, chatJid, status: 'sent' });
-        setImmediate(() => this.emitTyped('messageStatus', { id, chatJid, status: 'delivered' }));
+        if (this.skipDelivery)
+            this.skipDelivery = false;
+        else
+            setImmediate(() => this.emitTyped('messageStatus', { id, chatJid, status: 'delivered' }));
         return { id, timestamp };
     }
     async sendText(chatJid, text, opts) {
         this.beforeSend();
-        const id = `${this.idPrefix}-OUT-${FAKE_RUN}-${++this.outCounter}`;
+        const id = opts?.messageId ?? `${this.idPrefix}-OUT-${FAKE_RUN}-${++this.outCounter}`;
         this.sent.push({
             chatJid,
             text,
@@ -149,7 +155,7 @@ export class FakeWaAdapter extends EventEmitter {
     }
     async sendMedia(chatJid, file, opts) {
         this.beforeSend();
-        const id = `${this.idPrefix}-OUT-${FAKE_RUN}-${++this.outCounter}`;
+        const id = opts?.messageId ?? `${this.idPrefix}-OUT-${FAKE_RUN}-${++this.outCounter}`;
         this.sent.push({ chatJid, file, id, ...(opts?.quotedId ? { reply: opts } : {}) });
         this.media.set(id, file.buffer);
         return this.afterSend(chatJid, id);
@@ -163,6 +169,24 @@ export class FakeWaAdapter extends EventEmitter {
         this.simulateReaction({ chatJid, targetId: target.id, emoji, fromMe: true, timestamp });
         return { id, timestamp };
     }
+    /** Unlike reactions, WhatsApp's echo of our own edit or delete is never reported (as Baileys). */
+    async editText(chatJid, target, text) {
+        this.beforeSend();
+        this.changes.push({ kind: 'edit', chatJid, target: { ...target }, text });
+        return { id: `${this.idPrefix}-EDIT-${FAKE_RUN}-${++this.outCounter}`, timestamp: Date.now() };
+    }
+    async deleteForEveryone(chatJid, target) {
+        this.beforeSend();
+        this.changes.push({ kind: 'deleteForEveryone', chatJid, target: { ...target } });
+        return {
+            id: `${this.idPrefix}-REVOKE-${FAKE_RUN}-${++this.outCounter}`,
+            timestamp: Date.now(),
+        };
+    }
+    async deleteForMe(chatJid, target, timestamp) {
+        this.beforeSend();
+        this.changes.push({ kind: 'deleteForMe', chatJid, target: { ...target }, timestamp });
+    }
     async markRead(chatJid, messageIds) {
         this.reads.push({ chatJid, messageIds: [...messageIds] });
     }
@@ -298,9 +322,47 @@ export class FakeWaAdapter extends EventEmitter {
         this.emitTyped('reaction', reaction, { source });
         return reaction;
     }
+    /**
+     * Emit an edit (live unless `source` says history). In a DM the editor defaults to the chat
+     * partner; `fromMe` means the linked phone edited.
+     */
+    simulateEdit(p, source = 'live') {
+        const edit = { ...this.changeAuthor(p), body: p.body };
+        this.emitTyped('messageEdited', edit, { source });
+        return edit;
+    }
+    /** Emit a delete for everyone (live unless `source` says history), as `simulateEdit`. */
+    simulateRevoke(p, source = 'live') {
+        const revoke = this.changeAuthor(p);
+        this.emitTyped('messageDeleted', revoke, { source });
+        return revoke;
+    }
+    changeAuthor(p) {
+        const isGroup = p.chatJid.endsWith('@g.us');
+        const fromMe = p.fromMe ?? false;
+        return {
+            targetId: p.targetId,
+            chatJid: p.chatJid,
+            chatJidAlt: p.chatJidAlt ?? null,
+            senderJid: fromMe
+                ? null
+                : p.senderJid !== undefined
+                    ? p.senderJid
+                    : isGroup
+                        ? null
+                        : p.chatJid,
+            senderJidAlt: p.senderJidAlt ?? null,
+            fromMe,
+            timestamp: p.timestamp ?? Date.now(),
+        };
+    }
     simulateStatus(s) {
         this.setStatus(s);
     }
+    /** The next send gets its server ack but no delivered receipt (no phone took it). */
+    skipNextDelivery() {
+        this.skipDelivery = true;
+    }
     failNextSend(err = new Error('Fake send failure')) {
         this.nextSendError = err;
     }

package/dist/types.d.ts

@@ -50,6 +50,43 @@ export interface WaReaction {
     /** epoch ms */
     timestamp: number;
 }
+/**
+ * Someone edited a message they sent (WhatsApp `MESSAGE_EDIT`): the customer, a group member or the
+ * linked number itself (its phone or another linked device). Only text and captions are edited.
+ */
+export interface WaMessageEdit {
+    /** WhatsApp id of the edited message. */
+    targetId: string;
+    /** The chat of the message (as WhatsApp delivered the edit). */
+    chatJid: string;
+    /** DM only: the same person's other address (`key.remoteJidAlt`), as for messages. */
+    chatJidAlt?: string | null;
+    /** Who edited: the group participant or the DM partner; null when `fromMe`. */
+    senderJid: string | null;
+    senderJidAlt?: string | null;
+    /** Edited from the linked number (its phone or another linked device). */
+    fromMe: boolean;
+    /** The new text or caption. */
+    body: string;
+    /** epoch ms of the edit */
+    timestamp: number;
+}
+/**
+ * Someone deleted a message for everyone (WhatsApp `REVOKE`): its sender, the linked number, or in
+ * a group an admin deleting a member's message.
+ */
+export interface WaMessageRevoke {
+    /** WhatsApp id of the deleted message. */
+    targetId: string;
+    chatJid: string;
+    chatJidAlt?: string | null;
+    /** Who deleted it: the group participant or the DM partner; null when `fromMe`. */
+    senderJid: string | null;
+    senderJidAlt?: string | null;
+    fromMe: boolean;
+    /** epoch ms of the deletion */
+    timestamp: number;
+}
 export interface WaChatInfo {
     jid: string;
     type: 'dm' | 'group';
@@ -97,6 +134,8 @@ export interface WaMessageStatusUpdate {
     id: string;
     chatJid: string;
     status: 'sent' | 'delivered' | 'read' | 'failed';
+    /** `failed` only: the error code WhatsApp gave, when it gave one (for the log). */
+    error?: string;
 }
 export interface WaAdapterEvents {
     status: [WaStatus];
@@ -107,6 +146,14 @@ export interface WaAdapterEvents {
     reaction: [WaReaction, {
         source: 'live' | 'history';
     }];
+    /** A message was edited (live or history); never an echo of an edit this adapter sent. */
+    messageEdited: [WaMessageEdit, {
+        source: 'live' | 'history';
+    }];
+    /** A message was deleted for everyone (live or history); never an echo of this adapter's own. */
+    messageDeleted: [WaMessageRevoke, {
+        source: 'live' | 'history';
+    }];
     messageStatus: [WaMessageStatusUpdate];
     chats: [WaChatInfo[]];
     contacts: [WaContactInfo[]];
@@ -139,8 +186,17 @@ export interface WaSendOptions {
      * Only for adapters with `capabilities.mentions`.
      */
     mentions?: string[];
+    /**
+     * Send under this WhatsApp message id instead of a new one (Retry of a message WhatsApp already
+     * took): phones that already have that id ignore the copy, so no one sees it twice. An adapter
+     * that cannot choose the id ignores it.
+     */
+    messageId?: string;
 }
-/** The message a reaction points at: WhatsApp matches it by chat, id, side and group author. */
+/**
+ * The message a reaction, an edit or a delete points at: WhatsApp matches it by chat, id, side and
+ * group author.
+ */
 export interface WaReactionTarget {
     /** WhatsApp id of the message. */
     id: string;
@@ -149,6 +205,7 @@ export interface WaReactionTarget {
     /** Group messages from someone else: who wrote it. */
     participant?: string | null;
 }
+export type WaMessageTarget = WaReactionTarget;
 export interface SendResult {
     id: string;
     timestamp: number;
@@ -196,6 +253,12 @@ export interface WaCapabilities {
     blockWindowHours?: number | null;
     /** Sends WhatsApp mentions (`WaSendOptions.mentions`); absent: no. */
     mentions?: boolean;
+    /** Edits a sent text or caption (`editText`). Absent: no. */
+    editMessage?: boolean;
+    /** Deletes a sent message for everyone (`deleteForEveryone`). Absent: no. */
+    deleteForEveryone?: boolean;
+    /** Deletes a message on the linked device itself (`deleteForMe`). Absent: no. */
+    deleteForMe?: boolean;
 }
 /** The capabilities of an adapter that declares none: a phone linked by QR (Baileys, the fake). */
 export declare const LINKED_PHONE_CAPABILITIES: WaCapabilities;
@@ -246,6 +309,18 @@ export interface WaAdapter {
      * reaction per number, so this replaces one made on the phone. Throws WaUnavailableError offline.
      */
     sendReaction(chatJid: string, target: WaReactionTarget, emoji: string): Promise<SendResult>;
+    /**
+     * Replaces the text (or caption) of a message the linked number sent (`capabilities.editMessage`).
+     * WhatsApp shows the customer "Edited". Throws WaUnavailableError offline.
+     */
+    editText?(chatJid: string, target: WaMessageTarget, text: string): Promise<SendResult>;
+    /** Deletes a message for everyone (`capabilities.deleteForEveryone`). Throws WaUnavailableError offline. */
+    deleteForEveryone?(chatJid: string, target: WaMessageTarget): Promise<SendResult>;
+    /**
+     * Deletes a message on the linked phone only ("Delete for me", `capabilities.deleteForMe`);
+     * `timestamp` is the message's (epoch ms). Throws WaUnavailableError offline.
+     */
+    deleteForMe?(chatJid: string, target: WaMessageTarget, timestamp: number): Promise<void>;
     markRead(chatJid: string, messageIds: string[]): Promise<void>;
     sendPresence(chatJid: string, presence: 'composing' | 'paused'): Promise<void>;
     /** re-download by id if still cached */

package/dist/types.js

@@ -9,6 +9,9 @@ export const LINKED_PHONE_CAPABILITIES = Object.freeze({
     block: true,
     blockWindowHours: null,
     mentions: true,
+    editMessage: true,
+    deleteForEveryone: true,
+    deleteForMe: true,
 });
 export class WaUnavailableError extends Error {
     code = 'wa_unavailable';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ezychat/wa",
-  "version": "0.1.68",
+  "version": "0.1.70",
   "type": "module",
   "description": "EzyChat core: WhatsApp adapter interface, Baileys adapter and fake adapter.",
   "license": "MIT",
@@ -37,7 +37,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@ezychat/shared": "0.1.68",
+    "@ezychat/shared": "0.1.70",
     "baileys": "^7.0.0-rc14",
     "pino": "^10.4.0",
     "qrcode": "^1.5.4"