@pome-sh/cli 0.21.12 → 0.21.14

package/dist/{src-RUUCDQU4.js → src-MX3THU4R.js}

@@ -1,5 +1,6 @@
 export { SLACK_CHECKS } from './chunk-LH4EGGQW.js';
 import './chunk-NY55QTVQ.js';
+import { declareRouteInputs, booleanInput, integerInput, mountDeclaredRoute, UndeclaredInputError } from './chunk-4MQULI7E.js';
 import { loadMcpToolFixture, defineTwin, queryTokenResolver, formTokenResolver, deriveMcpToolTable, UnknownToolError, openTwinDatabase, createApp } from './chunk-TV5S6WQV.js';
 import './chunk-VBATFCWR.js';
 import './chunk-SG6ZTIMT.js';
@@ -246,6 +247,9 @@ function slackError(code, status = 400, extra) {
 function notFound(code = "not_found") {
   throw new TwinError(code, 404, code);
 }
+function validationFailed(code = "invalid_arguments", extra) {
+  throw new TwinError(code, 400, code, extra);
+}
 function isSqliteConstraintError(err) {
   if (!err || typeof err !== "object")
     return false;
@@ -305,44 +309,6 @@ function coerceFormValues(raw) {
   }
   return out;
 }
-function asString(value, fallback = "") {
-  if (typeof value === "string")
-    return value;
-  if (value === void 0 || value === null)
-    return fallback;
-  return String(value);
-}
-function asOptionalString(value) {
-  if (typeof value !== "string")
-    return void 0;
-  if (value.length === 0)
-    return void 0;
-  return value;
-}
-function asNumber(value, fallback) {
-  if (typeof value === "number" && Number.isFinite(value))
-    return value;
-  if (typeof value === "string" && value.length > 0) {
-    const parsed = Number(value);
-    if (Number.isFinite(parsed))
-      return parsed;
-  }
-  return fallback;
-}
-function asBool(value, fallback = false) {
-  if (typeof value === "boolean")
-    return value;
-  if (typeof value === "string") {
-    const v = value.toLowerCase().trim();
-    if (v === "1" || v === "true" || v === "yes")
-      return true;
-    if (v === "0" || v === "false" || v === "no")
-      return false;
-  }
-  if (typeof value === "number")
-    return value !== 0;
-  return fallback;
-}
 function cursorEncode(payload) {
   return Buffer.from(JSON.stringify(payload), "utf8").toString("base64url");
 }
@@ -2285,191 +2251,401 @@ var SlackDomain = class {
     return row?.name ?? id;
   }
 };
