@stage-labs/metro 0.1.0-beta.263 → 0.1.0-beta.265

package/runtime/node_modules/@metro-labs/daemon/src/voice/shared.ts

@@ -0,0 +1,199 @@
+import { randomUUID } from 'node:crypto';
+import { sameCall, type CallNotice, type CallRoute, type CallSource, type SpeechStatus, type SpeechTarget } from '@metro-labs/core/call';
+import { str } from '@metro-labs/core/str';
+import { log } from '@metro-labs/core/log';
+import { agentIdForLine, allowlistForLine, lineReceives, mayApprove, senderPermitted, accountFromLine } from '../agents/map.js';
+import { eventInScope } from '../agents/scope.js';
+import { harnessRunner } from '../claude/runner.js';
+import { policyFor, type Access } from '../policy/policy.js';
+
+export interface SharedSpeechAction {
+  actionId: string;
+  text: string;
+  isValid(): boolean;
+  status(status: SpeechStatus): void;
+}
+
+export interface SharedCallTransport {
+  enqueue(action: SharedSpeechAction): boolean;
+  terminate(): void;
+}
+
+export interface SpeechReceipt {
+  actionId: string;
+  sourceId: string;
+  status: SpeechStatus;
+  duplicate: boolean;
+}
+
+interface Action extends SpeechReceipt {
+  text: string;
+}
+
+interface Active {
+  route: CallRoute;
+  at: number;
+  transport: SharedCallTransport;
+  sources: Set<string>;
+  actions: Map<string, Action>;
+}
+
+export interface SharedCallBridge {
+  available(route: CallRoute): boolean;
+  notify(notice: CallNotice): boolean;
+  revoked(route: CallRoute): void;
+}
+
+const SOURCES_MAX = 1024;
+const TEXT_MAX = 32_000;
+const sourceValid = (sourceId: string): boolean => sourceId.length > 0 && sourceId.length <= 2048;
+
+const authorized = (route: CallRoute): boolean =>
+  agentIdForLine(route.line) === route.agentId && eventInScope(new Set([route.agentId]), route.line) && lineReceives(route.line) &&
+  mayApprove(route.line, route.from) && senderPermitted(allowlistForLine(route.line), route.from);
+
+function access(route: CallRoute): Access {
+  const account = accountFromLine(route.line);
+  return account === undefined ? 'deny' : policyFor({ kind: 'channel', station: account.station, account: account.accountId }, { name: 'send', group: 'write' });
+}
+
+export class SharedCalls {
+  private active: Active | null = null;
+  private bridge: SharedCallBridge | null = null;
+
+  constructor(private readonly permitted = authorized, private readonly policy = access) {}
+
+  connect(bridge: SharedCallBridge): void {
+    this.disconnect();
+    this.bridge = bridge;
+  }
+
+  disconnect(): void {
+    this.revoke();
+    this.bridge = null;
+  }
+
+  revoke(): void {
+    const active = this.active;
+    if (active !== null) this.end(active.route);
+  }
+
+  open(route: CallRoute, sourceId: string, transport: SharedCallTransport): boolean {
+    if (!this.permitted(route) || this.bridge?.available(route) !== true || !sourceValid(sourceId)) return false;
+    if (this.active !== null && sameCall(this.active.route, route)) return this.active.transport === transport && this.active.sources.has(sourceId);
+    if (this.active !== null) this.end(this.active.route);
+    this.active = { route, at: Date.now(), transport, sources: new Set([sourceId]), actions: new Map() };
+    if (this.bridge.notify({ type: 'started', route, sourceId })) return true;
+    this.end(route);
+    return false;
+  }
+
+  snapshot(): CallRoute | null {
+    const route = this.active?.route;
+    return route !== undefined && this.current(route) !== null ? route : null;
+  }
+
+  valid(source: CallSource): boolean {
+    return this.current(source.route)?.sources.has(source.sourceId) === true;
+  }
+
+  private current(route: CallRoute): Active | null {
+    const active = this.active;
+    return active !== null && sameCall(active.route, route) && this.permitted(route) && this.bridge?.available(route) === true ? active : null;
+  }
+
+  heard(route: CallRoute, text: string, sourceId: string): void {
+    if (text.trim() === '' || text.length > TEXT_MAX || !this.addSource(route, sourceId)) return;
+    if (this.bridge?.notify({ type: 'heard', route, text, sourceId }) !== true) this.end(route);
+  }
+
+  chat(event: Record<string, unknown>, scope: Set<string>): Record<string, string> {
+    const active = this.active;
+    if (active === null || event.senderVerified === false || !scope.has(active.route.agentId)) return {};
+    const { route } = active;
+    if (event.line !== route.line || event.from !== route.from || Date.parse(str(event.ts)) < active.at || !Number.isFinite(Date.parse(str(event.ts)))) return {};
+    const sourceId = str(event.messageId);
+    if (!this.addSource(route, sourceId, true)) return {};
+    return { call_id: route.callId, call_generation: route.generation, call_source_id: sourceId };
+  }
+
+  bindChat(event: Record<string, unknown>, scope: Set<string>): () => Record<string, string> {
+    const meta = this.chat(event, scope);
+    const route = this.active?.route;
+    const sourceId = meta.call_source_id;
+    return () => route !== undefined && sourceId !== undefined && this.valid({ route, sourceId }) ? meta : {};
+  }
+
+  source(line: string, target: SpeechTarget, scope: Set<string>): CallSource | null {
+    const route = this.active?.route;
+    if (route === undefined || route.line !== line || route.callId !== target.callId || route.generation !== target.generation || !scope.has(route.agentId)) return null;
+    const source = { route, sourceId: target.sourceId };
+    return this.valid(source) ? source : null;
+  }
+
+  speak(line: string, target: SpeechTarget, text: string, scope: Set<string>): SpeechReceipt {
+    const source = this.source(line, target, scope);
+    const active = this.active;
+    if (source === null || active === null) throw new Error('The call or its authorized source has ended or changed. Nothing was spoken.');
+    if (text.trim() === '' || text.length > TEXT_MAX) throw new Error('Call speech needs 1 to 32000 characters of text.');
+    const previous = active.actions.get(source.sourceId);
+    if (previous !== undefined) {
+      if (previous.text !== text) throw new Error('This source already has a different speech action. Nothing was repeated.');
+      return { actionId: previous.actionId, sourceId: previous.sourceId, status: previous.status, duplicate: true };
+    }
+    const accessAtAcceptance = this.policy(source.route);
+    if (accessAtAcceptance === 'deny') throw new Error('The owner blocked sending on this channel.');
+    const action: Action = { actionId: randomUUID(), sourceId: source.sourceId, text, status: 'accepted', duplicate: false };
+    active.actions.set(source.sourceId, action);
+    this.status(source.route, action, 'accepted');
+    const queued = active.transport.enqueue({
+      actionId: action.actionId,
+      text,
+      isValid: () => this.valid(source) && this.policy(source.route) === accessAtAcceptance,
+      status: (status) => { this.status(source.route, action, status); },
+    });
+    if (!queued) this.status(source.route, action, 'failed');
+    else if (action.status === 'accepted') this.status(source.route, action, 'queued');
+    return { actionId: action.actionId, sourceId: action.sourceId, status: action.status, duplicate: false };
+  }
+
+  end(route: CallRoute): void {
+    const active = this.active;
+    if (active === null || !sameCall(active.route, route)) return;
+    this.active = null;
+    this.bridge?.revoked(route);
+    active.transport.terminate();
+    for (const action of active.actions.values())
+      if (!this.terminal(action.status)) this.status(route, action, 'interrupted');
+    this.bridge?.notify({ type: 'ended', route });
+  }
+
+  private addSource(route: CallRoute, sourceId: string, duplicate = false): boolean {
+    const active = this.current(route);
+    if (active === null || !sourceValid(sourceId)) return false;
+    if (active.sources.has(sourceId)) return duplicate;
+    if (active.sources.size >= SOURCES_MAX) {
+      log.warn('sdk-call: the call source limit was reached; ending the call');
+      this.end(route);
+      return false;
+    }
+    active.sources.add(sourceId);
+    return true;
+  }
+
+  private terminal(status: SpeechStatus): boolean {
+    return status === 'completed' || status === 'interrupted' || status === 'failed';
+  }
+
+  private status(route: CallRoute, action: Action, status: SpeechStatus): void {
+    if (this.terminal(action.status) || (status === 'started' && action.status === 'started')) return;
+    action.status = status;
+    this.bridge?.notify({ type: 'speech', route, sourceId: action.sourceId, actionId: action.actionId, status });
+  }
+}
+
+export const sharedCalls = new SharedCalls();
+export const sharedCallsSelected = (): boolean => harnessRunner() === 'sdk';
+export const openSharedCall = (route: CallRoute, sourceId: string, transport: SharedCallTransport): boolean => sharedCalls.open(route, sourceId, transport);
+export const hearSharedCall = (route: CallRoute, text: string, sourceId: string): void => { sharedCalls.heard(route, text, sourceId); };
+export const endSharedCall = (route: CallRoute): void => { sharedCalls.end(route); };

