@stage-labs/metro 0.1.0-beta.32 → 0.1.0-beta.321

package/runtime/node_modules/@metro-labs/whatsapp/src/client.ts

@@ -1,22 +1,33 @@
 import makeWASocket, {
+  jidNormalizedUser,
   Browsers,
-  DisconnectReason,
   fetchLatestWaWebVersion,
   type proto,
   type WAMessage,
   type WAMessageKey,
   type WASocket,
 } from 'baileys';
-import { TrainError } from '@metro-labs/mcp/train-error';
-import { errMsg } from '@metro-labs/mcp/log';
+import { TrainError } from '@metro-labs/core/train-error';
+import { errMsg } from '@metro-labs/core/log';
 import type { WhatsAppAccount } from './types.js';
-import type { InboundMessage, ReactionInput } from './format.js';
-import { toInbound, toReaction, type ReactionEvent } from './parse.js';
+import type { InboundHandlers, WAClient, WAMedia, ClientRuntime } from './client-types.js';
+export type { InboundHandlers, WAClient, WAMedia } from './client-types.js';
+import { makeProfileCache, type SenderProfile } from '@metro-labs/core/stations/sender-profile';
+import type { SelfRef } from './parse.js';
+import type { History } from './history.js';
+import { createClientHistory } from './client-history.js';
+import { WhatsAppChannels } from './channels.js';
+import { bindMessages } from './messages.js';
+import { listMembers } from './members.js';
+import { SendExpiry } from './send-expiry.js';
 import { baileysLogger } from './logger.js';
+import { makeNameBook, nameFiles, type NameBook } from './names.js';
+import { limiter, PictureMemory, PROFILE_READS, readPeer, withName, type PeerProfile } from './profile.js';
 import { useAccountAuthState } from './auth-state.js';
 import { knownKey, makeKeyCache, targetKey, type KeyCache } from './keys.js';
 import { makeOutbox, type Outbox } from './outbox.js';
 import { deliveryNotes, describeNote } from './delivery.js';
