@stage-labs/metro 0.1.0-beta.21 → 0.1.0-beta.211

package/runtime/node_modules/@metro-labs/{discord → discord-bot}/src/actions.ts

@@ -1,32 +1,19 @@
+import type { Message } from 'discord.js';
 import {
-  ActivityType,
-  type Message,
-  type PresenceStatusData,
-} from 'discord.js';
-import {
-  accountFor,
   accounts,
   encodeEmoji,
-  lineOf,
   rest,
   routeOf,
 } from './accounts.js';
 import { emitOutbound, emitOutboundEdit, emitOutboundReact } from './format.js';
-import { respond } from './wire.js';
-import { normalizeDiscord } from '@metro-labs/mcp/stations/messaging-normalize';
-import { assertContentLength } from '@metro-labs/mcp/stations/attachments';
+import { messagingAliases } from '@metro-labs/core/stations/messaging-normalize';
 import {
   appendFiles,
   outgoingFiles,
   type OutgoingFile,
 } from './send-files.js';
-import {
-  makeStation,
-  type CallMsg,
-  type StationHandler,
-} from '@metro-labs/mcp/stations/station-runtime';
-import { joinVoice, leaveVoice, voiceDebug, voiceTranscribe } from './voice.js';
-import { speak } from './voice-speak.js';
+import { makeStation, respond, type CallMsg, type StationHandler } from '@metro-labs/core/stations/station-runtime';
+import { readProfile, setProfile } from './profile.js';
 import { discordMembers } from './members.js';
 import {
   groupAddHandler,
@@ -65,40 +52,17 @@ async function sendMessage(
 export type { CallMsg };
 
 async function send(id: string, args: Record<string, unknown>): Promise<void> {
-  const {
-    line,
-    text,
-    replyTo,
-    embeds,
-    stickerIds,
-    images,
-    files,
-    account,
-    attachmentKinds,
-    attachmentNames,
-  } = args as {
+  const { line, text, replyTo, account } = args as {
     line: string;
     text?: string;
     replyTo?: string;
-    embeds?: unknown[];
-    stickerIds?: string[];
-    images?: string[];
-    files?: string[];
     account?: string;
-    attachmentKinds?: string[];
-    attachmentNames?: string[];
   };
   const { accountId, channelId } = routeOf(line, account);
   const body: Record<string, unknown> = { flags: 4 };
   if (text !== undefined) body.content = text;
   if (replyTo) body.message_reference = { message_id: replyTo };
-  if (embeds) body.embeds = embeds;
-  if (stickerIds) body.sticker_ids = stickerIds;
-  const outgoing = outgoingFiles(
-    [...(images ?? []), ...(files ?? [])],
-    attachmentNames,
-    attachmentKinds,
-  );
+  const outgoing = outgoingFiles(args.attachments);
   const res = await sendMessage(accountId, channelId, body, outgoing);
   emitOutbound(accountId, line, res.id, text ?? '', replyTo);
   respond(id, {
@@ -110,38 +74,6 @@ async function send(id: string, args: Record<string, unknown>): Promise<void> {
   });
 }
 
-function presence(id: string, args: Record<string, unknown>): void {
-  const {
-    text,
-    status = 'online',
-    account,
-  } = args as {
-    text?: string;
-    status?: PresenceStatusData;
-    account?: string;
-  };
-  const accountId = accountFor({ account });
-  const acct = accounts.get(accountId);
-  if (!acct) {
-    respond(id, { error: `unknown account '${accountId}'` });
-    return;
-  }
-  const client = acct.client;
-  if (!client.user) {
-    respond(id, { error: `gateway not ready for account '${accountId}'` });
-    return;
-  }
-  client.user.setPresence({
-    status,
-    activities: text
-      ? [{ name: 'Custom Status', type: ActivityType.Custom, state: text }]
-      : [],
-  });
-  respond(id, {
-    result: { ok: true, text: text ?? null, status, account: accountId },
-  });
-}
-
 const profileUrl = (userId?: string): string | null =>
   userId === undefined ? null : `https://discord.com/users/${userId}`;
 
@@ -154,13 +86,19 @@ function listAccounts(id: string): void {
         url: profileUrl(a.client.user?.id),
         userId: a.client.user?.id ?? null,
         username: a.client.user?.username ?? null,
-        owner: a.cfg.owner ?? null,
         ready: a.client.isReady(),
       })),
     },
   });
 }
 
