@stage-labs/metro 0.1.0-beta.3 → 0.1.0-beta.300

package/runtime/node_modules/@metro-labs/xmtp/src/call-leftovers.ts

@@ -0,0 +1,48 @@
+import type { DecodedMessage } from '@xmtp/node-sdk';
+import { isRecord } from '@metro-labs/core/is-record';
+import { TrainError } from '@metro-labs/core/train-error';
+import { respond } from '@metro-labs/core/stations/station-runtime';
+import { accounts, lineOf, type Account } from './accounts.js';
+import { isCallSignal } from './codecs.js';
+
+const RECENT_MS = 24 * 60 * 60_000;
+const STAGE_HISTORY = 100;
+
+interface Leftover {
+  line: string;
+  callId: string;
+  peer: string;
+}
+
+function ownSignal(acct: Account, m: DecodedMessage): Record<string, unknown> | null {
+  if (m.senderInboxId !== acct.inboxId || !isCallSignal(m)) return null;
+  return isRecord(m.content) ? m.content : null;
+}
+
+function openJoins(acct: Account, line: string, messages: DecodedMessage[]): Leftover[] {
+  const open = new Map<string, string>();
+  for (const m of messages) {
+    const signal = ownSignal(acct, m);
+    if (signal === null || typeof signal.from !== 'string' || typeof signal.callId !== 'string') continue;
+    if (signal.kind === 'join') open.set(signal.from, signal.callId);
+    else if (signal.kind === 'leave') open.delete(signal.from);
+  }
+  return [...open].map(([peer, callId]) => ({ line, callId, peer }));
+}
+
+async function leftoversOf(acct: Account, sinceNs: bigint): Promise<Leftover[]> {
+  const found: Leftover[] = [];
+  for (const conv of await acct.client.conversations.list()) {
+    const newestFirst = await conv.messages({ sentAfterNs: sinceNs, direction: 1, limit: STAGE_HISTORY });
+    found.push(...openJoins(acct, lineOf(acct.cfg.id, conv.id), newestFirst.reverse()));
+  }
+  return found;
+}
+
+export async function callLeftovers(id: string): Promise<void> {
+  if (accounts.size === 0) throw new TrainError('UNAVAILABLE', 'no XMTP account is ready yet');
+  const sinceNs = BigInt(Date.now() - RECENT_MS) * 1_000_000n;
+  const calls: Leftover[] = [];
+  for (const acct of accounts.values()) calls.push(...(await leftoversOf(acct, sinceNs)));
+  respond(id, { result: { calls } });
+}

package/runtime/node_modules/@metro-labs/xmtp/src/channels.ts

@@ -0,0 +1,56 @@
+import {
+  ChannelDirectory,
+  DIRECTORY_LIMIT,
+  type ChannelSnapshot,
+} from '@metro-labs/core/stations/channel-directory';
+import { respond } from '@metro-labs/core/stations/station-runtime';
+import { TrainError } from '@metro-labs/core/train-error';
+import { ListConversationsOrderBy, type ListConversationsOptions } from '@xmtp/node-sdk';
+import { accountForCall, lineOf, type Account } from './accounts.js';
+import { syncConversations } from './network.js';
+
+interface ConversationMetadata {
+  id: string;
+  name?: string;
+}
+
+interface ConversationSource {
+  sync: () => Promise<unknown>;
+  list: (options: ListConversationsOptions) => Promise<ConversationMetadata[]>;
+}
+
+const directories = new WeakMap<Account, ChannelDirectory>();
+
+export async function loadChannels(account: string, source: ConversationSource): Promise<ChannelSnapshot> {
+  await syncConversations(source);
+  const conversations = await source.list({
+    limit: DIRECTORY_LIMIT + 1,
+    includeDuplicateDms: false,
+    orderBy: ListConversationsOrderBy.CreatedAt,
+  });
+  return {
+    channels: conversations.slice(0, DIRECTORY_LIMIT + 1).map((conversation) => ({
+      id: conversation.id,
+      line: lineOf(account, conversation.id),
+      ...('name' in conversation && conversation.name ? { name: conversation.name } : {}),
+      kind: 'name' in conversation ? 'group' : 'direct',
+    })),
+    capability: {
+      supported: true,
+      complete: false,
+      source: 'mixed',
+      reason: 'Only conversations known to this XMTP installation are listed; other devices may know more. Group names use locally stored metadata.' +
+        (conversations.length > DIRECTORY_LIMIT ? ` Results are limited to ${DIRECTORY_LIMIT} conversations.` : ''),
+    },
+  };
+}
+
+export async function listChannels(id: string, args: Record<string, unknown>): Promise<void> {
+  if (typeof args.account !== 'string' || !args.account.trim())
+    throw new TrainError('INVALID_ARGS', 'listChannels requires an account');
+  const acct = accountForCall({ account: args.account });
+  const directory = directories.get(acct) ?? new ChannelDirectory();
+  directories.set(acct, directory);
+  const result = await directory.list(acct.cfg.id, args, () => loadChannels(acct.cfg.id, acct.client.conversations));
+  respond(id, { result });
+}