package/runtime/node_modules/@metro-labs/daemon/src/voice/speech-queue.ts

@@ -0,0 +1,173 @@
+import type { SpeechStatus } from '@metro-labs/core/call';
+import { errMsg, log } from '@metro-labs/core/log';
+import { Player, type Playback } from './audio.js';
+import { Utterance } from './speech.js';
+import type { SharedSpeechAction } from './shared.js';
+import { voiceIdOf, type VoiceConfig } from './store.js';
+
+const MAX_QUEUED = 8;
+const MAX_TEXT = 32_000;
+const SPEECH_MS = 60_000;
+
+type Speech = Pick<Utterance, 'attach' | 'say' | 'end' | 'abort'>;
+type MakeSpeech = (failed: (reason: string) => void) => Speech;
+
+interface Playing {
+  action: SharedSpeechAction;
+  utterance: Speech | null;
+  timer: ReturnType<typeof setTimeout>;
+  synthesized: boolean;
+  started: boolean;
+}
+
+export class SpeechQueue {
+  private readonly player: Player;
+  private readonly waiting: SharedSpeechAction[] = [];
+  private current: Playing | null = null;
+  private live = false;
+  private closed = false;
+  private onFailed: () => void = () => undefined;
+
+  constructor(
+    cfg: VoiceConfig,
+    send: Playback['send'],
+    private readonly makeSpeech: MakeSpeech = (failed) => new Utterance(cfg.apiKey, voiceIdOf(cfg), failed),
+    private readonly timeoutMs = SPEECH_MS,
+  ) {
+    this.player = new Player({
+      send: (opus, timestamp, marker) => {
+        if (this.current !== null && !this.valid(this.current)) return;
+        return send(opus, timestamp, marker);
+      },
+      played: () => undefined,
+    });
+    this.player.whenFirstPlayed(() => {
+      const current = this.current;
+      if (current === null || current.started) return;
+      current.started = true;
+      current.action.status('started');
+    });
+    this.player.whenIdle(() => {
+      this.drained();
+    });
+    this.player.whenFailed((reason) => {
+      this.fail(reason);
+    });
+  }
+
+  get busy(): boolean {
+    return this.player.busy;
+  }
+
+  whenFailed(failed: () => void): void {
+    this.onFailed = failed;
+  }
+
+  enqueue(action: SharedSpeechAction): boolean {
+    if (this.closed || action.text.trim() === '' || action.text.length > MAX_TEXT) return false;
+    if (this.waiting.length + (this.current === null ? 0 : 1) >= MAX_QUEUED || !action.isValid()) return false;
+    this.waiting.push(action);
+    queueMicrotask(() => {
+      this.next();
+    });
+    return true;
+  }
+
+  connect(): void {
+    if (this.closed || this.live) return;
+    this.live = true;
+    this.player.start();
+    this.next();
+  }
+
+  cancel(): void {
+    const waiting = this.waiting.splice(0);
+    this.settle('interrupted');
+    for (const action of waiting) action.status('interrupted');
+  }
+
+  close(): void {
+    if (this.closed) return;
+    this.closed = true;
+    this.live = false;
+    this.cancel();
+    this.player.stop();
+  }
+
+  private next(): void {
+    if (!this.live || this.closed || this.current !== null) return;
+    const action = this.waiting.shift();
+    if (action === undefined) return;
+    if (!action.isValid()) {
+      action.status('failed');
+      this.next();
+      return;
+    }
+    const playing: Playing = {
+      action, utterance: null, synthesized: false, started: false,
+      timer: setTimeout(() => {
+        if (this.current === playing) this.fail('speech timed out');
+      }, this.timeoutMs),
+    };
+    this.current = playing;
+    try {
+      const utterance = this.makeSpeech((reason) => {
+        if (this.current === playing) this.fail(reason);
+      });
+      if (this.current !== playing) {
+        utterance.abort();
+        return;
+      }
+      playing.utterance = utterance;
+      utterance.attach({
+        audio: (pcm, chars) => {
+          if (this.valid(playing)) this.player.push(pcm, chars);
+        },
+        done: () => {
+          if (!this.valid(playing)) return;
+          playing.synthesized = true;
+          this.player.finish();
+          this.drained();
+        },
+      });
+      utterance.say(action.text);
+      utterance.end();
+    } catch (err) {
+      if (this.current === playing) this.fail(errMsg(err));
+    }
+  }
+
+  private valid(playing: Playing): boolean {
+    if (this.closed || this.current !== playing) return false;
+    if (playing.action.isValid()) return true;
+    this.settle('failed');
+    return false;
+  }
+
+  private drained(): void {
+    const current = this.current;
+    if (current === null || !current.synthesized || this.player.busy) return;
+    if (current.started) this.settle('completed');
+    else this.fail('no audio received');
+  }
+
+  private fail(reason: string): void {
+    log.warn({ reason }, 'voice: queued speech failed');
+    this.settle('failed');
+    this.onFailed();
+  }
+
+  private settle(status: SpeechStatus): void {
+    const current = this.current;
+    this.current = null;
+    this.player.clear();
+    if (current !== null) {
+      clearTimeout(current.timer);
+      current.utterance?.abort();
+      current.action.status(status);
+    }
+    queueMicrotask(() => {
+      this.next();
+    });
+  }
+}