+async function typing(id: string, args: Record<string, unknown>): Promise<void> {
+  const { line, account } = args as { line: string; account?: string };
+  const { accountId, channelId } = routeOf(line, account);
+  await rest(accountId, 'POST', `/channels/${channelId}/typing`);
+  respond(id, { result: { ok: true, account: accountId } });
+}
+
 async function react(id: string, args: Record<string, unknown>): Promise<void> {
   const { line, messageId, emoji, account } = args as {
     line: string;
@@ -216,7 +154,7 @@ async function remove(
   respond(id, { result: { ok: true, account: accountId } });
 }
 
-async function fetchMessages(
+async function read(
   id: string,
   args: Record<string, unknown>,
 ): Promise<void> {
@@ -244,104 +182,6 @@ async function fetchMessages(
   respond(id, { result: { messages: msgs, account: accountId } });
 }
 
-async function download(
-  id: string,
-  args: Record<string, unknown>,
-): Promise<void> {
-  const {
-    line,
-    messageId,
-    outDir = '/tmp',
-    account,
-  } = args as {
-    line: string;
-    messageId: string;
-    outDir?: string;
-    account?: string;
-  };
-  const { accountId, channelId } = routeOf(line, account);
-  const msg = await rest<{
-    attachments: { url: string; content_type?: string; filename: string }[];
-  }>(accountId, 'GET', `/channels/${channelId}/messages/${messageId}`);
-  const files: { path: string; mediaType: string }[] = [];
-  for (const att of msg.attachments) {
-    const res = await fetch(att.url, { signal: AbortSignal.timeout(60_000) });
-    if (!res.ok)
-      throw new Error(`discord download ${res.status} for ${att.url}`);
-    assertContentLength(res.headers.get('content-length'));
-    const buf = await res.arrayBuffer();
-    const path = `${outDir}/${messageId}-${att.filename}`;
-    await Bun.write(path, buf);
-    files.push({
-      path,
-      mediaType: att.content_type ?? 'application/octet-stream',
-    });
-  }
-  respond(id, { result: { files, account: accountId } });
-}
-
-async function threadCreate(
-  id: string,
-  args: Record<string, unknown>,
-): Promise<void> {
-  const {
-    line,
-    messageId,
-    name,
-    autoArchiveDuration = 1440,
-    account,
-  } = args as {
-    line: string;
-    messageId?: string;
-    name: string;
-    autoArchiveDuration?: number;
-    account?: string;
-  };
-  const { accountId, channelId } = routeOf(line, account);
-  const path = messageId
-    ? `/channels/${channelId}/messages/${messageId}/threads`
-    : `/channels/${channelId}/threads`;
-  const res = await rest<{ id: string }>(accountId, 'POST', path, {
-    name,
-    auto_archive_duration: autoArchiveDuration,
-  });
-  respond(id, {
-    result: {
-      threadId: res.id,
-      line: lineOf(accountId, res.id),
-      account: accountId,
-    },
-  });
-}
-
-async function pin(id: string, args: Record<string, unknown>): Promise<void> {
-  const { line, messageId, account } = args as {
-    line: string;
-    messageId: string;
-    account?: string;
-  };
-  const { accountId, channelId } = routeOf(line, account);
-  await rest(accountId, 'PUT', `/channels/${channelId}/pins/${messageId}`);
-  respond(id, { result: { ok: true, account: accountId } });
-}
-
-async function typing(id: string, args: Record<string, unknown>): Promise<void> {
-  const { line, account } = args as { line: string; account?: string };
-  const { accountId, channelId } = routeOf(line, account);
-  await rest(accountId, 'POST', `/channels/${channelId}/typing`);
-  respond(id, { result: { ok: true, account: accountId } });
-}
-
-async function channel(
-  id: string,
-  args: Record<string, unknown>,
-): Promise<void> {
-  const { line, account } = args as { line: string; account?: string };
-  const { accountId, channelId } = routeOf(line, account);
-  const res = await rest(accountId, 'GET', `/channels/${channelId}`);
-  respond(id, { result: res });
-}
-
 async function listMembers(
   id: string,
   args: Record<string, unknown>,
@@ -365,24 +205,16 @@ const HANDLERS: Record<string, StationHandler> = {
   groupRemoveMembers: groupRemoveHandler,
   send,
   react,
+  typing,
   edit,
   delete: remove,
-  fetch: fetchMessages,
-  download,
-  thread_create: threadCreate,
-  pin,
-  typing,
-  channel,
+  read,
   listMembers,
-  set_presence: presence,
-  joinVoice,
-  leaveVoice,
-  speak,
-  voiceDebug,
-  voiceTranscribe,
+  set_profile: setProfile,
+  profile: readProfile,
 };
 
 export const handleCall = makeStation({
   handlers: HANDLERS,
-  normalize: normalizeDiscord,
+  normalize: messagingAliases(),
 });

package/runtime/node_modules/@metro-labs/{discord → discord-bot}/src/attachments.ts

@@ -1,8 +1,8 @@
 import {
   saveBufferToCache,
   assertContentLength,
-} from '@metro-labs/mcp/stations/attachments';
-import type { SavedAttachment } from '@metro-labs/mcp/stations/attachments';
+} from '@metro-labs/core/stations/attachments';
+import type { SavedAttachment } from '@metro-labs/core/stations/attachments';
 
 export type { SavedAttachment };
 
@@ -19,7 +19,7 @@ export async function saveDiscordAttachment(
 ): Promise<SavedAttachment> {
   const res = await fetch(a.url, { signal: AbortSignal.timeout(60_000) });
   if (!res.ok)
-    throw new Error(`discord attachment fetch ${res.status} for ${a.url}`);
+    throw new Error(`discord-bot attachment fetch ${res.status} for ${a.url}`);
   assertContentLength(res.headers.get('content-length'));
   const data = new Uint8Array(await res.arrayBuffer());
   return saveBufferToCache(data, messageId, index, {

package/runtime/node_modules/@metro-labs/{discord → discord-bot}/src/format.ts

@@ -1,56 +1,9 @@
 import { MessageFlags, type Message, type MessageReaction, type User } from 'discord.js';
+import { reportAttachment, selfUri } from '@metro-labs/core/stations/train-events';
 import { accounts, lineOf } from './accounts.js';
-import { emit, mintId, SELF_URI } from './wire.js';
+import { emit, mintId } from '@metro-labs/core/stations/station-runtime';
 import { saveDiscordAttachment } from './attachments.js';
 
-export function emitInbound(
-  accountId: string,
-  e: Record<string, unknown>,
-): void {
-  const owner = accounts.get(accountId)?.cfg.owner;
-  const payload = {
-    ...(e.payload as Record<string, unknown> | undefined),
-    account: accountId,
-  };
-  emit({ ...e, ...(owner ? { to: owner } : {}), account: accountId, payload });
-}
-
-function emitAttachmentSaved(
-  accountId: string,
-  line: string,
-  sourceMsgId: string,
-  index: number,
-  ref: { url: string; name?: string | null; contentType?: string | null },
-  messageId: string,
-): void {
-  void saveDiscordAttachment(ref, messageId, index)
-    .then((saved) => {
-      emitInbound(accountId, {
-        kind: 'inbound',
-        id: mintId(),
-        ts: new Date().toISOString(),
-        station: 'discord',
-        line,
-        from: SELF_URI,
-        text: `📎 saved: ${saved.path}`,
-        payload: {
-          contentType: 'attachmentSaved',
-          attachmentFor: sourceMsgId,
-          index,
-          attachmentPath: saved.path,
-          localPath: saved.path,
-          mime: saved.mime,
-          name: saved.name,
-        },
-      });
-    })
-    .catch((err: unknown) =>
-      process.stderr.write(
-        `discord attachment save failed: ${err instanceof Error ? err.message : String(err)}\n`,
-      ),
-    );
-}
-
 const AV_TAG: Record<string, string> = { audio: 'audio', video: 'video' };
 
 function tagFor(att: {
@@ -65,6 +18,20 @@ function tagFor(att: {
   return `[${kind}: ${att.name ?? kind}]`;
 }
 
+function addressing(accountId: string, m: Message): { mentions_self: boolean; reply_to_self: boolean } {
+  const me = accounts.get(accountId)?.client.user ?? null;
+  if (me === null) return { mentions_self: false, reply_to_self: false };
+  return {
+    mentions_self: m.mentions.has(me, { ignoreRepliedUser: true, ignoreEveryone: true }),
+    reply_to_self: m.mentions.repliedUser?.id === me.id,
+  };
+}
+
+const senderOf = (m: Message): Record<string, string | undefined> => ({
+  from_name: m.author.username,
+  from_display_name: m.member?.displayName ?? m.author.globalName ?? undefined,
+});
+
 export function messageEnvelope(
   accountId: string,
   m: Message,
@@ -89,29 +56,25 @@ export function messageEnvelope(
     size: a.size,
   }));
   attachments.forEach((a, i) => {
-    emitAttachmentSaved(
-      accountId,
-      line,
-      envId,
-      i,
-      { url: a.url, name: a.name, contentType: a.contentType },
-      m.id,
+    reportAttachment(
+      saveDiscordAttachment({ url: a.url, name: a.name, contentType: a.contentType }, m.id, i),
+      { station: 'discord-bot', account: accountId, line, forId: envId, index: i },
+      { failed: { name: a.name, mime: a.contentType ?? undefined } },
     );
   });
   return {
-    kind: 'inbound',
     id: envId,
     ts: new Date(m.createdTimestamp).toISOString(),
-    station: 'discord',
+    station: 'discord-bot',
     line,
     line_name: 'name' in m.channel ? m.channel.name : undefined,
-    from: `metro://discord/${accountId}/user/${m.author.id}`,
-    from_name: m.author.username,
-    from_display_name: m.author.globalName ?? undefined,
+    from: `metro://discord-bot/${accountId}/user/${m.author.id}`,
+    ...senderOf(m),
     message_id: m.id,
     text,
     is_private: m.guildId == null,
     reply_to: m.reference?.messageId ?? undefined,
+    ...addressing(accountId, m),
     ...(m.reference?.messageId
       ? { event: { type: 'reply', replyTo: m.reference.messageId } }
       : {}),
@@ -126,12 +89,11 @@ export function reactionEnvelope(
 ): Record<string, unknown> | null {
   if (u.bot) return null;
   return {
-    kind: 'react',
     id: mintId(),
     ts: new Date().toISOString(),
-    station: 'discord',
+    station: 'discord-bot',
     line: lineOf(accountId, r.message.channelId),
-    from: `metro://discord/${accountId}/user/${u.id}`,
+    from: `metro://discord-bot/${accountId}/user/${u.id}`,
     from_name: u.username,
     from_display_name: u.globalName ?? undefined,
     message_id: r.message.id,
@@ -152,23 +114,20 @@ export function reactionEnvelope(
 }
 
 function outbound(
-  kind: string,
   accountId: string,
   line: string,
   messageId: string,
   extra: object,
 ): void {
   emit({
-    kind,
     id: mintId(),
     ts: new Date().toISOString(),
-    station: 'discord',
+    station: 'discord-bot',
     line,
-    from: SELF_URI,
+    from: selfUri(),
     to: line,
     message_id: messageId,
     ...extra,
-    account: accountId,
     payload: { account: accountId },
   });
 }
@@ -180,7 +139,7 @@ export function emitOutbound(
   text: string,
   replyTo?: string,
 ): void {
-  outbound('outbound', accountId, line, messageId, {
+  outbound(accountId, line, messageId, {
     text,
     reply_to: replyTo,
     ...(replyTo ? { event: { type: 'reply', replyTo } } : {}),
@@ -192,7 +151,7 @@ export function emitOutboundReact(
   messageId: string,
   emoji: string,
 ): void {
-  outbound('react', accountId, line, messageId, {
+  outbound(accountId, line, messageId, {
     emoji,
     event: { type: 'react', emoji, targetId: messageId },
   });
@@ -203,7 +162,7 @@ export function emitOutboundEdit(
   messageId: string,
   text: string,
 ): void {
-  outbound('edit', accountId, line, messageId, {
+  outbound(accountId, line, messageId, {
     text,
     event: { type: 'edit', targetId: messageId },
   });

package/runtime/node_modules/@metro-labs/{discord → discord-bot}/src/group-actions.ts

@@ -1,5 +1,5 @@
 import { routeOf, rest } from './accounts.js';
-import { respond } from './wire.js';
+import { respond } from '@metro-labs/core/stations/station-runtime';
 import {
   groupAddMembers,
   groupCreate,
@@ -17,7 +17,7 @@ export async function groupCreateHandler(
         capability: {
           supported: false,
           reason:
-            'discord create_group requires `parent` (the metro:// line of the channel to open the thread under)',
+            'discord-bot create_group requires `parent` (the metro:// line of the channel to open the thread under)',
         },
       },
     });

package/runtime/node_modules/@metro-labs/{discord → discord-bot}/src/group.ts

@@ -1,8 +1,8 @@
-import { errMsg } from '@metro-labs/mcp/log';
+import { errMsg } from '@metro-labs/core/log';
 import type {
   GroupResult,
   MemberOutcome,
-} from '@metro-labs/mcp/stations/types';
+} from '@metro-labs/core/stations/types';
 import { lineOf } from './accounts.js';
 
 export type RestFn = <T = unknown>(

package/runtime/node_modules/@metro-labs/{discord → discord-bot}/src/index.ts

@@ -1,4 +1,4 @@
-import { errMsg } from '@metro-labs/mcp/log';
+import { errMsg } from '@metro-labs/core/log';
 import {
   Client,
   Events,
@@ -14,12 +14,14 @@ import {
   lineOf,
   type AccountConfig,
 } from './accounts.js';
-import { emitInbound, messageEnvelope, reactionEnvelope } from './format.js';
-import { mintId } from './wire.js';
-import { readCalls } from '@metro-labs/mcp/trains/protocol';
+import { emitInbound } from '@metro-labs/core/stations/train-events';
+import { messageEnvelope, reactionEnvelope } from './format.js';
+import { mintId } from '@metro-labs/core/stations/station-runtime';
+import { readCalls } from '@metro-labs/core/trains/protocol';
+import { announceAccounts } from '@metro-labs/core/stations/train-boot';
 import { handleCall } from './actions.js';
 
-readCalls('discord', handleCall);
+readCalls('discord-bot', handleCall);
 
 function makeClient(): Client {
   return new Client({
@@ -30,7 +32,6 @@ function makeClient(): Client {
       GatewayIntentBits.GuildMessageReactions,
       GatewayIntentBits.DirectMessages,
       GatewayIntentBits.DirectMessageReactions,
-      GatewayIntentBits.GuildVoiceStates,
     ],
     partials: [
       Partials.Channel,
@@ -44,12 +45,11 @@ function makeClient(): Client {
 function onEdit(accountId: string, m: Message): void {
   if (m.author.bot) return;
   emitInbound(accountId, {
-    kind: 'edit',
     id: mintId(),
     ts: new Date(m.editedTimestamp ?? Date.now()).toISOString(),
-    station: 'discord',
+    station: 'discord-bot',
     line: lineOf(accountId, m.channelId),
-    from: `metro://discord/${accountId}/user/${m.author.id}`,
+    from: `metro://discord-bot/${accountId}/user/${m.author.id}`,
     from_name: m.author.username,
     from_display_name: m.author.globalName ?? undefined,
     message_id: m.id,
@@ -80,7 +80,7 @@ async function bootAccount(cfg: AccountConfig): Promise<void> {
       if (env) emitInbound(accountId, env);
     })().catch((err: unknown) => {
       process.stderr.write(
-        `discord[${accountId}] reaction handler failed: ${errMsg(err)}\n`,
+        `discord-bot[${accountId}] reaction handler failed: ${errMsg(err)}\n`,
       );
     });
   });
@@ -91,12 +91,12 @@ async function bootAccount(cfg: AccountConfig): Promise<void> {
         onEdit(accountId, _new.partial ? await _new.fetch() : _new);
       } catch (err) {
         process.stderr.write(
-          `discord[${accountId}] message update fetch failed: ${errMsg(err)}\n`,
+          `discord-bot[${accountId}] message update fetch failed: ${errMsg(err)}\n`,
         );
       }
     })().catch((err: unknown) => {
       process.stderr.write(
-        `discord[${accountId}] message update handler failed: ${errMsg(err)}\n`,
+        `discord-bot[${accountId}] message update handler failed: ${errMsg(err)}\n`,
       );
     });
   });
@@ -104,7 +104,7 @@ async function bootAccount(cfg: AccountConfig): Promise<void> {
   accounts.set(accountId, { cfg, client });
   await client.login(cfg.token);
   process.stderr.write(
-    `discord[${accountId}] ready — ${client.user?.tag ?? '?'} (owner=${cfg.owner ?? '(broadcast)'})\n`,
+    `discord-bot[${accountId}] ready — ${client.user?.tag ?? '?'}\n`,
   );
 }
 
@@ -114,14 +114,8 @@ for (const cfg of cfgs) {
     await bootAccount(cfg);
   } catch (err) {
     process.stderr.write(
-      `discord[${cfg.id}] boot FAILED: ${errMsg(err)}\n`,
+      `discord-bot[${cfg.id}] boot FAILED: ${errMsg(err)}\n`,
     );
   }
 }
-if (accounts.size === 0) {
-  process.stderr.write('discord: no accounts booted, exiting\n');
-  process.exit(2);
-}
-process.stderr.write(
-  `discord train ready — ${accounts.size} account(s): ${[...accounts.keys()].join(', ')}\n`,
-);
+announceAccounts('discord-bot', accounts.keys());

package/runtime/node_modules/@metro-labs/{discord → discord-bot}/src/members.ts

@@ -1,5 +1,5 @@
-import { errMsg } from '@metro-labs/mcp/log';
-import type { MemberList, MetroMember } from '@metro-labs/mcp/stations/types';
+import { errMsg } from '@metro-labs/core/log';
+import type { MemberList, MetroMember } from '@metro-labs/core/stations/types';
 import { rest } from './accounts.js';
 
 export interface DiscordRole {

package/runtime/node_modules/@metro-labs/discord-bot/src/profile.ts

@@ -0,0 +1,68 @@
+import { readFile } from 'node:fs/promises';
+import type { Client } from 'discord.js';
+import { TrainError } from '@metro-labs/core/train-error';
+import {
+  assertImage,
+  fieldsOf,
+  parseProfileChange,
+  type ProfileApplied,
+  type ProfileChange,
+} from '@metro-labs/core/stations/profile';
+import type { SenderProfile } from '@metro-labs/core/stations/sender-profile';
+import { accountFor, accounts } from './accounts.js';
+import { respond } from '@metro-labs/core/stations/station-runtime';
+
+export async function applyProfile(
+  client: Client,
+  change: ProfileChange,
+): Promise<void> {
+  const user = client.user;
+  if (!user) throw new TrainError('discord_not_ready', 'the gateway is not ready yet');
+  if (change.avatar !== undefined) assertImage(change.avatar);
+  const avatar = change.avatar === undefined ? undefined : await readFile(change.avatar.path);
+  if (change.name !== undefined || avatar !== undefined)
+    await user.edit({
+      ...(change.name === undefined ? {} : { username: change.name }),
+      ...(avatar === undefined ? {} : { avatar }),
+    });
+  if (change.bio !== undefined) {
+    const app = client.application;
+    if (!app) throw new TrainError('discord_not_ready', 'the application is not loaded yet');
+    await app.edit({ description: change.bio });
+  }
+}
+
+export async function setProfile(
+  id: string,
+  args: Record<string, unknown>,
+): Promise<void> {
+  const accountId = accountFor({ account: args.account as string | undefined });
+  const acct = accounts.get(accountId);
+  if (!acct) {
+    respond(id, { error: `unknown account '${accountId}'` });
+    return;
+  }
+  const change = parseProfileChange(args);
+  await applyProfile(acct.client, change);
+  const result: ProfileApplied = { account: accountId, applied: fieldsOf(change) };
+  respond(id, { result });
+}
+
+export async function readProfile(id: string, args: Record<string, unknown>): Promise<void> {
+  const accountId = accountFor({ account: args.account as string | undefined });
+  const acct = accounts.get(accountId);
+  if (!acct) {
+    respond(id, { error: `unknown account '${accountId}'` });
+    return;
+  }
+  const user = typeof args.user === 'string' ? args.user.trim() : '';
+  if (!/^\d+$/.test(user)) throw new TrainError('discord_user_required', 'profile needs the Discord id of the person', { retryable: false });
+  const found = await acct.client.users.fetch(user);
+  const result: SenderProfile = {
+    id: user,
+    name: found.username,
+    ...(found.globalName === null ? {} : { display_name: found.globalName }),
+    avatar: found.displayAvatarURL({ size: 256 }),
+  };
+  respond(id, { result });
+}