+import { closeOf, closeReason, ConnectionWatch, failureOf, type Closed } from './connection.js';
 import {
   ACK_WAIT_MS,
   bindAcks,
@@ -25,69 +36,48 @@ import {
   type AckWatch,
 } from './ack.js';
 
-export interface InboundHandlers {
-  onMessage(m: InboundMessage, raw: WAMessage): void;
-  onReaction(r: ReactionInput): void;
-}
-
-export interface WAMedia {
-  kind: string;
-  path: string;
-  mime: string;
-  name: string;
-  caption?: string;
-}
-
-export interface WAClient {
-  account: WhatsAppAccount;
-  self(): string | null;
-  start(handlers: InboundHandlers): Promise<void>;
-  sendText(jid: string, text: string, quotedId?: string): Promise<string>;
-  sendMedia(jid: string, media: WAMedia, quotedId?: string): Promise<string>;
-  sendReaction(jid: string, messageId: string, emoji: string): Promise<void>;
-  editMessage(jid: string, messageId: string, text: string): Promise<void>;
-  deleteMessage(jid: string, messageId: string): Promise<void>;
-  reuploadMedia(m: WAMessage): Promise<WAMessage>;
-  disconnect(): Promise<void>;
-}
-
 interface State {
   account: WhatsAppAccount;
+  runtime: ClientRuntime;
+  history: History;
+  expiry: SendExpiry;
   handlers?: InboundHandlers;
   sock?: WASocket;
   closed: boolean;
+  closing?: Promise<void>;
   openResolve?: () => void;
   openPromise: Promise<void>;
   keys: KeyCache;
   outbox: Outbox;
   acks: AckWatch;
+  names: NameBook;
+  channels: WhatsAppChannels;
+  watch: ConnectionWatch;
 }
-
 type SendOpts = Parameters<WASocket['sendMessage']>[2];
 type SendContent = Parameters<WASocket['sendMessage']>[1];
-
 function resetGate(st: State): void {
   st.openPromise = new Promise<void>((resolve) => {
     st.openResolve = resolve;
   });
 }
+function selfRef(st: State, sock: WASocket): SelfRef {
+  const jids = new Set<string>();
+  const me = sock.user;
+  if (me?.id) jids.add(jidNormalizedUser(me.id));
+  if (me?.lid) jids.add(jidNormalizedUser(me.lid));
+  return { jids, sentByMe: (jid, id) => st.keys.lookup(jid, id)?.fromMe === true };
+}
 
 function bindInbound(st: State, sock: WASocket): void {
-  sock.ev.on('messages.upsert', ({ messages, type }) => {
-    for (const m of messages) st.keys.remember(m.key);
-    if (type !== 'notify' || !st.handlers) return;
-    for (const m of messages) {
-      if (m.key.fromMe) continue;
-      const inbound = toInbound(st.account.id, m);
-      if (inbound) st.handlers.onMessage(inbound, m);
-    }
-  });
-  sock.ev.on('messages.reaction', (events: ReactionEvent[]) => {
-    if (!st.handlers) return;
-    for (const event of events) {
-      const reaction = toReaction(st.account.id, event);
-      if (reaction) st.handlers.onReaction(reaction);
-    }
+  bindMessages(sock, {
+    accountId: st.account.id,
+    keys: st.keys,
+    names: st.names,
+    history: st.history,
+    current: () => !st.closed && st.sock === sock,
+    handlers: () => st.handlers,
+    self: () => selfRef(st, sock),
   });
 }
 
@@ -119,19 +109,10 @@ function servedFromOutbox(
   return message;
 }
 
-const TERMINAL: Record<number, string> = {
-  [DisconnectReason.loggedOut]: ' — re-pair required',
-  [DisconnectReason.connectionReplaced]:
-    ' — another metro took this device; not reconnecting (two sockets on one ' +
-    'identity evict each other and risk a 463 timelock)',
-};
-
-export function terminalReason(code: number | undefined): string | undefined {
-  return code === undefined ? undefined : TERMINAL[code];
-}
-
-function onClose(st: State, code: number | undefined): void {
-  const terminal = terminalReason(code);
+function onClose(st: State, closed: Closed): void {
+  const { code } = closed;
+  const terminal = closeReason(closed);
+  if (!st.closed) st.watch.closed(closed);
   if (st.closed || terminal !== undefined) {
     process.stderr.write(
       `whatsapp[${st.account.id}] disconnected (code=${code ?? '?'})${terminal ?? ''}\n`,
@@ -144,6 +125,7 @@ function onClose(st: State, code: number | undefined): void {
     process.stderr.write(
       `whatsapp[${st.account.id}] reconnect failed: ${errMsg(e)}\n`,
     );
+    st.watch.failed(failureOf(e, 'reconnect'));
   });
 }
 
@@ -152,14 +134,15 @@ function bindConnection(st: State, sock: WASocket): void {
     const { connection, lastDisconnect } = update;
     if (connection === 'open') {
       process.stderr.write(`whatsapp[${st.account.id}] connected\n`);
+      if (st.sock === sock) st.watch.opened();
       st.openResolve?.();
       return;
     }
     if (connection !== 'close') return;
-    const code = (
-      lastDisconnect?.error as { output?: { statusCode?: number } } | undefined
-    )?.output?.statusCode;
-    onClose(st, code);
+    onClose(st, closeOf(lastDisconnect?.error));
+  });
+  sock.ws.on('frame', () => {
+    if (st.sock === sock) st.watch.heard();
   });
 }
 
@@ -168,19 +151,22 @@ async function connect(st: State): Promise<void> {
     st.account.credentials,
     st.account.id,
   );
-  const { version, error } = await fetchLatestWaWebVersion({});
+  if (st.closed) return;
+  const { version, error } = await st.runtime.fetchVersion({});
+  if (st.closed) return;
   if (error) {
     throw new TrainError(
       'whatsapp_connect',
       `failed to fetch WhatsApp web version: ${errMsg(error)}`,
     );
   }
-  const sock = makeWASocket({
+  const sock = st.runtime.makeSocket({
     version,
     auth: state,
     browser: Browsers.macOS('Safari'),
     markOnlineOnConnect: false,
     syncFullHistory: false,
+    emitOwnEvents: false,
     logger: baileysLogger(st.account.id),
     getMessage: (key) => Promise.resolve(servedFromOutbox(st, key)),
   });
@@ -188,15 +174,25 @@ async function connect(st: State): Promise<void> {
   sock.ev.on('creds.update', () => void saveCreds());
   bindConnection(st, sock);
   bindInbound(st, sock);
+  st.channels.bind(sock, () => !st.closed && st.sock === sock);
+  st.expiry.bind(sock, () => !st.closed && st.sock === sock);
   bindDelivery(st, sock);
 }
-
+async function lidFor(st: State, sock: WASocket, jid: string): Promise<string | null> {
+  try {
+    return await sock.signalRepository.lidMapping.getLIDForPN(jid);
+  } catch (e) {
+    process.stderr.write(
+      `whatsapp[${st.account.id}] no lid on file for ${jid}: ${errMsg(e)}\n`,
+    );
+    return null;
+  }
+}
 async function ready(st: State): Promise<WASocket> {
   await st.openPromise;
-  if (!st.sock) throw new TrainError('whatsapp_call', 'socket not connected');
+  if (st.closed || !st.sock) throw new TrainError('whatsapp_call', 'socket not connected');
   return st.sock;
 }
-
 async function send(
   st: State,
   jid: string,
@@ -204,10 +200,13 @@ async function send(
   opts?: SendOpts,
 ): Promise<string> {
   const sock = await ready(st);
-  const sent = await sock.sendMessage(jid, content, opts);
-  st.keys.remember(sent?.key);
-  st.outbox.remember(sent?.key, sent?.message);
-  const messageId = sent?.key.id;
+  const expiration = await st.expiry.forSend(sock, jid, content);
+  if (st.closed || st.sock !== sock) throw new TrainError('whatsapp_call', 'socket not connected');
+  const sent = await sock.sendMessage(jid, content, expiration === undefined ? opts : { ...opts, ephemeralExpiration: expiration });
+  const key = sent?.key;
+  st.keys.remember(key);
+  st.outbox.remember(key, sent?.message);
+  const messageId = key?.id;
   if (!messageId)
     throw new TrainError(
       'whatsapp_call',
@@ -216,9 +215,15 @@ async function send(
   const ack = await st.acks.wait(messageId, ACK_WAIT_MS);
   const refused = ack ? rejection(ack) : undefined;
   if (refused) throw refused;
+  recordSent(st, sock, sent, expiration);
   return messageId;
 }
 
+function recordSent(st: State, sock: WASocket, sent: WAMessage | undefined, expiration?: number): void {
+  if (!sent || st.closed) return;
+  st.history.ingestSent([sent], sock.user?.id ? jidNormalizedUser(sock.user.id) : undefined, expiration);
+}
+
 function quotedOpts(st: State, jid: string, quotedId: string): SendOpts {
   return {
     quoted: {
@@ -244,16 +249,59 @@ function mediaContent(m: WAMedia): SendContent {
   };
 }
 
-export function createClient(account: WhatsAppAccount): WAClient {
+function profileReader(st: State): (jid: string) => Promise<SenderProfile | null> {
+  const pictures = new PictureMemory();
+  const reads = limiter(PROFILE_READS);
+  const senders = makeProfileCache<PeerProfile>(async (jid) => {
+    const sock = await ready(st);
+    return reads(() => readPeer(sock, jid, pictures));
+  }, {
+    onError: (jid, err) => process.stderr.write(`whatsapp[${st.account.id}] could not read the profile of ${jid}: ${errMsg(err)}\n`),
+  });
+  return async (jid) => {
+    const peer = await senders.get(jid);
+    return peer === null ? null : withName(peer, st.names);
+  };
+}
+
+async function disconnect(st: State): Promise<void> {
+  st.closed = true;
+  st.watch.stop();
+  st.openResolve?.();
+  try {
+    st.history.close();
+  } finally {
+    const sock = st.sock;
+    st.sock = undefined;
+    await sock?.end(undefined);
+  }
+}
+
+function initialState(account: WhatsAppAccount, runtime: ClientRuntime): State {
   const st: State = {
     account,
+    runtime,
+    history: createClientHistory(account.id),
+    expiry: new SendExpiry(account.id),
     closed: false,
     openPromise: Promise.resolve(),
     keys: makeKeyCache(),
     outbox: makeOutbox(),
     acks: makeAckWatch(),
+    names: makeNameBook(nameFiles.path(account.id)),
+    channels: new WhatsAppChannels(account.id),
+    watch: new ConnectionWatch(account.id, () => st.sock?.ws.isOpen !== false),
   };
   resetGate(st);
+  return st;
+}
+
+export function createClient(
+  account: WhatsAppAccount,
+  runtime: ClientRuntime = { makeSocket: makeWASocket, fetchVersion: fetchLatestWaWebVersion },
+): WAClient {
+  const st = initialState(account, runtime);
+  const senderProfile = profileReader(st);
   return {
     account,
     self() {
@@ -263,14 +311,27 @@ export function createClient(account: WhatsAppAccount): WAClient {
     },
     async start(handlers) {
       st.handlers = handlers;
+      st.watch.watch();
       try {
         await connect(st);
       } catch (e) {
-        process.stderr.write(
-          `whatsapp[${account.id}] connect failed: ${errMsg(e)}\n`,
-        );
+        process.stderr.write(`whatsapp[${account.id}] connect failed: ${errMsg(e)}\n`);
+        st.watch.failed(failureOf(e, 'connect'));
       }
     },
+    status: () => st.watch.read(),
+    read(jid, options) {
+      const page = st.history.read(jid, options);
+      for (const message of page.messages) st.keys.remember(message.key);
+      return Promise.resolve(page);
+    },
+    listMembers(jid, limit) {
+      return listMembers(jid, async (node): Promise<unknown> => await (await ready(st)).query(node), st.names, limit);
+    },
+    listChannels(args) {
+      if (st.closed) return Promise.reject(new TrainError('whatsapp_call', 'socket not connected'));
+      return st.channels.list(() => ready(st), args);
+    },
     sendText(jid, text, quotedId) {
       return send(
         st,
@@ -287,6 +348,10 @@ export function createClient(account: WhatsAppAccount): WAClient {
         quotedId ? quotedOpts(st, jid, quotedId) : undefined,
       );
     },
+    async showTyping(jid) {
+      const sock = await ready(st);
+      await sock.sendPresenceUpdate('composing', jid);
+    },
     async sendReaction(jid, messageId, emoji) {
       const target = targetKey(st.keys, jid, messageId, 'react to');
       await send(st, jid, { react: { text: emoji, key: target } });
@@ -301,18 +366,30 @@ export function createClient(account: WhatsAppAccount): WAClient {
       await send(st, jid, {
         delete: knownKey(st.keys, jid, messageId, true),
       });
+      if (!st.closed) st.history.deleteMessages({ keys: [{ remoteJid: jid, id: messageId }] });
     },
     async reuploadMedia(m) {
       const sock = await ready(st);
       return sock.updateMediaMessage(m);
     },
-    async disconnect() {
-      st.closed = true;
-      try {
-        await st.sock?.end(undefined);
-      } catch {
-        st.sock = undefined;
+    async lookupSender(number) {
+      const sock = await ready(st);
+      const found = (await sock.onWhatsApp(number))?.[0];
+      if (found?.exists !== true) return { exists: false, jid: null, lid: null };
+      const jid = jidNormalizedUser(found.jid);
+      return { exists: true, jid, lid: await lidFor(st, sock, jid) };
+    },
+    async setProfile(change) {
+      const sock = await ready(st);
+      if (change.name !== undefined) await sock.updateProfileName(change.name);
+      if (change.bio !== undefined) await sock.updateProfileStatus(change.bio);
+      if (change.avatar !== undefined) {
+        const me = sock.user?.id;
+        if (me === undefined) throw new TrainError('whatsapp_call', 'own jid unknown');
+        await sock.updateProfilePicture(me, { url: change.avatar.path });
       }
     },
+    senderProfile,
+    disconnect: () => st.closing ??= disconnect(st),
   };
 }

package/runtime/node_modules/@metro-labs/whatsapp/src/connection.ts

@@ -0,0 +1,139 @@
+import { DisconnectReason } from 'baileys';
+import { isRecord } from '@metro-labs/core/is-record';
+import { errMsg } from '@metro-labs/core/log';
+import { TrainError } from '@metro-labs/core/train-error';
+import { accountStatus, type AccountStatus } from '@metro-labs/core/stations/account-status';
+
+export const RECONNECT_GRACE_MS = 3 * 60_000;
+export const SILENT_MS = 90_000;
+const CHECK_MS = 30_000;
+
+const TERMINAL: Record<number, string> = {
+  [DisconnectReason.loggedOut]: ' — re-pair required',
+  [DisconnectReason.connectionReplaced]:
+    ' — another metro took this device; not reconnecting (two sockets on one ' +
+    'identity evict each other and risk a 463 timelock)',
+};
+
+export function terminalReason(code: number | undefined): string | undefined {
+  return code === undefined ? undefined : TERMINAL[code];
+}
+
+export const closeReason = (closed: Closed): string | undefined =>
+  terminalReason(closed.removed ? DisconnectReason.loggedOut : closed.code);
+
+export interface Closed {
+  code: number | undefined;
+  message: string;
+  removed: boolean;
+}
+
+const recordOf = (value: unknown): Record<string, unknown> => (isRecord(value) ? value : {});
+
+export function closeOf(error: unknown): Closed {
+  const boom = recordOf(error);
+  const output = recordOf(boom.output);
+  const data = recordOf(boom.data);
+  return {
+    code: typeof output.statusCode === 'number' ? output.statusCode : undefined,
+    message: error instanceof Error ? error.message : '',
+    removed: data.tag === 'conflict' && recordOf(data.attrs).type === 'device_removed',
+  };
+}
+
+export function statusAfterClose(closed: Closed, now: number): AccountStatus {
+  if (closed.removed) return accountStatus('logged_out', 'WhatsApp removed this linked device.', now);
+  if (closed.code === DisconnectReason.loggedOut) return accountStatus('logged_out', 'WhatsApp logged this device out.', now);
+  if (closed.code === DisconnectReason.connectionReplaced)
+    return accountStatus('disconnected', 'Another Metro took over this WhatsApp device, so this one stopped.', now);
+  const code = `code ${closed.code === undefined ? '?' : String(closed.code)}`;
+  return accountStatus('connecting', `The connection dropped (${closed.message === '' ? code : `${closed.message}, ${code}`}).`, now);
+}
+
+export function failureOf(e: unknown, step: 'connect' | 'reconnect'): AccountStatus {
+  if (e instanceof TrainError && e.code === 'whatsapp_auth') return accountStatus('logged_out', 'No WhatsApp link is stored for this channel.');
+  return accountStatus('disconnected', `Metro could not ${step} to WhatsApp: ${errMsg(e)}`);
+}
+
+export interface Liveness {
+  open: boolean;
+  socketOpen: boolean;
+  lastFrameAt: number;
+}
+
+function openStatus(current: AccountStatus, live: Liveness, now: number): AccountStatus {
+  const trouble = !live.socketOpen ? 'The WhatsApp connection is not open.' : now - live.lastFrameAt > SILENT_MS ? 'WhatsApp stopped answering.' : null;
+  if (trouble === null) return current.state === 'connected' ? current : accountStatus('connected', undefined, now);
+  return current.state === 'connected' ? accountStatus('connecting', trouble, now) : current;
+}
+
+export function liveStatus(current: AccountStatus, live: Liveness, now: number): AccountStatus {
+  if (current.state === 'logged_out') return current;
+  const next = live.open ? openStatus(current, live, now) : current;
+  if (next.state !== 'connecting' || now - next.since < RECONNECT_GRACE_MS) return next;
+  return accountStatus('disconnected', `${next.reason ?? 'Metro could not reach WhatsApp.'} It has not come back for 3 minutes.`, next.since + RECONNECT_GRACE_MS);
+}
+
+export class ConnectionWatch {
+  private status: AccountStatus;
+  private open = false;
+  private lastFrameAt = 0;
+  private timer: ReturnType<typeof setInterval> | null = null;
+
+  constructor(
+    private readonly accountId: string,
+    private readonly socketOpen: () => boolean,
+    now = Date.now(),
+  ) {
+    this.status = accountStatus('connecting', undefined, now);
+  }
+
+  opened(now = Date.now()): void {
+    this.open = true;
+    this.lastFrameAt = now;
+    this.enter(accountStatus('connected', undefined, now));
+  }
+
+  heard(now = Date.now()): void {
+    this.lastFrameAt = now;
+  }
+
+  closed(closed: Closed, now = Date.now()): void {
+    this.open = false;
+    const next = statusAfterClose(closed, now);
+    if (next.state !== 'connecting') this.enter(next);
+    else if (this.status.state === 'connecting') this.enter(accountStatus('connecting', next.reason, this.status.since));
+    else if (this.status.state !== 'disconnected') this.enter(next);
+  }
+
+  failed(status: AccountStatus): void {
+    this.open = false;
+    this.enter(status);
+  }
+
+  read(now = Date.now()): AccountStatus {
+    const next = liveStatus(this.status, { open: this.open, socketOpen: this.socketOpen(), lastFrameAt: this.lastFrameAt }, now);
+    if (next !== this.status) this.enter(next);
+    return this.status;
+  }
+
+  watch(): void {
+    if (this.timer !== null) return;
+    this.timer = setInterval(() => {
+      this.read();
+    }, CHECK_MS);
+    this.timer.unref();
+  }
+
+  stop(): void {
+    if (this.timer !== null) clearInterval(this.timer);
+    this.timer = null;
+  }
+
+  private enter(next: AccountStatus): void {
+    const before = this.status.state;
+    this.status = next;
+    if (before === next.state) return;
+    process.stderr.write(`whatsapp[${this.accountId}] state ${before} -> ${next.state}${next.reason === undefined ? '' : `: ${next.reason}`}\n`);
+  }
+}

package/runtime/node_modules/@metro-labs/whatsapp/src/format.ts

@@ -1,6 +1,5 @@
-import type { SavedAttachment } from '@metro-labs/mcp/stations/attachments';
 import { lineOf } from './accounts.js';
-import { mintId, SELF_URI } from './wire.js';
+import { mintId } from '@metro-labs/core/stations/station-runtime';
 import type { WAMediaRef } from './media.js';
 
 export interface InboundMessage {
@@ -13,6 +12,9 @@ export interface InboundMessage {
   isPrivate: boolean;
   pushName?: string;
   media?: WAMediaRef;
+  replyTo?: string;
+  mentionsSelf?: boolean;
+  replyToSelf?: boolean;
 }
 
 export interface ReactionInput {
@@ -38,7 +40,6 @@ function attachmentView(ref: WAMediaRef): Record<string, unknown> {
 
 export function envelope(m: InboundMessage): Record<string, unknown> {
   return {
-    kind: 'inbound',
     id: mintId(),
     ts: m.date.toISOString(),
     station: 'whatsapp',
@@ -48,6 +49,9 @@ export function envelope(m: InboundMessage): Record<string, unknown> {
     message_id: m.messageId,
     text: m.text,
     is_private: m.isPrivate,
+    ...(m.replyTo === undefined ? {} : { reply_to: m.replyTo, event: { type: 'reply', replyTo: m.replyTo } }),
+    ...(m.mentionsSelf === true ? { mentions_self: true } : {}),
+    ...(m.replyToSelf === true ? { reply_to_self: true } : {}),
     payload: {
       account: m.accountId,
       message_id: m.messageId,
@@ -56,63 +60,8 @@ export function envelope(m: InboundMessage): Record<string, unknown> {
   };
 }
 
-function mediaEvent(
-  m: InboundMessage,
-  text: string,
-  payload: Record<string, unknown>,
-): Record<string, unknown> {
-  return {
-    kind: 'inbound',
-    id: mintId(),
-    ts: new Date().toISOString(),
-    station: 'whatsapp',
-    line: lineOf(m.accountId, m.chatJid),
-    from: SELF_URI,
-    text,
-    payload: { account: m.accountId, ...payload },
-  };
-}
-
-export function attachmentSavedEnvelope(
-  m: InboundMessage,
-  sourceId: string,
-  ref: WAMediaRef,
-  saved: SavedAttachment,
-  index: number,
-): Record<string, unknown> {
-  return mediaEvent(m, `📎 saved: ${saved.path}`, {
-    contentType: 'attachmentSaved',
-    attachmentFor: sourceId,
-    index,
-    kind: ref.kind,
-    attachmentPath: saved.path,
-    localPath: saved.path,
-    mime: saved.mime,
-    name: saved.name,
-  });
-}
-
-export function attachmentFailedEnvelope(
-  m: InboundMessage,
-  sourceId: string,
-  ref: WAMediaRef,
-  index: number,
-  reason: string,
-): Record<string, unknown> {
-  return mediaEvent(m, `📎 not fetched: ${reason}`, {
-    contentType: 'attachmentFailed',
-    attachmentFor: sourceId,
-    index,
-    kind: ref.kind,
-    name: ref.name,
-    mime: ref.mime,
-    reason,
-  });
-}
-
 export function reactionEnvelope(r: ReactionInput): Record<string, unknown> {
   return {
-    kind: 'react',
     id: mintId(),
     ts: r.date.toISOString(),
     station: 'whatsapp',