package/runtime/node_modules/@metro-labs/xmtp/src/codecs.ts

@@ -0,0 +1,282 @@
+import type {
+  ContentTypeId,
+  ContentCodec,
+  EncodedContent,
+} from '@xmtp/content-type-primitives';
+
+const enc = (o: unknown): Uint8Array =>
+  new TextEncoder().encode(JSON.stringify(o));
+const dec = (e: EncodedContent): unknown =>
+  JSON.parse(new TextDecoder().decode(e.content));
+
+const makeJsonCodec = <T>(
+  contentType: ContentTypeId,
+  fallbackFn: (c: T) => string | undefined,
+  push = true,
+) =>
+  class {
+    get contentType() {
+      return contentType;
+    }
+    encode(c: T): EncodedContent {
+      const fallback = fallbackFn(c);
+      return {
+        type: contentType,
+        parameters: {},
+        ...(fallback === undefined ? {} : { fallback }),
+        content: enc(c),
+      };
+    }
+    decode(e: EncodedContent): T {
+      return dec(e) as T;
+    }
+    fallback(c: T) {
+      return fallbackFn(c);
+    }
+    shouldPush() {
+      return push;
+    }
+  };
+
+export const ContentTypePoll: ContentTypeId = {
+  authorityId: 'metro.box',
+  typeId: 'poll',
+  versionMajor: 1,
+  versionMinor: 0,
+};
+export interface PollOption {
+  label: string;
+  description?: string;
+}
+export interface PollQuestion {
+  question: string;
+  header?: string;
+  multiSelect?: boolean;
+  open?: boolean;
+  options?: (PollOption | string)[];
+}
+export interface PollContent {
+  questions?: PollQuestion[];
+  question?: string;
+  header?: string;
+  multiSelect?: boolean;
+  pollId?: string;
+  options?: (PollOption | string)[];
+  [k: string]: unknown;
+}
+const pollTitle = (c: PollContent): string =>
+  c.questions?.[0]?.question ?? c.question ?? 'Poll';
+export const PollCodec = makeJsonCodec<PollContent>(
+  ContentTypePoll,
+  (c) => `📊 Poll: ${pollTitle(c)}`,
+);
+
+const normOpts = (o: (string | PollOption)[]): PollOption[] =>
+  o.map((x) =>
+    typeof x === 'string'
+      ? { label: x }
+      : { label: x.label, description: x.description },
+  );
+
+export function buildPollContent(
+  args: Record<string, unknown>,
+  pollId: string,
+): { poll: PollContent; title: string } {
+  const { question, options, header, multiSelect, questions } = args as {
+    question?: string;
+    options?: (string | PollOption)[];
+    header?: string;
+    multiSelect?: boolean;
+    questions?: PollQuestion[];
+  };
+  if (Array.isArray(questions) && questions.length > 0) {
+    const norm: PollQuestion[] = questions.map((q, i) => {
+      if (!q || typeof q.question !== 'string' || !q.question)
+        throw new Error(`ask questions[${i}] requires a question`);
+      const open = q.open === true;
+      const opts = Array.isArray(q.options) ? q.options : [];
+      if (!open && opts.length === 0)
+        throw new Error(
+          `ask questions[${i}] requires a non-empty options array (or open:true for free-text)`,
+        );
+      return {
+        question: q.question,
+        options: normOpts(opts),
+        multiSelect: !!q.multiSelect,
+        ...(open ? { open: true } : {}),
+        ...(q.header ? { header: q.header } : {}),
+      };
+    });
+    const first = norm[0];
+    if (!first) throw new Error('ask requires at least one question');
+    return { poll: { questions: norm, pollId }, title: first.question };
+  }
+  if (!question || typeof question !== 'string')
+    throw new Error('ask requires a question (or a questions[] array)');
+  if (!Array.isArray(options) || options.length === 0)
+    throw new Error('ask requires a non-empty options array');
+  return {
+    poll: {
+      question,
+      options: normOpts(options),
+      multiSelect: !!multiSelect,
+      pollId,
+      ...(header ? { header } : {}),
+    },
+    title: question,
+  };
+}
+
+export const ContentTypeSignatureRequest: ContentTypeId = {
+  authorityId: 'metro.box',
+  typeId: 'signatureRequest',
+  versionMajor: 1,
+  versionMinor: 0,
+};
+export interface SignatureRequestContent {
+  id?: string;
+  kind?: 'eip712' | 'personal';
+  eip712?: unknown;
+  message?: string;
+  description?: string;
+  [k: string]: unknown;
+}
+export const SignatureRequestCodec = makeJsonCodec<SignatureRequestContent>(
+  ContentTypeSignatureRequest,
+  (c) =>
+    c.description
+      ? `[Signature request] ${c.description}`
+      : '[Signature request]',
+);
+
+export const ContentTypeSignatureReference: ContentTypeId = {
+  authorityId: 'metro.box',
+  typeId: 'signatureReference',
+  versionMajor: 1,
+  versionMinor: 0,
+};
+export interface SignatureReferenceContent {
+  requestId?: string;
+  signature: string;
+  signer?: string;
+  [k: string]: unknown;
+}
+export const SignatureReferenceCodec =
+  makeJsonCodec<SignatureReferenceContent>(ContentTypeSignatureReference, (c) =>
+    c.signature ? `[Signature] ${c.signature}` : '[Signature]',
+  );
+
+const xmtpOrg = (typeId: string): ContentTypeId => ({
+  authorityId: 'xmtp.org',
+  typeId,
+  versionMajor: 1,
+  versionMinor: 0,
+});
+export const WalletSendCallsCodec = makeJsonCodec<{ calls?: { metadata?: { description?: string } }[] }>(
+  xmtpOrg('walletSendCalls'),
+  (c) => {
+    const desc = c.calls?.[0]?.metadata?.description;
+    return desc ? `[Transaction request] ${desc}` : '[Transaction request]';
+  },
+);
+export const TransactionReferenceCodec = makeJsonCodec<{ reference?: string }>(
+  xmtpOrg('transactionReference'),
+  (c) => (c.reference ? `[Transaction] ${c.reference}` : '[Transaction]'),
+);
+
+export const ContentTypeFrame: ContentTypeId = {
+  authorityId: 'stage.box',
+  typeId: 'frame',
+  versionMajor: 1,
+  versionMinor: 0,
+};
+export interface FrameContent {
+  title?: string;
+  description?: string;
+  widget?: Record<string, unknown>;
+  screens?: Record<string, unknown>;
+  start?: string;
+  source?: { url: string };
+}
+export const frameFallback = (c: FrameContent): string => {
+  const head = c.title ? `Frame: ${c.title}` : 'Frame';
+  return c.description ? `${head}\n${c.description}` : head;
+};
+export const FrameCodec = makeJsonCodec<FrameContent>(ContentTypeFrame, frameFallback);
+
+export const ContentTypeFrameAction: ContentTypeId = {
+  authorityId: 'stage.box',
+  typeId: 'frameAction',
+  versionMajor: 1,
+  versionMinor: 0,
+};
+export interface FrameActionContent {
+  frameId: string;
+  action: { type: string; payload?: Record<string, unknown> };
+  label?: string;
+}
+export const frameActionText = (c: FrameActionContent): string => {
+  const payload = c.action.payload === undefined ? '' : ` ${JSON.stringify(c.action.payload)}`;
+  return `Frame action: ${c.action.type}${payload}`;
+};
+const FrameActionCodec = makeJsonCodec<FrameActionContent>(ContentTypeFrameAction, frameActionText);
+
+export const ContentTypeDeleteRequest: ContentTypeId = {
+  authorityId: 'stage.box',
+  typeId: 'deleteRequest',
+  versionMajor: 1,
+  versionMinor: 0,
+};
+const DeleteRequestCodec = makeJsonCodec<{ messageId: string }>(ContentTypeDeleteRequest, () => 'Message deleted');
+
+const ContentTypeDeleteMessage: ContentTypeId = {
+  authorityId: 'xmtp.org',
+  typeId: 'deleteMessage',
+  versionMajor: 1,
+  versionMinor: 0,
+};
+
+const varint = (value: number): number[] => {
+  const out: number[] = [];
+  let rest = value;
+  while (rest > 0x7f) {
+    out.push((rest & 0x7f) | 0x80);
+    rest = Math.floor(rest / 0x80);
+  }
+  out.push(rest);
+  return out;
+};
+
+export function encodeDeleteMessage(messageId: string): EncodedContent {
+  const id = new TextEncoder().encode(messageId);
+  return {
+    type: ContentTypeDeleteMessage,
+    parameters: {},
+    content: new Uint8Array([0x0a, ...varint(id.length), ...id]),
+  };
+}
+
+export const CALL_TYPES = new Set(['callInvite', 'callSignal']);
+const callContentType = (typeId: string): ContentTypeId => ({
+  authorityId: 'stage.box',
+  typeId,
+  versionMajor: 1,
+  versionMinor: 0,
+});
+const CallInviteCodec = makeJsonCodec<{ video?: unknown }>(callContentType('callInvite'), (c) =>
+  c.video === true ? '📞 Video call' : '📞 Voice call',
+);
+export const isCallSignal = (m: { contentType?: ContentTypeId }): boolean =>
+  m.contentType?.authorityId === 'stage.box' && m.contentType.typeId === 'callSignal';
+export const CallSignalCodec = makeJsonCodec<Record<string, unknown>>(callContentType('callSignal'), () => undefined, false);
+
+export const CODECS = (): ContentCodec[] => [
+  new PollCodec(),
+  new SignatureRequestCodec(),
+  new SignatureReferenceCodec(),
+  new FrameCodec(),
+  new FrameActionCodec(),
+  new DeleteRequestCodec(),
+  new CallInviteCodec(),
+  new CallSignalCodec(),
+];