+var AMBIENT_INPUTS = { token: z.string().optional() };
+function slackRead(path, args) {
+  const shape = { ...AMBIENT_INPUTS, ...args };
+  return {
+    get: declareRouteInputs({ method: "GET", path, query: shape }),
+    post: declareRouteInputs({ method: "POST", path, body: shape, bodyEncoding: "form" })
+  };
+}
+function slackWrite(path, args) {
+  const shape = { ...AMBIENT_INPUTS, ...args };
+  return declareRouteInputs({ method: "POST", path, body: shape, bodyEncoding: "form" });
+}
+var emptyIfAbsent = () => z.string().default("");
+var absentIfEmpty = () => z.string().optional().transform((value) => value ? value : void 0);
+var falseIfAbsent = () => booleanInput.default(false);
+var optionalInteger = () => integerInput().optional();
+var zeroIfAbsent = () => integerInput().default(0);
+var opaque = () => z.unknown().optional();
+var SLACK_READS = {
+  authTest: slackRead("/auth.test", {}),
+  conversationsList: slackRead("/conversations.list", {
+    types: absentIfEmpty(),
+    exclude_archived: falseIfAbsent(),
+    limit: optionalInteger(),
+    cursor: absentIfEmpty(),
+    team_id: absentIfEmpty()
+  }),
+  // `channel` is read with `asOptionalString` and the handler raises Slack's own
+  // `channel_not_found` when it is absent, so the schema stays optional.
+  conversationsInfo: slackRead("/conversations.info", {
+    channel: absentIfEmpty(),
+    include_num_members: falseIfAbsent()
+  }),
+  conversationsMembers: slackRead("/conversations.members", {
+    channel: emptyIfAbsent(),
+    limit: optionalInteger(),
+    cursor: absentIfEmpty()
+  }),
+  conversationsHistory: slackRead("/conversations.history", {
+    channel: emptyIfAbsent(),
+    cursor: absentIfEmpty(),
+    inclusive: falseIfAbsent(),
+    latest: absentIfEmpty(),
+    limit: optionalInteger(),
+    oldest: absentIfEmpty()
+  }),
+  conversationsReplies: slackRead("/conversations.replies", {
+    channel: emptyIfAbsent(),
+    ts: emptyIfAbsent(),
+    cursor: absentIfEmpty(),
+    inclusive: falseIfAbsent(),
+    latest: absentIfEmpty(),
+    limit: optionalInteger(),
+    oldest: absentIfEmpty()
+  }),
+  reactionsGet: slackRead("/reactions.get", {
+    channel: emptyIfAbsent(),
+    timestamp: emptyIfAbsent(),
+    full: falseIfAbsent()
+  }),
+  usersList: slackRead("/users.list", {
+    cursor: absentIfEmpty(),
+    limit: optionalInteger(),
+    include_locale: falseIfAbsent(),
+    team_id: absentIfEmpty()
+  }),
+  usersInfo: slackRead("/users.info", {
+    user: emptyIfAbsent(),
+    include_locale: falseIfAbsent()
+  }),
+  usersLookupByEmail: slackRead("/users.lookupByEmail", { email: emptyIfAbsent() }),
+  usersProfileGet: slackRead("/users.profile.get", {
+    user: absentIfEmpty(),
+    include_labels: falseIfAbsent()
+  }),
+  pinsList: slackRead("/pins.list", { channel: emptyIfAbsent() }),
+  searchMessages: slackRead("/search.messages", {
+    query: emptyIfAbsent(),
+    count: optionalInteger(),
+    page: optionalInteger(),
+    sort: absentIfEmpty(),
+    sort_dir: absentIfEmpty(),
+    highlight: falseIfAbsent()
+  }),
+  filesInfo: slackRead("/files.info", { file: emptyIfAbsent() }),
+  filesList: slackRead("/files.list", {
+    channel: absentIfEmpty(),
+    user: absentIfEmpty(),
+    count: optionalInteger(),
+    page: optionalInteger(),
+    types: absentIfEmpty()
+  }),
+  bookmarksList: slackRead("/bookmarks.list", { channel_id: emptyIfAbsent() }),
+  teamInfo: slackRead("/team.info", { team: absentIfEmpty() }),
+  // `domain.emojiList` reads no argument at all, and the pre-F-1179 handler
+  // forwarded the whole merged bag — the silent hole this ticket exists to
+  // close. `include_categories` is what Slack's `emoji.list` declares beyond
+  // `token`, so that is the surface, and an unnamed argument is now refused.
+  emojiList: slackRead("/emoji.list", { include_categories: falseIfAbsent() })
+};
+var SLACK_WRITES = {
+  conversationsCreate: slackWrite("/conversations.create", {
+    name: emptyIfAbsent(),
+    is_private: falseIfAbsent(),
+    team_id: absentIfEmpty()
+  }),
+  conversationsArchive: slackWrite("/conversations.archive", { channel: emptyIfAbsent() }),
+  conversationsInvite: slackWrite("/conversations.invite", {
+    channel: emptyIfAbsent(),
+    users: emptyIfAbsent()
+  }),
+  conversationsJoin: slackWrite("/conversations.join", { channel: emptyIfAbsent() }),
+  conversationsLeave: slackWrite("/conversations.leave", { channel: emptyIfAbsent() }),
+  conversationsKick: slackWrite("/conversations.kick", {
+    channel: emptyIfAbsent(),
+    user: emptyIfAbsent()
+  }),
+  conversationsOpen: slackWrite("/conversations.open", {
+    users: absentIfEmpty(),
+    channel: absentIfEmpty(),
+    return_im: falseIfAbsent()
+  }),
+  conversationsSetTopic: slackWrite("/conversations.setTopic", {
+    channel: emptyIfAbsent(),
+    topic: emptyIfAbsent()
+  }),
+  conversationsSetPurpose: slackWrite("/conversations.setPurpose", {
+    channel: emptyIfAbsent(),
+    purpose: emptyIfAbsent()
+  }),
+  chatPostMessage: slackWrite("/chat.postMessage", {
+    channel: emptyIfAbsent(),
+    text: absentIfEmpty(),
+    blocks: absentIfEmpty(),
+    attachments: absentIfEmpty(),
+    thread_ts: absentIfEmpty(),
+    reply_broadcast: falseIfAbsent(),
+    icon_emoji: absentIfEmpty(),
+    icon_url: absentIfEmpty(),
+    username: absentIfEmpty(),
+    as_user: falseIfAbsent()
+  }),
+  chatUpdate: slackWrite("/chat.update", {
+    channel: emptyIfAbsent(),
+    ts: emptyIfAbsent(),
+    text: absentIfEmpty(),
+    blocks: absentIfEmpty(),
+    attachments: absentIfEmpty()
+  }),
+  chatDelete: slackWrite("/chat.delete", {
+    channel: emptyIfAbsent(),
+    ts: emptyIfAbsent()
+  }),
+  chatScheduleMessage: slackWrite("/chat.scheduleMessage", {
+    channel: emptyIfAbsent(),
+    text: emptyIfAbsent(),
+    post_at: zeroIfAbsent(),
+    thread_ts: absentIfEmpty(),
+    blocks: absentIfEmpty()
+  }),
+  chatDeleteScheduledMessage: slackWrite("/chat.deleteScheduledMessage", {
+    channel: emptyIfAbsent(),
+    scheduled_message_id: emptyIfAbsent()
+  }),
+  reactionsAdd: slackWrite("/reactions.add", {
+    channel: emptyIfAbsent(),
+    timestamp: emptyIfAbsent(),
+    name: emptyIfAbsent()
+  }),
+  reactionsRemove: slackWrite("/reactions.remove", {
+    channel: emptyIfAbsent(),
+    timestamp: emptyIfAbsent(),
+    name: emptyIfAbsent()
+  }),
+  usersProfileSet: slackWrite("/users.profile.set", {
+    user: absentIfEmpty(),
+    profile: absentIfEmpty(),
+    name: absentIfEmpty(),
+    value: absentIfEmpty()
+  }),
+  pinsAdd: slackWrite("/pins.add", {
+    channel: emptyIfAbsent(),
+    timestamp: emptyIfAbsent()
+  }),
+  pinsRemove: slackWrite("/pins.remove", {
+    channel: emptyIfAbsent(),
+    timestamp: emptyIfAbsent()
+  }),
+  filesUpload: slackWrite("/files.upload", {
+    channels: absentIfEmpty(),
+    channel: absentIfEmpty(),
+    filename: absentIfEmpty(),
+    title: absentIfEmpty(),
+    filetype: absentIfEmpty(),
+    content: absentIfEmpty(),
+    initial_comment: absentIfEmpty(),
+    thread_ts: absentIfEmpty()
+  }),
+  filesDelete: slackWrite("/files.delete", { file: emptyIfAbsent() }),
+  bookmarksAdd: slackWrite("/bookmarks.add", {
+    channel_id: emptyIfAbsent(),
+    title: emptyIfAbsent(),
+    type: absentIfEmpty(),
+    link: absentIfEmpty(),
+    emoji: absentIfEmpty(),
+    entity_id: absentIfEmpty()
+  }),
+  bookmarksRemove: slackWrite("/bookmarks.remove", {
+    channel_id: emptyIfAbsent(),
+    bookmark_id: emptyIfAbsent()
+  }),
+  canvasesCreate: slackWrite("/canvases.create", {
+    title: absentIfEmpty(),
+    document_content: opaque(),
+    channel_id: absentIfEmpty()
+  }),
+  canvasesEdit: slackWrite("/canvases.edit", {
+    canvas_id: emptyIfAbsent(),
+    changes: opaque()
+  }),
+  canvasesDelete: slackWrite("/canvases.delete", { canvas_id: emptyIfAbsent() })
+};
+[
+  ...Object.values(SLACK_READS).flatMap((surfaces) => [surfaces.get, surfaces.post]),
+  ...Object.values(SLACK_WRITES)
+];
 
 // ../packages/twin-slack/dist/src/routes.js