package/runtime/node_modules/@metro-labs/daemon/src/voice/speech.ts

@@ -6,7 +6,7 @@ import { elevenLabs, parsed, wsText } from './scribe.js';
 
 const TTS_MODEL = 'eleven_flash_v2_5';
 
-interface Voiced {
+export interface Voiced {
   audio(pcm48k: Int16Array, chars: number): void;
   done(): void;
 }
@@ -37,10 +37,12 @@ export class Utterance {
   private aborted = false;
   private voiced = false;
   private refusal: string | null = null;
+  private finished = false;
 
-  constructor(apiKey: string, voiceId: string, failed: (reason: string) => void) {
+  constructor(apiKey: string, voiceId: string, private readonly failed: (reason: string) => void) {
     this.ws = new WebSocket(ttsUrl(voiceId), { headers: { 'xi-api-key': apiKey } });
     this.ws.on('open', () => {
+      if (this.aborted) return;
       this.ws.send(JSON.stringify({ text: ' ' }));
       for (const line of this.outbox.splice(0)) this.ws.send(line);
     });
@@ -48,15 +50,14 @@ export class Utterance {
       this.onMessage(wsText(data));
     });
     this.ws.on('error', (err) => {
+      if (this.aborted || this.finished) return;
       this.refusal ??= errMsg(err);
       log.warn({ err: errMsg(err) }, 'voice: text to speech connection error');
     });
     this.ws.on('close', (code, why) => {
       this.closed = true;
-      this.listener?.done();
-      this.listener = null;
       const reason = this.refusal ?? (code === 1000 ? null : (why.toString() || `closed (${String(code)})`));
-      if (!this.aborted && !this.voiced && reason !== null) failed(reason.slice(0, MAX_REASON));
+      this.complete(reason);
     });
   }
 
@@ -65,7 +66,7 @@ export class Utterance {
   }
 
   attach(listener: Voiced): void {
-    this.listener = listener;
+    if (!this.aborted && !this.finished) this.listener = listener;
   }
 
   say(text: string): void {
@@ -77,28 +78,52 @@ export class Utterance {
   }
 
   abort(): void {
+    if (this.aborted) return;
     this.aborted = true;
     this.listener = null;
+    this.outbox.length = 0;
     this.ws.terminate();
   }
 
+  private complete(reason: string | null): void {
+    if (this.aborted || this.finished) return;
+    this.finished = true;
+    const listener = this.listener;
+    this.listener = null;
+    this.outbox.length = 0;
+    const failure = reason ?? (listener !== null && !this.voiced ? 'no audio received' : null);
+    if (failure !== null) this.failed(failure.slice(0, MAX_REASON));
+    else listener?.done();
+  }
+
   private post(msg: Record<string, unknown>): void {
+    if (this.aborted || this.closed || this.finished) return;
     const line = JSON.stringify(msg);
     if (this.ws.readyState === WebSocket.OPEN) this.ws.send(line);
     else this.outbox.push(line);
   }
 
+  private refused(msg: Record<string, unknown>, raw: string): void {
+    if (typeof msg.message === 'string' && msg.message !== '') this.refusal ??= msg.message;
+    log.warn({ msg: raw.slice(0, MAX_REASON) }, 'voice: text to speech said');
+  }
+
+  private audio(encoded: string, chars: number): void {
+    this.voiced = true;
+    const pcm = pcmOf(Buffer.from(encoded, 'base64'));
+    const up = upsample2(pcm, this.carry);
+    this.carry = pcm.at(-1) ?? this.carry;
+    this.listener?.audio(up, chars);
+  }
+
   private onMessage(raw: string): void {
+    if (this.aborted || this.finished) return;
     const msg = parsed(raw);
-    if (typeof msg.audio === 'string' && msg.audio !== '') {
-      this.voiced = true;
-      const pcm = pcmOf(Buffer.from(msg.audio, 'base64'));
-      const up = upsample2(pcm, this.carry);
-      this.carry = pcm.at(-1) ?? this.carry;
-      this.listener?.audio(up, charsOf(msg));
-    } else if (msg.isFinal !== true) {
-      if (typeof msg.message === 'string' && msg.message !== '') this.refusal ??= msg.message;
-      log.warn({ msg: raw.slice(0, MAX_REASON) }, 'voice: text to speech said');
+    if (typeof msg.audio === 'string' && msg.audio !== '') this.audio(msg.audio, charsOf(msg));
+    else if (msg.isFinal !== true) this.refused(msg, raw);
+    if (this.refusal !== null || msg.isFinal === true) {
+      this.complete(this.refusal);
+      this.ws.close(1000);
     }
   }
 }

package/runtime/node_modules/@metro-labs/daemon/src/voice/talk.ts

@@ -58,7 +58,7 @@ export class Talk implements Thinking {
 
   constructor(
     private readonly cfg: VoiceConfig,
-    out: (opus: Buffer, timestamp: number, marker: boolean) => void,
+    out: Playback['send'],
     private readonly ended: (reason: string) => void,
     private readonly approvals: CallApprovals,
   ) {
@@ -72,6 +72,9 @@ export class Talk implements Thinking {
     this.player.whenFirstPlayed(() => {
       this.firstPlayed();
     });
+    this.player.whenFailed((reason) => {
+      if (!this.finished) this.ended(`audio playback failed: ${reason}`);
+    });
     this.brain = new Brain(brainModel(cfg), this);
     this.scribe = new Scribe(cfg.apiKey, languageOf(cfg), {
       partial: (text) => {
@@ -88,10 +91,11 @@ export class Talk implements Thinking {
   }
 
   prime(context: string): void {
-    this.brain.tell(context);
+    if (!this.finished) this.brain.tell(context);
   }
 
   connect(): void {
+    if (this.finished || this.live) return;
     this.live = true;
     this.spare ??= this.utterance();
     this.player.start();
@@ -118,8 +122,8 @@ export class Talk implements Thinking {
   }
 
   turnStarted(): void {
-    this.muted = false;
     if (this.finished) return;
+    this.muted = false;
     this.reply = {
       utterance: this.takeUtterance(),
       said: '',
@@ -137,19 +141,20 @@ export class Talk implements Thinking {
 
   text(delta: string): void {
     const reply = this.reply;
-    if (this.muted || reply === null) return;
+    if (this.finished || this.muted || reply === null) return;
     reply.firstText ??= performance.now();
     this.speak(reply, reply.chunker.add(delta));
   }
 
   tool(name: string): void {
+    if (this.finished) return;
     log.info({ tool: name }, 'voice: the agent uses a tool during the call');
     if (this.reply !== null && !this.muted) this.speak(this.reply, this.reply.chunker.flush());
   }
 
   turnEnded(): void {
     const reply = this.reply;
-    if (reply === null || this.muted) return;
+    if (this.finished || reply === null || this.muted) return;
     this.speak(reply, reply.chunker.flush());
     reply.utterance.end();
     log.info(
@@ -171,6 +176,7 @@ export class Talk implements Thinking {
   }
 
   exited(reason: string): void {
+    if (this.finished) return;
     log.warn({ reason }, 'voice: the agent session for the call ended');
     this.ended(`agent session ${reason}`);
   }
@@ -183,13 +189,13 @@ export class Talk implements Thinking {
     ready.attach({
       audio: (pcm, chars) => {
         const current = reply();
-        if (current?.utterance !== ready) return;
+        if (this.finished || this.muted || current?.utterance !== ready) return;
         this.spoke = true;
         current.firstAudio ??= performance.now();
         this.player.push(pcm, chars);
       },
       done: () => {
-        this.player.finish();
+        if (!this.finished && !this.muted && this.reply?.utterance === ready) this.player.finish();
       },
     });
     return ready;
@@ -239,11 +245,13 @@ export class Talk implements Thinking {
   }
 
   private partial(text: string): void {
+    if (this.finished) return;
     if (text !== '') this.lastHeardAt = performance.now();
     if (this.interrupts(text)) this.cutOff();
   }
 
   private committed(text: string): void {
+    if (this.finished) return;
     if (this.interrupts(text)) this.cutOff();
     const note = this.cut;
     const now = this.muted;

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

@@ -8,7 +8,7 @@ import {
   type StationHandler,
 } from '@metro-labs/core/stations/station-runtime';
 import { messagingAliases } from '@metro-labs/core/stations/messaging-normalize';
-import { accountFor, accounts, targetOf } from './accounts.js';
+import { accountFor, accounts, lineOf, targetOf } from './accounts.js';
 import { phoneNumberOf, senderLookup } from './resolve.js';
 import { assertImage, fieldsOf, parseProfileChange, type ProfileApplied } from '@metro-labs/core/stations/profile';
 import type { WAClient } from './client.js';
@@ -117,6 +117,35 @@ function makeSend(clientFor: ClientFor): StationHandler {
   };
 }
 
+function makeRead(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const { accountId, client, jid } = resolve(args, clientFor);
+    const page = await guard(() => client.read(jid, {
+      limit: typeof args.limit === 'number' ? args.limit : undefined,
+      before: str(args.before),
+      since: str(args.since),
+    }));
+    const messages = page.messages.map((row) => ({
+      id: row.messageId,
+      ts: row.timestamp,
+      ...(row.senderJid ? { from: lineOf(accountId, `user/${row.senderJid}`) } : {}),
+      self: row.fromMe,
+      text: row.text,
+      ...(row.truncated ? { truncated: true } : {}),
+      ...(row.attachments ? { attachments: row.attachments } : {}),
+    }));
+    respond(id, { result: { ...page, line: lineOf(accountId, jid), account: accountId, messages } });
+  };
+}
+
+function makeListMembers(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const { client, jid } = resolve({ line: args.line }, clientFor);
+    const result = await guard(() => client.listMembers(jid, typeof args.limit === 'number' ? args.limit : undefined));
+    respond(id, { result });
+  };
+}
+
 function makeReact(clientFor: ClientFor): StationHandler {
   return async (id, args) => {
     const { accountId, client, jid } = resolve(args, clientFor);
@@ -208,6 +237,8 @@ export function makeHandleCall(
     handlers: {
       accounts: makeAccounts(clientFor),
       send: makeSend(clientFor),
+      read: makeRead(clientFor),
+      listMembers: makeListMembers(clientFor),
       react: makeReact(clientFor),
       typing: makeTyping(clientFor),
       edit: makeEdit(clientFor),

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

@@ -0,0 +1,49 @@
+import { errMsg, log } from '@metro-labs/core/log';
+import { isPnUser, isLidUser, makeEventBuffer, processSyncAction, type BaileysEventEmitter, type Contact } from 'baileys';
+import type { History } from './history.js';
+import { baileysLogger } from './logger.js';
+
+interface AppStateHooks {
+  history: History;
+  current(): boolean;
+}
+
+export function supportsHistoryDeletion(processAction = processSyncAction): boolean {
+  const ev = makeEventBuffer(baileysLogger('history-support'));
+  const id = 'history-support@g.us';
+  const messageRange = { lastMessageTimestamp: 1 };
+  let received = 0;
+  ev.on('chats.clear', (event) => {
+    if (event.id === id && event.messageRange === messageRange) received++;
+  });
+  try {
+    for (const initial of [false, true]) {
+      for (const type of ['clearChat', 'deleteChat']) {
+        const value = type === 'clearChat' ? { clearChatAction: { messageRange } } : { deleteChatAction: { messageRange } };
+        const before = received;
+        processAction({ index: [type, id], syncAction: { value } }, ev, { id }, initial ? { accountSettings: { unarchiveChats: false } } : undefined);
+        if (received !== before + 1) return false;
+      }
+    }
+    return true;
+  } catch (err) {
+    log.warn({ err: errMsg(err) }, 'whatsapp: local history deletion support check failed');
+    return false;
+  }
+}
+
+export function noteHistoryContact(history: History, contact: Partial<Contact>): void {
+  const pn = contact.phoneNumber ?? (isPnUser(contact.id) ? contact.id : undefined);
+  const lid = contact.lid ?? (isLidUser(contact.id) ? contact.id : undefined);
+  if (pn && lid) history.alias(pn, lid);
+}
+
+export function bindAppState(ev: BaileysEventEmitter, hooks: AppStateHooks): void {
+  ev.on('lid-mapping.update', ({ pn, lid }) => {
+    if (hooks.current()) hooks.history.alias(pn, lid);
+  });
+  ev.on('chats.clear', ({ id, messageRange }) => {
+    if (!hooks.current()) return;
+    hooks.history.clearRange(id, messageRange ?? {});
+  });
+}