package/runtime/node_modules/@metro-labs/xmtp/src/conv-helpers.ts

@@ -0,0 +1,254 @@
+import { IdentifierKind } from '@xmtp/node-sdk';
+import { convOf, type Account } from './accounts.js';
+import { inboxEthCache, cacheInboxEth } from './wire.js';
+import { TrainError } from '@metro-labs/core/train-error';
+import type { MemberList, MetroMember } from '@metro-labs/core/stations/types';
+import { readAppData, readAppDataObject, type GroupLike } from './labels.js';
+import { network, syncConversation } from './network.js';
+
+export { parseMemberArgs, resolveMembers } from './member-args.js';
+
+type Conv = Awaited<ReturnType<typeof convOf>>['conv'] & object;
+export interface EthId {
+  identifier: string;
+  identifierKind: IdentifierKind;
+}
+
+export function ethIdentifiers(addrs: string[]): EthId[] {
+  return addrs.map((a) => ({
+    identifier: a,
+    identifierKind: IdentifierKind.Ethereum,
+  }));
+}
+
+export async function createGroupWithMembers(
+  acct: Account,
+  addrs: string[],
+  inboxes: string[],
+  opts: { groupName: string; groupDescription?: string; appData?: string },
+): Promise<GroupLike> {
+  if (!addrs.length)
+    return acct.client.conversations.createGroup(inboxes, opts);
+  const created = await acct.client.conversations.createGroupWithIdentifiers(
+    ethIdentifiers(addrs),
+    opts,
+  );
+  if (inboxes.length)
+    await (
+      created as unknown as { addMembers: (ids: string[]) => Promise<unknown> }
+    ).addMembers(inboxes);
+  return created;
+}
+
+export async function resolveAddresses(
+  acct: Account,
+  inboxIds: string[],
+): Promise<Record<string, string>> {
+  const addresses: Record<string, string> = {};
+  const missing = inboxIds.filter((iid) => {
+    const cached = inboxEthCache.get(iid);
+    if (cached) {
+      addresses[iid] = cached;
+      return false;
+    }
+    return true;
+  });
+  if (!missing.length) return addresses;
+  try {
+    const states = await acct.client.preferences.fetchInboxStates(missing);
+    for (let i = 0; i < missing.length; i++) {
+      const key = missing[i];
+      if (key === undefined) continue;
+      const eth = states[i]?.identifiers.find(
+        (it: { identifierKind: IdentifierKind }) =>
+          it.identifierKind === IdentifierKind.Ethereum,
+      );
+      if (eth?.identifier) {
+        addresses[key] = eth.identifier;
+        cacheInboxEth(key, eth.identifier);
+      }
+    }
+  } catch (error) {
+    network.note(error);
+    if (network.remaining() > 0) throw error;
+    return addresses;
+  }
+  return addresses;
+}
+
+export async function buildGroupInfo(
+  line: string,
+  acct: Account,
+  conv: Conv,
+): Promise<Record<string, unknown>> {
+  await syncConversation(acct.client, conv);
+  const rawAppData = (conv as unknown as GroupLike).appData ?? '';
+  const appData = readAppDataObject(rawAppData);
+  const members = await conv.members();
+  const inboxIds = members.map((m) => m.inboxId);
+  const addresses = memberAddresses(members);
+  const isDm =
+    typeof (conv as unknown as { peerInboxId?: unknown }).peerInboxId ===
+    'function';
+  const gn = (conv as unknown as { name?: string | (() => Promise<string>) })
+    .name;
+  const resolvedName = typeof gn === 'function' ? await gn() : (gn ?? '');
+  const { labels, category, status, priority, github, preview } = readAppData(rawAppData);
+  return {
+    line,
+    id: conv.id,
+    account: acct.cfg.id,
+    version: isDm ? 'dm' : 'group',
+    name: resolvedName ?? '',
+    memberCount: inboxIds.length,
+    labels,
+    category,
+    status,
+    priority,
+    github,
+    preview,
+    assigned: Object.hasOwn(appData, 'assigned') ? appData.assigned : [],
+    appData,
+    rawAppData,
+    members: inboxIds.map((iid) => ({
+      inboxId: iid,
+      address: addresses[iid] ?? null,
+    })),
+  };
+}
+
+interface RawMember {
+  inboxId: string;
+  permissionLevel?: number;
+  accountIdentifiers?: EthId[];
+}
+
+function memberAddresses(members: RawMember[]): Record<string, string> {
+  const addresses: Record<string, string> = {};
+  for (const member of members) {
+    const eth = member.accountIdentifiers?.find((id) => id.identifierKind === IdentifierKind.Ethereum);
+    if (eth) addresses[member.inboxId] = eth.identifier;
+  }
+  return addresses;
+}
+
+function toMetroMember(
+  m: RawMember,
+  addresses: Record<string, string>,
+): MetroMember {
+  const member: MetroMember = { id: m.inboxId };
+  const address = addresses[m.inboxId];
+  if (address) member.address = address;
+  if (typeof m.permissionLevel === 'number')
+    member.is_admin = m.permissionLevel >= 1;
+  return member;
+}
+
+export async function buildMemberList(conv: Conv): Promise<MemberList> {
+  const raw = await conv.members();
+  const addresses = memberAddresses(raw);
+  return {
+    members: raw.map((m) => toMetroMember(m, addresses)),
+    capability: { supported: true, complete: true, total: raw.length },
+  };
+}
+
+interface MemberGroup {
+  sync?: () => Promise<unknown>;
+  addMembers?: (ids: string[]) => Promise<unknown>;
+  addMembersByIdentifiers?: (ids: EthId[]) => Promise<unknown>;
+  removeMembers?: (ids: string[]) => Promise<unknown>;
+  removeMembersByIdentifiers?: (ids: EthId[]) => Promise<unknown>;
+}
+
+async function applyByIdentifiers(
+  group: MemberGroup,
+  byIdent: ((ids: EthId[]) => Promise<unknown>) | undefined,
+  addrs: string[],
+  verb: string,
+): Promise<void> {
+  if (!addrs.length) return;
+  if (typeof byIdent !== 'function')
+    throw new TrainError(
+      'INVALID_ARGS',
+      `group does not support ${verb}ByIdentifiers; pass inboxIds instead`,
+    );
+  await byIdent.call(group, ethIdentifiers(addrs));
+}
+
+async function applyByInboxId(
+  group: MemberGroup,
+  byId: ((ids: string[]) => Promise<unknown>) | undefined,
+  inboxes: string[],
+  verb: string,
+): Promise<void> {
+  if (!inboxes.length) return;
+  if (typeof byId !== 'function')
+    throw new TrainError(
+      'INVALID_ARGS',
+      `group does not support ${verb} by inboxId`,
+    );
+  await byId.call(group, inboxes);
+}
+
+export async function applyMemberOp(
+  conv: Conv,
+  addrs: string[],
+  inboxes: string[],
+  mode: 'add' | 'remove',
+): Promise<void> {
+  const group = conv as unknown as MemberGroup;
+  const byId = mode === 'add' ? group.addMembers : group.removeMembers;
+  const byIdent =
+    mode === 'add'
+      ? group.addMembersByIdentifiers
+      : group.removeMembersByIdentifiers;
+  const verb = mode === 'add' ? 'addMembers' : 'removeMembers';
+  if (typeof byId !== 'function' && typeof byIdent !== 'function')
+    throw new TrainError(
+      'INVALID_ARGS',
+      `${verb} target is not a group (no ${verb})`,
+    );
+  await group.sync?.();
+  await applyByIdentifiers(group, byIdent, addrs, verb);
+  await applyByInboxId(group, byId, inboxes, verb);
+}
+
+const NAME_CACHE_MAX = 5000;
+const convNameCache = new Map<string, string>();
+
+function remember(convId: string, name: string): void {
+  convNameCache.delete(convId);
+  convNameCache.set(convId, name);
+  if (convNameCache.size > NAME_CACHE_MAX) {
+    const oldest = convNameCache.keys().next().value;
+    if (oldest !== undefined) convNameCache.delete(oldest);
+  }
+}
+
+async function readName(conv: unknown): Promise<string> {
+  try {
+    if (typeof (conv as { peerInboxId?: unknown }).peerInboxId === 'function')
+      return '';
+    const n = (conv as { name?: string | (() => Promise<string>) }).name;
+    const resolved = typeof n === 'function' ? await n() : n;
+    return typeof resolved === 'string' ? resolved : '';
+  } catch {
+    return '';
+  }
+}
+
+export async function groupNameFor(
+  convId: string,
+  conv: unknown,
+): Promise<string> {
+  const cached = convNameCache.get(convId);
+  if (cached !== undefined) return cached;
+  const name = await readName(conv);
+  remember(convId, name);
+  return name;
+}
+
+export function warmGroupName(convId: string, name: string | undefined): void {
+  if (typeof name === 'string' && name) remember(convId, name);
+}

