@stage-labs/metro 0.1.0-beta.324 → 0.1.0-beta.326

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

@@ -242,16 +242,6 @@ function pollPayload(
   };
 }
 
-function labeledPayload(
-  base: Record<string, unknown>,
-  typeId: string,
-  text: string,
-  key: string,
-  c: unknown,
-): Record<string, unknown> {
-  return { ...base, text, payload: { contentType: typeId, [key]: c } };
-}
-
 function attachmentEnvelope(
   base: Record<string, unknown>,
   typeId: string,
@@ -275,32 +265,21 @@ function attachmentEnvelope(
   return undefined;
 }
 
+const REF_TEXT = new Map([
+  ['walletSendCalls', 'Payment request'],
+  ['transactionReference', 'Transaction'],
+  ['signatureRequest', 'Signature request'],
+  ['signatureReference', 'Signature'],
+]);
+
 function refEnvelope(
   base: Record<string, unknown>,
   typeId: string | undefined,
   c: object,
 ): Record<string, unknown> | undefined {
-  if (typeId === 'walletSendCalls')
-    return labeledPayload(
-      base,
-      typeId,
-      'Payment request',
-      'walletSendCalls',
-      c,
-    );
-  if (typeId === 'transactionReference')
-    return labeledPayload(
-      base,
-      typeId,
-      'Transaction',
-      'transactionReference',
-      c,
-    );
-  if (typeId === 'signatureRequest')
-    return labeledPayload(base, typeId, 'Signature request', 'signatureRequest', c);
-  if (typeId === 'signatureReference')
-    return labeledPayload(base, typeId, 'Signature', 'signatureReference', c);
-  return undefined;
+  if (typeId === undefined) return undefined;
+  const text = REF_TEXT.get(typeId);
+  return text === undefined ? undefined : { ...base, text, payload: { contentType: typeId, [typeId]: c } };
 }
 
 function frameEnvelope(

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

@@ -1,3 +1,4 @@
+import { isRecord } from '@metro-labs/core/is-record';
 import { TrainError } from '@metro-labs/core/train-error';
 import type { FrameActionContent, FrameContent } from './codecs.js';
 
@@ -13,9 +14,6 @@ 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 {
@@ -30,8 +28,8 @@ function plain(value: unknown): string {
 
 function childrenOf(node: Node): Node[] {
   const c = node.children;
-  if (Array.isArray(c)) return c.filter(isNode);
-  return isNode(c) ? [c] : [];
+  if (Array.isArray(c)) return c.filter(isRecord);
+  return isRecord(c) ? [c] : [];
 }
 
 export function frameSummary(widget: Node): { title?: string; description?: string } {
@@ -73,7 +71,7 @@ function checkSize(value: unknown, name: string): void {
 
 function parseWidget(raw: unknown, name = 'frame widget'): Node {
   const widget = parseJson(raw, name);
-  if (!isNode(widget) || typeof widget.type !== 'string' || widget.type === '')
+  if (!isRecord(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;
@@ -82,7 +80,7 @@ function parseWidget(raw: unknown, name = 'frame widget'): Node {
 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) {
+  if (!isRecord(given) || given.type !== undefined || given.widget === undefined) {
     const widget = parseWidget(given, name);
     return { screen: widget, widget };
   }
@@ -97,9 +95,9 @@ function openTargets(root: unknown): string[] {
   while (stack.length > 0) {
     const value = stack.pop();
     if (Array.isArray(value)) stack.push(...(value as unknown[]));
-    else if (isNode(value)) {
+    else if (isRecord(value)) {
       if (value.type === FRAME_OPEN)
-        targets.push(isNode(value.payload) && typeof value.payload.screen === 'string' ? value.payload.screen : '');
+        targets.push(isRecord(value.payload) && typeof value.payload.screen === 'string' ? value.payload.screen : '');
       stack.push(...Object.values(value));
     }
   }
@@ -130,7 +128,7 @@ interface FrameBody {
 
 function parseScreens(raw: unknown, start: unknown): FrameBody {
   const given = parseJson(raw, 'frame screens');
-  if (!isNode(given))
+  if (!isRecord(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);
@@ -153,7 +151,7 @@ function frameBody(args: Node): FrameBody {
 
 function sourcePart(raw: unknown): Pick<FrameContent, 'source'> {
   if (raw === undefined) return {};
-  const url = isNode(raw) && typeof raw.url === 'string' ? raw.url.trim() : '';
+  const url = isRecord(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:')
@@ -163,7 +161,7 @@ function sourcePart(raw: unknown): Pick<FrameContent, 'source'> {
 
 export function buildFrameContent(raw: unknown): { frame: FrameContent; title: string } {
   const args = parseJson(raw, 'frame');
-  if (!isNode(args))
+  if (!isRecord(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);
@@ -180,8 +178,8 @@ export function buildFrameContent(raw: unknown): { frame: FrameContent; title: s
 
 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;
+  if (typeof v.frameId !== 'string' || !isRecord(v.action) || typeof v.action.type !== 'string') return undefined;
+  const payload = isRecord(v.action.payload) ? v.action.payload : undefined;
   return {
     frameId: v.frameId,
     action: payload ? { type: v.action.type, payload } : { type: v.action.type },

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

@@ -1,6 +1,6 @@
 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 { accountForCall, lineOf, openConv } from './accounts.js';
 import {
   applyMemberOp,
   createGroupWithMembers,
@@ -38,8 +38,7 @@ async function memberOp(
   const { addrs, inboxes } = splitMembers(args);
   if (!addrs.length && !inboxes.length)
     throw new TrainError('INVALID_ARGS', `${verb} requires members`);
-  const { conv } = await convOf(line);
-  if (!conv) throw new TrainError('NOT_FOUND', `conversation not found for ${line}`);
+  const { conv } = await openConv(line);
   await applyMemberOp(conv, addrs, inboxes, mode);
   return {
     capability: { supported: true },

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

@@ -1,4 +1,5 @@
 import { IdentifierKind, type Signer } from '@xmtp/node-sdk';
+import { hexToBytes } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
@@ -15,19 +16,12 @@ export interface Identity {
   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) => bytesOf(await acct.signMessage({ message: msg })),
+    signMessage: async (msg: string) => hexToBytes(await acct.signMessage({ message: msg })),
   };
   return { signer, address: acct.address, smart: null };
 }
@@ -37,7 +31,7 @@ export async function smartSignerFor(privateKey: string, rpc?: string): Promise<
   const signer: Signer = {
     type: 'SCW',
     getIdentifier: () => Promise.resolve({ identifier: smart.address, identifierKind: IdentifierKind.Ethereum }),
-    signMessage: async (msg: string) => bytesOf(await smart.signMessage(msg)),
+    signMessage: async (msg: string) => hexToBytes(await smart.signMessage(msg)),
     getChainId: () => BigInt(SMART_CHAIN_ID),
   };
   return { signer, address: smart.address, smart };

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

@@ -1,3 +1,4 @@
+import { isRecord } from '@metro-labs/core/is-record';
 import { TrainError } from '@metro-labs/core/train-error';
 
 export interface GroupLike {
@@ -41,10 +42,10 @@ export function readAppDataObject(
 ): Record<string, unknown> {
   if (!existingAppData?.trim()) return {};
   const parsed: unknown = JSON.parse(existingAppData);
-  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+  if (!isRecord(parsed)) {
     throw new TrainError('INVALID_ARGS', 'Channel appData must be a JSON object');
   }
-  return parsed as Record<string, unknown>;
+  return parsed;
 }
 
 export function normalizeAssigned(value: unknown): string[] {
@@ -62,14 +63,13 @@ export function normalizeAssigned(value: unknown): string[] {
 }
 
 export function metadataPatch(value: unknown): Record<string, unknown> {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+  if (!isRecord(value)) {
     throw new TrainError('INVALID_ARGS', 'metadata must be a JSON object');
   }
-  const patch = value as Record<string, unknown>;
-  if (Object.hasOwn(patch, 'v')) {
+  if (Object.hasOwn(value, 'v')) {
     throw new TrainError('INVALID_ARGS', 'metadata cannot change the reserved v field');
   }
-  return patch;
+  return value;
 }
 
 function trimmedString(v: unknown): string | undefined {
@@ -94,9 +94,8 @@ export function readAppData(appData: string | undefined): {
 } {
   if (!appData?.trim()) return { labels: [] };
   try {
-    const p: unknown = JSON.parse(appData);
-    if (!p || typeof p !== 'object' || Array.isArray(p)) return { labels: [] };
-    const rec = p as Record<string, unknown>;
+    const rec: unknown = JSON.parse(appData);
+    if (!isRecord(rec)) return { labels: [] };
     return {
       labels: cleanLabels(rec.labels),
       category: cleanMetadataText(rec.category),

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

@@ -1,3 +1,5 @@
+import { isRecord } from '@metro-labs/core/is-record';
+import { errMsg } from '@metro-labs/core/log';
 import { TrainError } from '@metro-labs/core/train-error';
 
 export const STAGE_NAMES_PARENT = 'stage.base.eth';
@@ -27,10 +29,10 @@ async function ask(path: string, init: RequestInit, fetchImpl: typeof fetch): Pr
   try {
     res = await fetchImpl(`${proxyBase()}/names/${path}`, { ...init, headers: HEADERS, signal: AbortSignal.timeout(30_000) });
   } catch (err) {
-    throw new TrainError('names_unreachable', `could not reach the stage name service: ${err instanceof Error ? err.message : String(err)}`);
+    throw new TrainError('names_unreachable', `could not reach the stage name service: ${errMsg(err)}`);
   }
   const body: unknown = await res.json().catch(() => null);
-  const record = typeof body === 'object' && body !== null ? (body as Record<string, unknown>) : {};
+  const record = isRecord(body) ? body : {};
   if (!res.ok) throw new TrainError('names_refused', typeof record.error === 'string' ? record.error : `the stage name service answered ${String(res.status)}`);
   return record;
 }

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

@@ -1,12 +1,11 @@
+import { isRecord } from '@metro-labs/core/is-record';
 import { errMsg } from '@metro-labs/core/log';
 import { TrainError } from '@metro-labs/core/train-error';
 
 const RATE_DELAY_MS = 60_000;
 const MAX_DELAY_MS = 300_000;
 
-function recordOf(value: unknown): Record<string, unknown> {
-  return typeof value === 'object' && value !== null ? value as Record<string, unknown> : {};
-}
+const recordOf = (value: unknown): Record<string, unknown> => (isRecord(value) ? value : {});
 
 function retryAfter(error: unknown, now: number): number {
   const fields = recordOf(error);

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

@@ -1,6 +1,7 @@
 import { readFile } from 'node:fs/promises';
 import { encodeFunctionData, encodePacked, keccak256, namehash, stringToBytes, type Hex } from 'viem';
 import { normalize } from 'viem/ens';
+import { errMsg } from '@metro-labs/core/log';
 import { TrainError } from '@metro-labs/core/train-error';
 import {
   assertImage,
@@ -93,7 +94,7 @@ export async function setUpName(smart: SmartAccount, name: string): Promise<bool
     await sendSponsoredCalls(smart, nameSetupCalls(name, smart.address, resolver));
     return true;
   } catch (err) {
-    process.stderr.write(`xmtp: the name ${name} is claimed but its address and primary name are not set for ${smart.address}: ${err instanceof Error ? err.message : String(err)}\n`);
+    process.stderr.write(`xmtp: the name ${name} is claimed but its address and primary name are not set for ${smart.address}: ${errMsg(err)}\n`);
     return false;
   }
 }

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

@@ -1,6 +1,6 @@
 import type { DecodedMessage } from '@xmtp/node-sdk';
-import { kindOf } from '@metro-labs/core/stations/attachments';
-import { saveInlineAttachment, saveRemoteAttachment, type RemoteEntry, type SavedAttachment } from './attachments.js';
+import { kindOf, type SavedAttachment } from '@metro-labs/core/stations/attachments';
+import { saveInlineAttachment, saveRemoteAttachment, type RemoteEntry } from './attachments.js';
 
 interface ReadAttachment {
   name?: string;

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

@@ -3,6 +3,7 @@ import { base } from 'viem/chains';
 import { normalize } from 'viem/ens';
 import { makeProfileCache, type SenderProfile as Profile } from '@metro-labs/core/stations/sender-profile';
 import { respond } from '@metro-labs/core/stations/station-runtime';
+import { errMsg } from '@metro-labs/core/log';
 import { TrainError } from '@metro-labs/core/train-error';
 import { accountForCall, accounts, type Account } from './accounts.js';
 import { resolveAddresses } from './conv-helpers.js';
@@ -85,7 +86,7 @@ const senders = makeProfileCache<SenderProfile>(
     const address = (await resolveAddresses(acct, [inboxId]))[inboxId];
     return address === undefined ? null : profileOf(address);
   },
-  { onError: (k, err) => process.stderr.write(`xmtp: could not resolve the sender ${k}: ${err instanceof Error ? err.message : String(err)}\n`) },
+  { onError: (k, err) => process.stderr.write(`xmtp: could not resolve the sender ${k}: ${errMsg(err)}\n`) },
 );
 
 export const senderFields = (p: SenderProfile | null): Record<string, string> =>

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

@@ -1,3 +1,7 @@
+import { spawn } from 'node:child_process';
+import { existsSync, mkdtempSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 import { errMsg } from '@metro-labs/core/log';
 import { emitInbound, selfUri } from '@metro-labs/core/stations/train-events';
 import { mintId } from '@metro-labs/core/stations/station-runtime';
@@ -8,59 +12,32 @@ const WHISPER_MODEL =
   `${process.env.HOME}/.cache/whisper-cpp/ggml-base.bin`;
 const FFMPEG_BIN = process.env.METRO_FFMPEG_BIN ?? 'ffmpeg';
 
+const run = (bin: string, args: string[]): Promise<void> =>
+  new Promise((res, rej) => {
+    const p = spawn(bin, args, { stdio: 'ignore' });
+    p.on('error', rej);
+    p.on('exit', (c) => {
+      if (c === 0) res();
+      else rej(new Error(`${bin} ${String(c)}`));
+    });
+  });
+
 export async function transcribeAndEmit(
   audio: Uint8Array,
   line: string,
   accountId: string,
   sourceMsgId: string,
 ): Promise<void> {
-  const {
-    existsSync: ex,
-    readFileSync: rf,
-    writeFileSync: wf,
-    unlinkSync,
-    mkdtempSync,
-  } = await import('node:fs');
-  const { tmpdir } = await import('node:os');
-  const path = await import('node:path');
-  const j = (...parts: string[]): string => path.join(...parts);
-  const { spawn } = await import('node:child_process');
-  if (!ex(WHISPER_MODEL)) return;
-  const dir = mkdtempSync(j(tmpdir(), 'xmtp-tx-'));
-  const inFile = j(dir, 'in.m4a');
-  const wav = j(dir, 'in.wav');
-  const out = j(dir, 'in');
-  const run = (bin: string, args: string[]): Promise<void> =>
-    new Promise((res, rej) => {
-      const p = spawn(bin, args, { stdio: 'ignore' });
-      p.on('error', rej);
-      p.on('exit', (c) => {
-        if (c === 0) res();
-        else rej(new Error(`${bin} ${String(c)}`));
-      });
-    });
+  if (!existsSync(WHISPER_MODEL)) return;
+  const dir = mkdtempSync(join(tmpdir(), 'xmtp-tx-'));
+  const inFile = join(dir, 'in.m4a');
+  const wav = join(dir, 'in.wav');
+  const out = join(dir, 'in');
   try {
-    wf(inFile, audio);
-    await run(FFMPEG_BIN, [
-      '-y',
-      '-i',
-      inFile,
-      '-ar',
-      '16000',
-      '-ac',
-      '1',
-      wav,
-    ]);
-    await run(WHISPER_BIN, [
-      '-m',
-      WHISPER_MODEL,
-      '-f',
-      wav,
-      '--output-txt',
-      '-of',
-      out,
-    ]);
-    const text = rf(`${out}.txt`, 'utf8').trim();
+    writeFileSync(inFile, audio);
+    await run(FFMPEG_BIN, ['-y', '-i', inFile, '-ar', '16000', '-ac', '1', wav]);
+    await run(WHISPER_BIN, ['-m', WHISPER_MODEL, '-f', wav, '--output-txt', '-of', out]);
+    const text = readFileSync(`${out}.txt`, 'utf8').trim();
     if (!text) return;
     emitInbound(accountId, {
       id: mintId(),

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

@@ -5,7 +5,8 @@ import {
   TransactionReferenceCodec,
   WalletSendCallsCodec,
 } from './codecs.js';
-import { bad, isNode, parseJson } from './frames.js';
+import { isRecord } from '@metro-labs/core/is-record';
+import { bad, parseJson } from './frames.js';
 
 const WALLET_TYPES: Record<string, { codec: { encode(c: Record<string, unknown>): EncodedContent }; needs: string[] }> = {
   walletSendCalls: { codec: new WalletSendCallsCodec(), needs: ['version', 'chainId', 'from', 'calls'] },
@@ -16,11 +17,11 @@ const WALLET_TYPES: Record<string, { codec: { encode(c: Record<string, unknown>)
 
 export function buildWalletContent(raw: unknown): { encoded: EncodedContent; summary: string } {
   const args = parseJson(raw, 'wallet');
-  const type = isNode(args) && typeof args.type === 'string' ? args.type : '';
+  const type = isRecord(args) && typeof args.type === 'string' ? args.type : '';
   const spec = Object.hasOwn(WALLET_TYPES, type) ? WALLET_TYPES[type] : undefined;
-  if (!isNode(args) || !spec) throw bad(`wallet type must be one of ${Object.keys(WALLET_TYPES).join(', ')}`);
+  if (!isRecord(args) || !spec) throw bad(`wallet type must be one of ${Object.keys(WALLET_TYPES).join(', ')}`);
   const content = parseJson(args.content, 'wallet content');
-  if (!isNode(content)) throw bad(`wallet content must be the ${type} JSON object`);
+  if (!isRecord(content)) throw bad(`wallet content must be the ${type} JSON object`);
   const missing = spec.needs.filter((key) => content[key] === undefined);
   if (missing.length > 0) throw bad(`${type} content needs ${missing.join(', ')}`);
   const encoded = spec.codec.encode(content);

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

@@ -4,12 +4,18 @@ const uidToXmtp = new Map<string, string>();
 const INBOX_ETH_CACHE_MAX = 5000;
 export const inboxEthCache = new Map<string, string>();
 
+const SENT_MAX = 5000;
+const sentIds = new Set<string>();
+
+function dropOldest(held: Map<string, string> | Set<string>, max: number): void {
+  if (held.size <= max) return;
+  const oldest = held.keys().next().value;
+  if (oldest !== undefined) held.delete(oldest);
+}
+
 export function cacheInboxEth(inboxId: string, eth: string): void {
   inboxEthCache.set(inboxId, eth);
-  if (inboxEthCache.size > INBOX_ETH_CACHE_MAX) {
-    const oldest = inboxEthCache.keys().next().value;
-    if (oldest !== undefined) inboxEthCache.delete(oldest);
-  }
+  dropOldest(inboxEthCache, INBOX_ETH_CACHE_MAX);
 }
 
 export function rememberUid(
@@ -18,10 +24,7 @@ export function rememberUid(
 ): void {
   if (!uid || !xmtpId || !uid.startsWith('msg_')) return;
   uidToXmtp.set(uid, xmtpId);
-  if (uidToXmtp.size > UID_MAP_MAX) {
-    const oldest = uidToXmtp.keys().next().value;
-    if (oldest !== undefined) uidToXmtp.delete(oldest);
-  }
+  dropOldest(uidToXmtp, UID_MAP_MAX);
 }
 
 export function resolveMsgId(rawId: string): string {
@@ -34,16 +37,10 @@ export function resolveMsgId(rawId: string): string {
   );
 }
 
-const SENT_MAX = 5000;
-const sentIds = new Set<string>();
-
 export function rememberSent(xmtpId: string | undefined): void {
   if (!xmtpId) return;
   sentIds.add(xmtpId);
-  if (sentIds.size > SENT_MAX) {
-    const oldest = sentIds.values().next().value;
-    if (oldest !== undefined) sentIds.delete(oldest);
-  }
+  dropOldest(sentIds, SENT_MAX);
 }
 
 export const sentByMe = (xmtpId: string): boolean => sentIds.has(xmtpId);

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.324"
+  "version": "0.1.0-beta.326"
 }

package/runtime/sdk-runner/node_modules/@metro-labs/core/src/automation-store.ts

@@ -8,7 +8,7 @@ import {
 } from './automation-types.js';
 import { isRecord } from './is-record.js';
 
-export type { AutomationOutcome, AutomationRequest, AutomationResolution, AutomationStatus, AutomationState, AutomationUuid } from './automation-types.js';
+export type { AutomationOutcome, AutomationRequest, AutomationResolution, AutomationStatus } from './automation-types.js';
 
 function payload<T extends { uuid: string }>(row: unknown, parse: (value: unknown) => T): T {
   try {

package/runtime/sdk-runner/node_modules/@metro-labs/core/src/automation-types.ts

@@ -5,7 +5,7 @@ export const AUTOMATION_PROMPT_MAX = 64 * 1024;
 const PROMPT_JSON_MAX = 128 * 1024 + 2;
 export const AUTOMATION_REQUEST_MAX = 512;
 export const AUTOMATION_RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
-export const AUTOMATION_ROUTINE_RE = /^[a-z][a-z0-9-]{0,63}$/;
+const AUTOMATION_ROUTINE_RE = /^[a-z][a-z0-9-]{0,63}$/;
 const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
 const STATES = ['dispatched', 'consumed', 'awaiting-completion', 'completed', 'failed', 'interrupted', 'coalesced', 'cancelled'] as const;
 const DETAILS = ['sdk-completed', 'sdk-failed', 'runner-interrupted', 'newer-slot', 'owner-cancelled', 'worker-blocked', 'worker-completed'] as const;
@@ -29,7 +29,7 @@ const ERRORS = {
 
 export type AutomationUuid = `${string}-${string}-${string}-${string}-${string}`;
 export type AutomationState = (typeof STATES)[number];
-export type AutomationDetail = (typeof DETAILS)[number];
+type AutomationDetail = (typeof DETAILS)[number];
 export type AutomationOutcome = 'completed' | 'blocked';
 export type AutomationErrorCode = keyof typeof ERRORS;
 

package/runtime/sdk-runner/node_modules/@metro-labs/core/src/lines.ts

@@ -2,8 +2,6 @@ export type Line = string & { readonly __line: unique symbol };
 export const asLine = (s: string): Line => s as Line;
 
 const PREFIX = 'metro://';
-const build = (station: string, ...seg: (string | number)[]): Line =>
-  asLine(`${PREFIX}${station}/${seg.map(String).join('/')}`);
 
 function parseAccountScoped(
   line: Line | string,
@@ -42,11 +40,7 @@ function parseTelegramLine(
 }
 
 export const Line = {
-  claude: (orgId: string, sessionId: string): Line =>
-    build('claude', orgId, sessionId),
-  webhook: (endpointId: string): Line => build('webhook', endpointId),
-  user: (station: string, id: string | number): Line =>
-    build(station, 'user', id),
+  webhook: (endpointId: string): Line => asLine(`${PREFIX}webhook/${endpointId}`),
 
   parse(line: Line | string): { station: string; path: string[] } | null {
     if (!line.startsWith(PREFIX)) return null;
@@ -68,7 +62,7 @@ export const Line = {
   parseDiscord: (line: Line | string) =>
     parseAccountScoped(line, 'discord-bot', isSnowflake),
 
-  parseTelegram: (line: Line | string) => parseTelegramLine(line),
+  parseTelegram: parseTelegramLine,
 
   parseThreema: (line: Line | string) =>
     parseAccountScoped(line, 'threema', isThreemaResource),

package/runtime/sdk-runner/node_modules/@metro-labs/core/src/protocol.ts

@@ -5,12 +5,6 @@ import { coerceErrorInfo, type TrainErrorInfo } from './train-error.js';
 import type { StructuredEvent } from './events.js';
 import type { CallMsg } from './stations/station-runtime.js';
 
-export {
-  TrainError,
-  serializeTrainError,
-  type TrainErrorInfo,
-} from './train-error.js';
-
 const CALL_TIMEOUT_MS = 60_000;
 
 export interface Pending {

package/runtime/sdk-runner/node_modules/@metro-labs/core/src/skill-source.ts

@@ -15,7 +15,7 @@ export interface SkillSource {
   folder: string;
 }
 
-export interface SkillFile {
+interface SkillFile {
   path: string;
   size: number;
   sha256: string;

package/runtime/sdk-runner/node_modules/@metro-labs/core/src/stations/account-status.ts

@@ -1,6 +1,6 @@
 import { isRecord } from '../is-record.js';
 
-export const ACCOUNT_STATES = ['connected', 'connecting', 'logged_out', 'disconnected'] as const;
+const ACCOUNT_STATES = ['connected', 'connecting', 'logged_out', 'disconnected'] as const;
 
 export type AccountState = (typeof ACCOUNT_STATES)[number];
 

package/runtime/sdk-runner/node_modules/@metro-labs/core/src/stations/attachments.ts

@@ -1,3 +1,7 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, open, rename, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
 export const attachDir = (): string =>
   process.env.METRO_XMTP_ATTACH_DIR ??
   `${process.env.HOME}/.cache/metro/messenger-uploads`;
@@ -89,14 +93,9 @@ const cachePathFor = async (
   index: number,
   meta: { mime?: string; name?: string },
 ): Promise<string> => {
-  const { mkdir } = await import('node:fs/promises');
-  const nodePath = await import('node:path');
   const dir = attachDir();
   await mkdir(dir, { recursive: true });
-  return nodePath.join(
-    dir,
-    cacheFileName(messageId, index, meta.name, meta.mime),
-  );
+  return join(dir, cacheFileName(messageId, index, meta.name, meta.mime));
 };
 
 export const saveBufferToCache = async (
@@ -106,8 +105,6 @@ export const saveBufferToCache = async (
   meta: { mime?: string; name?: string },
 ): Promise<SavedAttachment> => {
   assertAttachmentSize(data.length);
-  const { writeFile, rename, rm } = await import('node:fs/promises');
-  const { randomUUID } = await import('node:crypto');
   const path = await cachePathFor(messageId, index, meta);
   const part = `${await cachePathFor(randomUUID(), index, meta)}.part`;
   try {
@@ -125,7 +122,6 @@ export const saveStreamToCache = async (
   index: number,
   meta: { mime?: string; name?: string },
 ): Promise<SavedAttachment> => {
-  const { open, rename, rm } = await import('node:fs/promises');
   const path = await cachePathFor(messageId, index, meta);
   const part = `${path}.part`;
   const handle = await open(part, 'w');

package/runtime/sdk-runner/node_modules/@metro-labs/core/src/stations/channel-directory.ts

@@ -14,7 +14,7 @@ export interface ChannelEntry {
   kind: 'direct' | 'group' | 'channel' | 'thread';
 }
 
-export interface ChannelCapability {
+interface ChannelCapability {
   supported: boolean;
   complete: boolean;
   source: 'remote' | 'local' | 'mixed' | 'unsupported';