-async function readArgs(c) {
-  const method = c.req.method.toUpperCase();
-  if (method === "GET" || method === "HEAD") {
-    return { ...c.req.query() };
-  }
-  const body = await parseFormOrJson(c);
-  return { ...c.req.query(), ...body };
-}
 function actorFrom(c) {
   const session = c.get("session");
   return { login: typeof session?.login === "string" ? session.login : void 0 };
 }
-var optNum = (value, fallback) => value === void 0 ? void 0 : asNumber(value, fallback);
+async function parseDeclared(declaration, c) {
+  try {
+    return await declaration.parse(c.req);
+  } catch (error) {
+    if (error instanceof UndeclaredInputError) {
+      validationFailed("invalid_arguments", {
+        response_metadata: { messages: [error.message] }
+      });
+    }
+    throw error;
+  }
+}
 function registerSlackRoutes(app, { domain, recorder }) {
-  const read = (path, call) => {
-    const handler = recorder.handle({ mutation: false }, async (c) => ({
+  const read = (surfaces, call) => {
+    mountDeclaredRoute(app, surfaces.get, recorder.handle({ mutation: false }, async (c) => ({
       status: 200,
-      body: slackOk(call(await readArgs(c), actorFrom(c)))
-    }));
-    app.get(path, handler);
-    app.post(path, handler);
+      body: slackOk(call((await parseDeclared(surfaces.get, c)).query, actorFrom(c)))
+    })));
+    mountDeclaredRoute(app, surfaces.post, recorder.handle({ mutation: false }, async (c) => ({
+      status: 200,
+      body: slackOk(call((await parseDeclared(surfaces.post, c)).body, actorFrom(c)))
+    })));
   };
-  const write = (path, call, mutated = () => true) => {
-    app.post(path, recorder.handle({ mutation: true }, async (c) => {
+  const write = (declaration, call, mutated = () => true) => {
+    mountDeclaredRoute(app, declaration, recorder.handle({ mutation: true }, async (c) => {
       let delta = null;
-      const result = call(await readArgs(c), actorFrom(c), (d) => {
+      const inputs = await parseDeclared(declaration, c);
+      const result = call(inputs.body, actorFrom(c), (d) => {
         delta = d;
       });
       return { status: 200, body: slackOk(result), delta, mutation: mutated(result) };
     }));
   };
-  read("/auth.test", (_args, actor) => domain.authTest(actor));
-  read("/conversations.list", (args) => domain.conversationsList({
-    types: asOptionalString(args.types),
-    exclude_archived: asBool(args.exclude_archived, false),
-    limit: optNum(args.limit, 100),
-    cursor: asOptionalString(args.cursor),
-    team_id: asOptionalString(args.team_id)
+  read(SLACK_READS.authTest, (_args, actor) => domain.authTest(actor));
+  read(SLACK_READS.conversationsList, (args) => domain.conversationsList({
+    types: args.types,
+    exclude_archived: args.exclude_archived,
+    limit: args.limit,
+    cursor: args.cursor,
+    team_id: args.team_id
   }));
-  read("/conversations.info", (args, actor) => {
-    const channel = asOptionalString(args.channel);
-    if (!channel)
+  read(SLACK_READS.conversationsInfo, (args, actor) => {
+    if (!args.channel)
       throw new TwinError("channel_not_found", 400, "channel_not_found");
-    return domain.conversationsInfo({ channel, include_num_members: asBool(args.include_num_members, false) }, actor);
+    return domain.conversationsInfo({ channel: args.channel, include_num_members: args.include_num_members }, actor);
   });
-  write("/conversations.create", (args, actor, delta) => domain.conversationsCreate({
-    name: asString(args.name),
-    is_private: asBool(args.is_private, false),
-    team_id: asOptionalString(args.team_id)
-  }, actor, delta));
-  write("/conversations.archive", (args, actor, delta) => domain.conversationsArchive({ channel: asString(args.channel) }, actor, delta));
-  write("/conversations.invite", (args, actor, delta) => domain.conversationsInvite({ channel: asString(args.channel), users: asString(args.users) }, actor, delta));
-  write("/conversations.join", (args, actor, delta) => domain.conversationsJoin({ channel: asString(args.channel) }, actor, delta));
-  write("/conversations.leave", (args, actor, delta) => domain.conversationsLeave({ channel: asString(args.channel) }, actor, delta));
-  write("/conversations.kick", (args, actor, delta) => domain.conversationsKick({ channel: asString(args.channel), user: asString(args.user) }, actor, delta));
-  read("/conversations.members", (args, actor) => domain.conversationsMembers({
-    channel: asString(args.channel),
-    limit: optNum(args.limit, 100),
-    cursor: asOptionalString(args.cursor)
-  }, actor));
-  read("/conversations.history", (args, actor) => domain.conversationsHistory({
-    channel: asString(args.channel),
-    cursor: asOptionalString(args.cursor),
-    inclusive: asBool(args.inclusive, false),
-    latest: asOptionalString(args.latest),
-    limit: optNum(args.limit, 100),
-    oldest: asOptionalString(args.oldest)
+  write(SLACK_WRITES.conversationsCreate, (args, actor, delta) => domain.conversationsCreate({ name: args.name, is_private: args.is_private, team_id: args.team_id }, actor, delta));
+  write(SLACK_WRITES.conversationsArchive, (args, actor, delta) => domain.conversationsArchive({ channel: args.channel }, actor, delta));
+  write(SLACK_WRITES.conversationsInvite, (args, actor, delta) => domain.conversationsInvite({ channel: args.channel, users: args.users }, actor, delta));
+  write(SLACK_WRITES.conversationsJoin, (args, actor, delta) => domain.conversationsJoin({ channel: args.channel }, actor, delta));
+  write(SLACK_WRITES.conversationsLeave, (args, actor, delta) => domain.conversationsLeave({ channel: args.channel }, actor, delta));
+  write(SLACK_WRITES.conversationsKick, (args, actor, delta) => domain.conversationsKick({ channel: args.channel, user: args.user }, actor, delta));
+  read(SLACK_READS.conversationsMembers, (args, actor) => domain.conversationsMembers({ channel: args.channel, limit: args.limit, cursor: args.cursor }, actor));
+  read(SLACK_READS.conversationsHistory, (args, actor) => domain.conversationsHistory({
+    channel: args.channel,
+    cursor: args.cursor,
+    inclusive: args.inclusive,
+    latest: args.latest,
+    limit: args.limit,
+    oldest: args.oldest
   }, actor));
-  read("/conversations.replies", (args, actor) => domain.conversationsReplies({
-    channel: asString(args.channel),
-    ts: asString(args.ts),
-    cursor: asOptionalString(args.cursor),
-    inclusive: asBool(args.inclusive, false),
-    latest: asOptionalString(args.latest),
-    limit: optNum(args.limit, 100),
-    oldest: asOptionalString(args.oldest)
+  read(SLACK_READS.conversationsReplies, (args, actor) => domain.conversationsReplies({
+    channel: args.channel,
+    ts: args.ts,
+    cursor: args.cursor,
+    inclusive: args.inclusive,
+    latest: args.latest,
+    limit: args.limit,
+    oldest: args.oldest
   }, actor));
-  write("/conversations.open", (args, actor, delta) => domain.conversationsOpen({
-    users: asOptionalString(args.users),
-    channel: asOptionalString(args.channel),
-    return_im: asBool(args.return_im, false)
-  }, actor, delta), (result) => !result.already_open);
-  write("/conversations.setTopic", (args, actor, delta) => domain.conversationsSetTopic({ channel: asString(args.channel), topic: asString(args.topic) }, actor, delta));
-  write("/conversations.setPurpose", (args, actor, delta) => domain.conversationsSetPurpose({ channel: asString(args.channel), purpose: asString(args.purpose) }, actor, delta));
-  write("/chat.postMessage", (args, actor, delta) => domain.chatPostMessage({
-    channel: asString(args.channel),
-    text: asOptionalString(args.text),
-    blocks: asOptionalString(args.blocks),
-    attachments: asOptionalString(args.attachments),
-    thread_ts: asOptionalString(args.thread_ts),
-    reply_broadcast: asBool(args.reply_broadcast, false),
-    icon_emoji: asOptionalString(args.icon_emoji),
-    icon_url: asOptionalString(args.icon_url),
-    username: asOptionalString(args.username),
-    as_user: asBool(args.as_user, false)
+  write(SLACK_WRITES.conversationsOpen, (args, actor, delta) => domain.conversationsOpen({ users: args.users, channel: args.channel, return_im: args.return_im }, actor, delta), (result) => !result.already_open);
+  write(SLACK_WRITES.conversationsSetTopic, (args, actor, delta) => domain.conversationsSetTopic({ channel: args.channel, topic: args.topic }, actor, delta));
+  write(SLACK_WRITES.conversationsSetPurpose, (args, actor, delta) => domain.conversationsSetPurpose({ channel: args.channel, purpose: args.purpose }, actor, delta));
+  write(SLACK_WRITES.chatPostMessage, (args, actor, delta) => domain.chatPostMessage({
+    channel: args.channel,
+    text: args.text,
+    blocks: args.blocks,
+    attachments: args.attachments,
+    thread_ts: args.thread_ts,
+    reply_broadcast: args.reply_broadcast,
+    icon_emoji: args.icon_emoji,
+    icon_url: args.icon_url,
+    username: args.username,
+    as_user: args.as_user
   }, actor, delta));
-  write("/chat.update", (args, actor, delta) => domain.chatUpdate({
-    channel: asString(args.channel),
-    ts: asString(args.ts),
-    text: asOptionalString(args.text),
-    blocks: asOptionalString(args.blocks),
-    attachments: asOptionalString(args.attachments)
+  write(SLACK_WRITES.chatUpdate, (args, actor, delta) => domain.chatUpdate({
+    channel: args.channel,
+    ts: args.ts,
+    text: args.text,
+    blocks: args.blocks,
+    attachments: args.attachments
   }, actor, delta));
-  write("/chat.delete", (args, actor, delta) => domain.chatDelete({ channel: asString(args.channel), ts: asString(args.ts) }, actor, delta));
-  write("/chat.scheduleMessage", (args, actor, delta) => domain.chatScheduleMessage({
-    channel: asString(args.channel),
-    text: asString(args.text),
-    post_at: asNumber(args.post_at, 0),
-    thread_ts: asOptionalString(args.thread_ts),
-    blocks: asOptionalString(args.blocks)
+  write(SLACK_WRITES.chatDelete, (args, actor, delta) => domain.chatDelete({ channel: args.channel, ts: args.ts }, actor, delta));
+  write(SLACK_WRITES.chatScheduleMessage, (args, actor, delta) => domain.chatScheduleMessage({
+    channel: args.channel,
+    text: args.text,
+    post_at: args.post_at,
+    thread_ts: args.thread_ts,
+    blocks: args.blocks
   }, actor, delta));
-  write("/chat.deleteScheduledMessage", (args, actor, delta) => domain.chatDeleteScheduledMessage({ channel: asString(args.channel), scheduled_message_id: asString(args.scheduled_message_id) }, actor, delta));
-  write("/reactions.add", (args, actor, delta) => domain.reactionsAdd({ channel: asString(args.channel), timestamp: asString(args.timestamp), name: asString(args.name) }, actor, delta));
-  write("/reactions.remove", (args, actor, delta) => domain.reactionsRemove({ channel: asString(args.channel), timestamp: asString(args.timestamp), name: asString(args.name) }, actor, delta));
-  read("/reactions.get", (args, actor) => domain.reactionsGet({
-    channel: asString(args.channel),
-    timestamp: asString(args.timestamp),
-    full: asBool(args.full, false)
-  }, actor));
-  read("/users.list", (args) => domain.usersList({
-    cursor: asOptionalString(args.cursor),
-    limit: optNum(args.limit, 100),
-    include_locale: asBool(args.include_locale, false),
-    team_id: asOptionalString(args.team_id)
+  write(SLACK_WRITES.chatDeleteScheduledMessage, (args, actor, delta) => domain.chatDeleteScheduledMessage({ channel: args.channel, scheduled_message_id: args.scheduled_message_id }, actor, delta));
+  write(SLACK_WRITES.reactionsAdd, (args, actor, delta) => domain.reactionsAdd({ channel: args.channel, timestamp: args.timestamp, name: args.name }, actor, delta));
+  write(SLACK_WRITES.reactionsRemove, (args, actor, delta) => domain.reactionsRemove({ channel: args.channel, timestamp: args.timestamp, name: args.name }, actor, delta));
+  read(SLACK_READS.reactionsGet, (args, actor) => domain.reactionsGet({ channel: args.channel, timestamp: args.timestamp, full: args.full }, actor));
+  read(SLACK_READS.usersList, (args) => domain.usersList({
+    cursor: args.cursor,
+    limit: args.limit,
+    include_locale: args.include_locale,
+    team_id: args.team_id
   }));
-  read("/users.info", (args) => domain.usersInfo({ user: asString(args.user), include_locale: asBool(args.include_locale, false) }));
-  read("/users.lookupByEmail", (args) => domain.usersLookupByEmail({ email: asString(args.email) }));
-  read("/users.profile.get", (args, actor) => domain.usersProfileGet({ user: asOptionalString(args.user), include_labels: asBool(args.include_labels, false) }, actor));
-  write("/users.profile.set", (args, actor, delta) => domain.usersProfileSet({
-    user: asOptionalString(args.user),
-    profile: asOptionalString(args.profile),
-    name: asOptionalString(args.name),
-    value: asOptionalString(args.value)
-  }, actor, delta));
-  write("/pins.add", (args, actor, delta) => domain.pinsAdd({ channel: asString(args.channel), timestamp: asString(args.timestamp) }, actor, delta));
-  write("/pins.remove", (args, actor, delta) => domain.pinsRemove({ channel: asString(args.channel), timestamp: asString(args.timestamp) }, actor, delta));
-  read("/pins.list", (args, actor) => domain.pinsList({ channel: asString(args.channel) }, actor));
-  read("/search.messages", (args, actor) => domain.searchMessages({
-    query: asString(args.query),
-    count: optNum(args.count, 20),
-    page: optNum(args.page, 1),
-    sort: asOptionalString(args.sort),
-    sort_dir: asOptionalString(args.sort_dir),
-    highlight: asBool(args.highlight, false)
+  read(SLACK_READS.usersInfo, (args) => domain.usersInfo({ user: args.user, include_locale: args.include_locale }));
+  read(SLACK_READS.usersLookupByEmail, (args) => domain.usersLookupByEmail({ email: args.email }));
+  read(SLACK_READS.usersProfileGet, (args, actor) => domain.usersProfileGet({ user: args.user, include_labels: args.include_labels }, actor));
+  write(SLACK_WRITES.usersProfileSet, (args, actor, delta) => domain.usersProfileSet({ user: args.user, profile: args.profile, name: args.name, value: args.value }, actor, delta));
+  write(SLACK_WRITES.pinsAdd, (args, actor, delta) => domain.pinsAdd({ channel: args.channel, timestamp: args.timestamp }, actor, delta));
+  write(SLACK_WRITES.pinsRemove, (args, actor, delta) => domain.pinsRemove({ channel: args.channel, timestamp: args.timestamp }, actor, delta));
+  read(SLACK_READS.pinsList, (args, actor) => domain.pinsList({ channel: args.channel }, actor));
+  read(SLACK_READS.searchMessages, (args, actor) => domain.searchMessages({
+    query: args.query,
+    count: args.count,
+    page: args.page,
+    sort: args.sort,
+    sort_dir: args.sort_dir,
+    highlight: args.highlight
   }, actor));
-  write("/files.upload", (args, actor, delta) => domain.filesUpload({
-    channels: asOptionalString(args.channels),
-    channel: asOptionalString(args.channel),
-    filename: asOptionalString(args.filename),
-    title: asOptionalString(args.title),
-    filetype: asOptionalString(args.filetype),
-    content: asOptionalString(args.content),
-    initial_comment: asOptionalString(args.initial_comment),
-    thread_ts: asOptionalString(args.thread_ts)
+  write(SLACK_WRITES.filesUpload, (args, actor, delta) => domain.filesUpload({
+    channels: args.channels,
+    channel: args.channel,
+    filename: args.filename,
+    title: args.title,
+    filetype: args.filetype,
+    content: args.content,
+    initial_comment: args.initial_comment,
+    thread_ts: args.thread_ts
   }, actor, delta));
-  read("/files.info", (args) => domain.filesInfo({ file: asString(args.file) }));
-  read("/files.list", (args) => domain.filesList({
-    channel: asOptionalString(args.channel),
-    user: asOptionalString(args.user),
-    count: optNum(args.count, 100),
-    page: optNum(args.page, 1),
-    types: asOptionalString(args.types)
+  read(SLACK_READS.filesInfo, (args) => domain.filesInfo({ file: args.file }));
+  read(SLACK_READS.filesList, (args) => domain.filesList({
+    channel: args.channel,
+    user: args.user,
+    count: args.count,
+    page: args.page,
+    types: args.types
   }));
-  write("/files.delete", (args, actor, delta) => domain.filesDelete({ file: asString(args.file) }, actor, delta));
-  write("/bookmarks.add", (args, actor, delta) => domain.bookmarksAdd({
-    channel_id: asString(args.channel_id),
-    title: asString(args.title),
-    type: asOptionalString(args.type),
-    link: asOptionalString(args.link),
-    emoji: asOptionalString(args.emoji),
-    entity_id: asOptionalString(args.entity_id)
+  write(SLACK_WRITES.filesDelete, (args, actor, delta) => domain.filesDelete({ file: args.file }, actor, delta));
+  write(SLACK_WRITES.bookmarksAdd, (args, actor, delta) => domain.bookmarksAdd({
+    channel_id: args.channel_id,
+    title: args.title,
+    type: args.type,
+    link: args.link,
+    emoji: args.emoji,
+    entity_id: args.entity_id
   }, actor, delta));
-  write("/bookmarks.remove", (args, actor, delta) => domain.bookmarksRemove({ channel_id: asString(args.channel_id), bookmark_id: asString(args.bookmark_id) }, actor, delta));
-  read("/bookmarks.list", (args) => domain.bookmarksList({ channel_id: asString(args.channel_id) }));
-  read("/team.info", (args) => domain.teamInfo({ team: asOptionalString(args.team) }));
-  write("/canvases.create", (args, actor, delta) => domain.canvasesCreate({
-    title: asOptionalString(args.title),
+  write(SLACK_WRITES.bookmarksRemove, (args, actor, delta) => domain.bookmarksRemove({ channel_id: args.channel_id, bookmark_id: args.bookmark_id }, actor, delta));
+  read(SLACK_READS.bookmarksList, (args) => domain.bookmarksList({ channel_id: args.channel_id }));
+  read(SLACK_READS.teamInfo, (args) => domain.teamInfo({ team: args.team }));
+  write(SLACK_WRITES.canvasesCreate, (args, actor, delta) => domain.canvasesCreate({
+    title: args.title,
     document_content: args.document_content,
-    channel_id: asOptionalString(args.channel_id)
+    channel_id: args.channel_id
   }, actor, delta));
-  write("/canvases.edit", (args, actor, delta) => domain.canvasesEdit({ canvas_id: asString(args.canvas_id), changes: args.changes }, actor, delta));
-  write("/canvases.delete", (args, actor, delta) => domain.canvasesDelete({ canvas_id: asString(args.canvas_id) }, actor, delta));
-  read("/emoji.list", (args) => domain.emojiList(args));
+  write(SLACK_WRITES.canvasesEdit, (args, actor, delta) => domain.canvasesEdit({ canvas_id: args.canvas_id, changes: args.changes }, actor, delta));
+  write(SLACK_WRITES.canvasesDelete, (args, actor, delta) => domain.canvasesDelete({ canvas_id: args.canvas_id }, actor, delta));
+  read(SLACK_READS.emojiList, (args) => domain.emojiList({ include_categories: args.include_categories }));
 }
 
 // ../packages/twin-slack/dist/fixtures/mcp-tools-list.meta.json