package/runtime/node_modules/@metro-labs/xmtp/src/delete-requests.ts

@@ -0,0 +1,34 @@
+import type { DecodedMessage } from '@xmtp/node-sdk';
+import { ContentTypeDeleteRequest } from './codecs.js';
+
+type Listed = Pick<DecodedMessage, 'id' | 'senderInboxId' | 'contentType' | 'content'>;
+
+export const isDeleteRequest = (m: Pick<Listed, 'contentType'>): boolean =>
+  m.contentType?.authorityId === ContentTypeDeleteRequest.authorityId &&
+  m.contentType.typeId === ContentTypeDeleteRequest.typeId;
+
+function targetOf(m: Listed): string | undefined {
+  if (!isDeleteRequest(m)) return undefined;
+  const id = (m.content as { messageId?: unknown } | undefined)?.messageId;
+  return typeof id === 'string' && id ? id : undefined;
+}
+
+export function superAdminCheck(conv: unknown): (inboxId: string) => boolean {
+  const group = conv as { isSuperAdmin?: (inboxId: string) => boolean };
+  return (inboxId) => typeof group.isSuperAdmin === 'function' && group.isSuperAdmin(inboxId);
+}
+
+export function deletedByRequests(
+  messages: Listed[],
+  isSuperAdmin: (inboxId: string) => boolean,
+): Set<string> {
+  const senders = new Map(messages.map((m) => [m.id, m.senderInboxId]));
+  const deleted = new Set<string>();
+  for (const m of messages) {
+    const target = targetOf(m);
+    const sender = target === undefined ? undefined : senders.get(target);
+    if (target !== undefined && sender !== undefined && (sender === m.senderInboxId || isSuperAdmin(m.senderInboxId)))
+      deleted.add(target);
+  }
+  return deleted;
+}