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

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

@@ -0,0 +1,190 @@
+import { TrainError } from '@metro-labs/core/train-error';
+import type { FrameActionContent, FrameContent } from './codecs.js';
+
+export const FRAME_MAX_CHARS = 64 * 1024;
+export const FRAME_MAX_SCREENS = 50;
+const MAX_SCREEN_ID = 120;
+const FRAME_OPEN = 'frame.open';
+const MAX_TITLE = 200;
+const MAX_DESCRIPTION = 1000;
+const MAX_SOURCE_URL = 2048;
+const SUMMARY_SCAN = 80;
+const TEXT_TYPES = new Set(['Text', 'Caption', 'Markdown']);
+
+type Node = Record<string, unknown>;
+
+export const isNode = (v: unknown): v is Node =>
+  typeof v === 'object' && v !== null && !Array.isArray(v);
+
+export const bad = (message: string): TrainError => new TrainError('INVALID_ARGS', message);
+
+function plain(value: unknown): string {
+  if (typeof value !== 'string') return '';
+  return value
+    .replace(/!?\[([^\]]*)\]\([^)]*\)/g, '$1')
+    .replace(/^\s*(?:#{1,6}|>)\s*/gm, '')
+    .replace(/[*_`~]/g, '')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function childrenOf(node: Node): Node[] {
+  const c = node.children;
+  if (Array.isArray(c)) return c.filter(isNode);
+  return isNode(c) ? [c] : [];
+}
+
+export function frameSummary(widget: Node): { title?: string; description?: string } {
+  const titles: string[] = [];
+  const texts: string[] = [];
+  const stack: Node[] = [widget];
+  for (let seen = 0; stack.length > 0 && seen < SUMMARY_SCAN; seen += 1) {
+    const node = stack.pop();
+    if (!node) break;
+    const value = plain(node.value);
+    if (node.type === 'Title' && value) titles.push(value);
+    if (typeof node.type === 'string' && TEXT_TYPES.has(node.type) && value) texts.push(value);
+    stack.push(...childrenOf(node).reverse());
+  }
+  const title = titles[0] ?? texts[0];
+  return { title, description: texts.find((t) => t !== title) };
+}
+
+function clip(value: unknown, max: number, name: string): string | undefined {
+  if (value === undefined) return undefined;
+  if (typeof value !== 'string') throw bad(`frame ${name} must be a string`);
+  const out = value.trim().slice(0, max);
+  return out === '' ? undefined : out;
+}
+
+export function parseJson(raw: unknown, name: string): unknown {
+  if (typeof raw !== 'string') return raw;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw bad(`${name} is not valid JSON`);
+  }
+}
+
+function checkSize(value: unknown, name: string): void {
+  const chars = JSON.stringify(value).length;
+  if (chars > FRAME_MAX_CHARS) throw bad(`${name} is ${chars} characters; the limit is ${FRAME_MAX_CHARS}`);
+}
+
+function parseWidget(raw: unknown, name = 'frame widget'): Node {
+  const widget = parseJson(raw, name);
+  if (!isNode(widget) || typeof widget.type !== 'string' || widget.type === '')
+    throw bad(`${name} must be a ChatKit widget object with a \`type\` (Card, ListView or Basic)`);
+  checkSize(widget, name);
+  return widget;
+}
+
+function parseScreen(id: string, raw: unknown): { screen: Node; widget: Node } {
+  const name = `frame screen "${id}"`;
+  const given = parseJson(raw, name);
+  if (!isNode(given) || given.type !== undefined || given.widget === undefined) {
+    const widget = parseWidget(given, name);
+    return { screen: widget, widget };
+  }
+  const widget = parseWidget(given.widget, `${name} widget`);
+  const title = clip(given.title, MAX_TITLE, `screen "${id}" title`);
+  return { screen: title ? { title, widget } : { widget }, widget };
+}
+
+function openTargets(root: unknown): string[] {
+  const targets: string[] = [];
+  const stack: unknown[] = [root];
+  while (stack.length > 0) {
+    const value = stack.pop();
+    if (Array.isArray(value)) stack.push(...(value as unknown[]));
+    else if (isNode(value)) {
+      if (value.type === FRAME_OPEN)
+        targets.push(isNode(value.payload) && typeof value.payload.screen === 'string' ? value.payload.screen : '');
+      stack.push(...Object.values(value));
+    }
+  }
+  return targets;
+}
+
+function screenIds(screens: Node): string[] {
+  const ids = Object.keys(screens);
+  if (ids.length === 0 || ids.length > FRAME_MAX_SCREENS)
+    throw bad(`frame screens must hold 1 to ${FRAME_MAX_SCREENS} screens, not ${ids.length}`);
+  const badId = ids.find((id) => id === '' || id.length > MAX_SCREEN_ID);
+  if (badId !== undefined) throw bad(`frame screen ids must be 1 to ${MAX_SCREEN_ID} characters`);
+  return ids;
+}
+
+function checkLinks(screens: Node, ids: string[], start: unknown): void {
+  if (typeof start !== 'string' || !ids.includes(start))
+    throw bad(`frame start is required with screens and must be one of their ids: ${ids.slice(0, 10).join(', ')}`);
+  const lost = openTargets(screens).find((target) => !ids.includes(target));
+  if (lost !== undefined)
+    throw bad(`frame.open goes to screen "${lost}", which is not in screens (${ids.slice(0, 10).join(', ')})`);
+}
+
+interface FrameBody {
+  content: Pick<FrameContent, 'widget' | 'screens' | 'start'>;
+  first: Node;
+}
+
+function parseScreens(raw: unknown, start: unknown): FrameBody {
+  const given = parseJson(raw, 'frame screens');
+  if (!isNode(given))
+    throw bad('frame screens must be an object of screen id to widget: {"home": {…}, "story": {"title": "…", "widget": {…}}}');
+  const ids = screenIds(given);
+  const parsed = ids.map((id) => [id, parseScreen(id, given[id])] as const);
+  const screens: Node = Object.fromEntries(parsed.map(([id, p]) => [id, p.screen]));
+  checkSize(screens, 'frame screens');
+  checkLinks(screens, ids, start);
+  const first = parsed.find(([id]) => id === start)?.[1];
+  if (!first || typeof start !== 'string') throw bad('frame start must name a screen');
+  return { content: { screens, start }, first: first.widget };
+}
+
+function frameBody(args: Node): FrameBody {
+  if (args.screens === undefined) {
+    const widget = parseWidget(args.widget);
+    return { content: { widget }, first: widget };
+  }
+  if (args.widget !== undefined) throw bad('frame takes `widget` or `screens`, not both');
+  return parseScreens(args.screens, args.start);
+}
+
+function sourcePart(raw: unknown): Pick<FrameContent, 'source'> {
+  if (raw === undefined) return {};
+  const url = isNode(raw) && typeof raw.url === 'string' ? raw.url.trim() : '';
+  if (url.length > MAX_SOURCE_URL)
+    throw bad(`frame source url is ${url.length} characters; the limit is ${MAX_SOURCE_URL}`);
+  if (!URL.canParse(url) || new URL(url).protocol !== 'https:')
+    throw bad('frame source must be {"url": "https://…"}, the node that serves this widget');
+  return { source: { url } };
+}
+
+export function buildFrameContent(raw: unknown): { frame: FrameContent; title: string } {
+  const args = parseJson(raw, 'frame');
+  if (!isNode(args))
+    throw bad('frame must be an object: {widget, title?, description?} or {screens, start, title?, description?}');
+  const body = frameBody(args);
+  const derived = frameSummary(body.first);
+  const title = clip(args.title, MAX_TITLE, 'title') ?? derived.title?.slice(0, MAX_TITLE);
+  const description = clip(args.description, MAX_DESCRIPTION, 'description') ?? derived.description?.slice(0, MAX_DESCRIPTION);
+  const frame: FrameContent = {
+    ...(title ? { title } : {}),
+    ...(description && description !== title ? { description } : {}),
+    ...body.content,
+    ...sourcePart(args.source),
+  };
+  return { frame, title: title ?? 'Frame' };
+}
+
+export function asFrameAction(c: object): FrameActionContent | undefined {
+  const v = c as Partial<FrameActionContent>;
+  if (typeof v.frameId !== 'string' || !isNode(v.action) || typeof v.action.type !== 'string') return undefined;
+  const payload = isNode(v.action.payload) ? v.action.payload : undefined;
+  return {
+    frameId: v.frameId,
+    action: payload ? { type: v.action.type, payload } : { type: v.action.type },
+    ...(typeof v.label === 'string' && v.label ? { label: v.label } : {}),
+  };
+}

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

@@ -1,7 +1,7 @@
 import type {
   MemberOutcome,
   MemberOutcomeStatus,
-} from '@metro-labs/mcp/stations/types';
+} from '@metro-labs/core/stations/types';
 
 type Args = Record<string, unknown>;
 

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

@@ -1,5 +1,5 @@
-import { TrainError } from '@metro-labs/mcp/train-error';
-import type { GroupResult } from '@metro-labs/mcp/stations/types';
+import { TrainError } from '@metro-labs/core/train-error';
+import type { GroupResult } from '@metro-labs/core/stations/types';
 import { accountForCall, convOf, lineOf } from './accounts.js';
 import {
   applyMemberOp,

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

@@ -2,32 +2,46 @@ import { IdentifierKind, type Signer } from '@xmtp/node-sdk';
 import { privateKeyToAccount } from 'viem/accounts';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { SMART_CHAIN_ID, smartAccountFor, type SmartAccount } from './smart.js';
 
 export const XMTP_ENV = 'production' as const;
 
 export const expandHome = (p: string): string =>
   p.startsWith('~') ? join(homedir(), p.slice(1)) : p;
 
-export function signerFor(privateKey: string): {
+export interface Identity {
   signer: Signer;
   address: string;
-} {
+  smart: SmartAccount | null;
+}
+
+const bytesOf = (sig: string): Uint8Array => {
+  const hex = sig.slice(2);
+  const out = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < out.length; i++) out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  return out;
+};
+
+export function signerFor(privateKey: string): Identity {
   const acct = privateKeyToAccount(privateKey as `0x${string}`);
   const signer: Signer = {
     type: 'EOA',
-    getIdentifier: () =>
-      Promise.resolve({
-        identifier: acct.address,
-        identifierKind: IdentifierKind.Ethereum,
-      }),
-    signMessage: async (msg: string) => {
-      const sig = await acct.signMessage({ message: msg });
-      const hex = sig.slice(2);
-      const out = new Uint8Array(hex.length / 2);
-      for (let i = 0; i < out.length; i++)
-        out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
-      return out;
-    },
+    getIdentifier: () => Promise.resolve({ identifier: acct.address, identifierKind: IdentifierKind.Ethereum }),
+    signMessage: async (msg: string) => bytesOf(await acct.signMessage({ message: msg })),
+  };
+  return { signer, address: acct.address, smart: null };
+}
+
+export async function smartSignerFor(privateKey: string, rpc?: string): Promise<Identity> {
+  const smart = await smartAccountFor(privateKey, rpc);
+  const signer: Signer = {
+    type: 'SCW',
+    getIdentifier: () => Promise.resolve({ identifier: smart.address, identifierKind: IdentifierKind.Ethereum }),
+    signMessage: async (msg: string) => bytesOf(await smart.signMessage(msg)),
+    getChainId: () => BigInt(SMART_CHAIN_ID),
   };
-  return { signer, address: acct.address };
+  return { signer, address: smart.address, smart };
 }
+
+export const identityFor = (privateKey: string, smart: boolean): Promise<Identity> =>
+  smart ? smartSignerFor(privateKey) : Promise.resolve(signerFor(privateKey));

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

@@ -1,57 +1,31 @@
-import { errMsg } from '@metro-labs/mcp/log';
-import { ConsentState, type DecodedMessage } from '@xmtp/node-sdk';
+import { errMsg } from '@metro-labs/core/log';
+import type { DecodedMessage } from '@xmtp/node-sdk';
 import {
   accounts,
   bootAccount,
   loadAccounts,
   type Account,
 } from './accounts.js';
-import { emitInbound, envelope } from './emit.js';
+import { emitInbound } from '@metro-labs/core/stations/train-events';
+import { announceAccounts } from '@metro-labs/core/stations/train-boot';
+import { envelope } from './emit.js';
 import { groupNameFor } from './conv-helpers.js';
-import { handleControlDm, pushInbound } from './push.js';
-import { readCalls } from '@metro-labs/mcp/trains/protocol';
+import { senderFieldsNow } from './sender.js';
+import { readCalls } from '@metro-labs/core/trains/protocol';
 import { handleCall } from './actions.js';
+import { streamMessages } from './stream.js';
 
 readCalls('xmtp', handleCall);
 
-const SYNC_MS = Number(process.env.XMTP_SYNC_MS ?? '60000');
 const SILENT_TYPES = new Set([
   'readReceipt',
   'transactionReference',
   'walletSendCalls',
   'groupUpdated',
   'group_updated',
+  'deleteRequest',
 ]);
 
-async function bootSync(acct: Account): Promise<void> {
-  const { id } = acct.cfg;
-  try {
-    await acct.client.conversations.syncAll([
-      ConsentState.Allowed,
-      ConsentState.Unknown,
-    ]);
-    const initial = await acct.client.conversations.list();
-    process.stderr.write(
-      `xmtp[${id}]: synced ${initial.length} conversation(s) at boot\n`,
-    );
-  } catch (err) {
-    process.stderr.write(
-      `xmtp[${id}] boot sync error: ${errMsg(err)}\n`,
-    );
-  }
-}
-
-function startPeriodicSync(acct: Account): void {
-  const { id } = acct.cfg;
-  setInterval(() => {
-    acct.client.conversations
-      .syncAll([ConsentState.Allowed, ConsentState.Unknown])
-      .catch((err: unknown) => {
-        process.stderr.write(`xmtp[${id}] sync error: ${errMsg(err)}\n`);
-      });
-  }, SYNC_MS).unref();
-}
-
 async function handleStreamMessage(
   acct: Account,
   msg: DecodedMessage,
@@ -59,44 +33,24 @@ async function handleStreamMessage(
   const { id } = acct.cfg;
   if (msg.senderInboxId === acct.client.inboxId) return;
   if (SILENT_TYPES.has(msg.contentType?.typeId ?? '')) return;
-  if (handleControlDm(id, msg)) return;
   const conv = await acct.client.conversations.getConversationById(
     msg.conversationId,
   );
   if (!conv) return;
   const env = envelope(id, msg, conv);
+  Object.assign(env, senderFieldsNow(acct, msg.senderInboxId));
   const name = await groupNameFor(msg.conversationId, conv);
-  if (name) {
-    env.line_name = name;
-    env.lineName = name;
-    const p = (env.payload ?? {}) as Record<string, unknown>;
-    env.payload = { ...p, lineName: name };
-  }
+  if (name) env.line_name = name;
   emitInbound(id, env);
-  pushInbound(id, env, msg, conv);
 }
 
 async function runAccount(acct: Account): Promise<void> {
-  const { id } = acct.cfg;
-  await bootSync(acct);
-  startPeriodicSync(acct);
-
-  for (;;) {
-    try {
-      const stream = await acct.client.conversations.streamAllMessages({
-        consentStates: [ConsentState.Allowed, ConsentState.Unknown],
-      });
-      for await (const msg of stream) {
-        if (!msg) continue;
-        await handleStreamMessage(acct, msg);
-      }
-    } catch (err) {
-      process.stderr.write(
-        `xmtp[${id}] stream error (retry 5s): ${errMsg(err)}\n`,
-      );
-    }
-    await new Promise((r) => setTimeout(r, 5000));
-  }
+  await streamMessages(acct.client.conversations, async (msg) => {
+    if (!msg) return;
+    await handleStreamMessage(acct, msg).catch((err: unknown) => {
+      process.stderr.write(`xmtp[${acct.cfg.id}] one message failed and was skipped: ${errMsg(err)}\n`);
+    });
+  });
 }
 
 const cfgs = loadAccounts();
@@ -109,13 +63,7 @@ for (const cfg of cfgs) {
     );
   }
 }
-if (accounts.size === 0) {
-  process.stderr.write('xmtp: no accounts booted, exiting\n');
-  process.exit(2);
-}
-process.stderr.write(
-  `xmtp train ready — ${accounts.size} account(s): ${[...accounts.keys()].join(', ')}\n`,
-);
+announceAccounts('xmtp', accounts.keys());
 
 for (const acct of accounts.values())
   runAccount(acct).catch((err: unknown) => {

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

@@ -1,3 +1,5 @@
+import { TrainError } from '@metro-labs/core/train-error';
+
 export interface GroupLike {
   id: string;
   appData?: string;
@@ -10,14 +12,21 @@ export interface GroupLike {
 
 const MAX_LABELS = 16;
 const MAX_LABEL_LEN = 24;
+const MAX_APP_DATA_BYTES = 8192;
+export const PRIORITIES = ['Urgent', 'High', 'Medium', 'Low'] as const;
+type Priority = (typeof PRIORITIES)[number];
+
+function cleanLabel(raw: string): string {
+  return raw.trim().replace(/\s+/g, ' ').slice(0, MAX_LABEL_LEN);
+}
 
-export function cleanLabels(raw: unknown): string[] {
+function cleanLabels(raw: unknown): string[] {
   if (!Array.isArray(raw)) return [];
   const out: string[] = [];
   const seen = new Set<string>();
   for (const item of raw) {
     if (typeof item !== 'string') continue;
-    const label = item.trim().replace(/\s+/g, ' ').slice(0, MAX_LABEL_LEN);
+    const label = cleanLabel(item);
     const key = label.toLowerCase();
     if (!label || seen.has(key)) continue;
     seen.add(key);
@@ -27,44 +36,59 @@ export function cleanLabels(raw: unknown): string[] {
   return out;
 }
 
-function parseAppDataObject(
+export function readAppDataObject(
   existingAppData: string | undefined,
 ): Record<string, unknown> {
   if (!existingAppData?.trim()) return {};
-  try {
-    const p: unknown = JSON.parse(existingAppData);
-    if (p && typeof p === 'object' && !Array.isArray(p))
-      return p as Record<string, unknown>;
-  } catch {
-    return {};
+  const parsed: unknown = JSON.parse(existingAppData);
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new TrainError('INVALID_ARGS', 'Channel appData must be a JSON object');
   }
-  return {};
+  return parsed as Record<string, unknown>;
 }
 
-export function labelsBlob(
-  existingAppData: string | undefined,
-  labels: string[],
-  github?: string,
-): string {
-  const existing = parseAppDataObject(existingAppData);
-  const blob: Record<string, unknown> = {
-    ...existing,
-    v: 1,
-    labels: cleanLabels(labels),
-  };
-  if (typeof github === 'string') {
-    if (github.trim()) blob.github = github.trim();
-    else delete blob.github;
-  }
-  return JSON.stringify(blob);
+export function normalizeAssigned(value: unknown): string[] {
+  if (!Array.isArray(value)) {
+    throw new TrainError('INVALID_ARGS', 'assigned must be an array of Ethereum addresses');
+  }
+  const addresses: string[] = [];
+  for (const address of value) {
+    if (typeof address !== 'string' || !/^0x[0-9a-fA-F]{40}$/.test(address.trim())) {
+      throw new TrainError('INVALID_ARGS', 'assigned must contain valid Ethereum addresses');
+    }
+    addresses.push(address.trim().toLowerCase());
+  }
+  return [...new Set(addresses)];
+}
+
+export function metadataPatch(value: unknown): Record<string, unknown> {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new TrainError('INVALID_ARGS', 'metadata must be a JSON object');
+  }
+  const patch = value as Record<string, unknown>;
+  if (Object.hasOwn(patch, 'v')) {
+    throw new TrainError('INVALID_ARGS', 'metadata cannot change the reserved v field');
+  }
+  return patch;
 }
 
 function trimmedString(v: unknown): string | undefined {
   return typeof v === 'string' && v.trim() ? v.trim() : undefined;
 }
 
+function cleanMetadataText(v: unknown): string | undefined {
+  return typeof v === 'string' ? cleanLabel(v) || undefined : undefined;
+}
+
+function cleanPriority(value: unknown): Priority | undefined {
+  return PRIORITIES.find((priority) => priority === (typeof value === 'string' ? value.trim() : value));
+}
+
 export function readAppData(appData: string | undefined): {
   labels: string[];
+  category?: string;
+  status?: string;
+  priority?: Priority;
   github?: string;
   preview?: string;
 } {
@@ -75,6 +99,9 @@ export function readAppData(appData: string | undefined): {
     const rec = p as Record<string, unknown>;
     return {
       labels: cleanLabels(rec.labels),
+      category: cleanMetadataText(rec.category),
+      status: cleanMetadataText(rec.status),
+      priority: cleanPriority(rec.priority),
       github: trimmedString(rec.github),
       preview: trimmedString(rec.preview),
     };
@@ -83,41 +110,66 @@ export function readAppData(appData: string | undefined): {
   }
 }
 
+function checkedLabels(value: unknown): string[] {
+  if (!Array.isArray(value) || value.some((label: unknown) => typeof label !== 'string')) {
+    throw new TrainError('INVALID_ARGS', 'labels must be an array of strings');
+  }
+  return cleanLabels(value);
+}
+
+function checkedMetadataText(key: string, value: unknown): string | undefined {
+  if (value !== undefined && value !== null && typeof value !== 'string') {
+    throw new TrainError('INVALID_ARGS', `${key} must be a string or null`);
+  }
+  return cleanMetadataText(value);
+}
+
+function checkedPriority(value: unknown): Priority | undefined {
+  if (value === undefined || value === null || (typeof value === 'string' && !value.trim())) return undefined;
+  const priority = cleanPriority(value);
+  if (!priority) {
+    throw new TrainError('INVALID_ARGS', 'priority must be Urgent, High, Medium, Low, or null');
+  }
+  return priority;
+}
+
+const KNOWN_FIELDS = new Map<string, (value: unknown) => unknown>([
+  ['labels', checkedLabels],
+  ['assigned', normalizeAssigned],
+  ['github', (value) => normalizeGithubUrl(value) || undefined],
+  ['preview', (value) => normalizePreviewUrl(value) || undefined],
+  ['category', (value) => checkedMetadataText('category', value)],
+  ['status', (value) => checkedMetadataText('status', value)],
+  ['priority', checkedPriority],
+]);
+
 function applyMergeKey(
   merged: Record<string, unknown>,
   k: string,
   v: unknown,
 ): void {
-  if (k === 'labels') {
-    merged.labels = cleanLabels(v);
-    return;
-  }
-  if (k === 'github') {
-    const g = normalizeGithubUrl(v);
-    if (g) merged.github = g;
-    else delete merged.github;
-    return;
-  }
-  if (k === 'preview') {
-    const p = normalizePreviewUrl(v);
-    if (p) merged.preview = p;
-    else delete merged.preview;
-    return;
-  }
-  if (v === undefined || v === null) Reflect.deleteProperty(merged, k);
-  else merged[k] = v;
+  const normalize = KNOWN_FIELDS.get(k);
+  const value = normalize ? normalize(v) : v;
+  if (value === undefined || value === null) Reflect.deleteProperty(merged, k);
+  else Object.defineProperty(merged, k, { value, enumerable: true, configurable: true, writable: true });
 }
 
 export function mergeAppData(
   existingAppData: string | undefined,
   patch: Record<string, unknown>,
 ): { blob: string; merged: Record<string, unknown> } {
-  const merged: Record<string, unknown> = {
-    ...parseAppDataObject(existingAppData),
-    v: 1,
-  };
-  for (const [k, v] of Object.entries(patch)) applyMergeKey(merged, k, v);
-  return { blob: JSON.stringify(merged), merged };
+  const current = readAppDataObject(existingAppData);
+  const checked = metadataPatch(patch);
+  if (Object.hasOwn(checked, 'assigned') && Object.hasOwn(current, 'assigned')) {
+    normalizeAssigned(current.assigned);
+  }
+  const merged: Record<string, unknown> = { v: 1, ...current };
+  for (const [k, v] of Object.entries(checked)) applyMergeKey(merged, k, v);
+  const blob = JSON.stringify(merged);
+  if (Buffer.byteLength(blob, 'utf8') > MAX_APP_DATA_BYTES) {
+    throw new TrainError('INVALID_ARGS', `Channel appData exceeds ${MAX_APP_DATA_BYTES} bytes`);
+  }
+  return { blob, merged };
 }
 
 export function normalizeGithubUrl(url: unknown): string {

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

@@ -1,4 +1,4 @@
-import { TrainError } from '@metro-labs/mcp/train-error';
+import { TrainError } from '@metro-labs/core/train-error';
 
 type Args = Record<string, unknown>;