@pome-sh/cli 0.21.12 → 0.21.14

package/dist/{src-B63VPRRZ.js → src-WS5PCGRC.js}

@@ -2,6 +2,7 @@ export { GMAIL_CHECKS } from './chunk-EU6SGN7A.js';
 import { gmailErrorEnvelope, gmailSeedSchema, parseSeed, defaultSeedState, notFound, invalidArgument, checkFault, unsupported, validateSearchQuery, SEARCH_MAILBOX_MESSAGE_BUDGET, GmailError, parseSearchQuery, CATEGORY_LABELS, parseDate, parseSize, KNOWN_FIELDS, parseDuration, assertHasOperator } from './chunk-NJ246QPJ.js';
 export { DEFAULT_GMAIL_AGENT_EMAIL, GmailError, SEARCH_MAILBOX_MESSAGE_BUDGET, agentPathInboxMailbox, defaultSeedState, gmailErrorEnvelope, gmailSeedSchema, loadSeedFromEnv, parseSearchQuery, parseSeed, validateSearchQuery } from './chunk-NJ246QPJ.js';
 import './chunk-NY55QTVQ.js';
+import { integerInput, booleanInput, repeatedInput, declareRouteInputs, mountDeclaredRoute, UndeclaredInputError, MalformedBodyError } from './chunk-4MQULI7E.js';
 import { loadMcpToolFixture, deriveMcpToolTable, defineTwin, openTwinDatabase, createApp } from './chunk-TV5S6WQV.js';
 import './chunk-VBATFCWR.js';
 import './chunk-SG6ZTIMT.js';
@@ -2773,26 +2774,8 @@ function isBinary(value) {
 }
 
 // ../packages/twin-gmail/dist/src/rest-common.js
-function emailFromContext(c) {
-  return resolveUserEmail(routeParam(c, "userId"), c.get("session"));
-}
-function routeParam(c, name) {
-  const value = c.req.param(name);
-  if (!value)
-    invalidArgument(`Missing path parameter: ${name}`);
-  return value;
-}
-async function readJsonObject(c) {
-  try {
-    const value = await c.req.json();
-    if (!value || typeof value !== "object" || Array.isArray(value))
-      invalidArgument("Invalid request body");
-    return value;
-  } catch (error) {
-    if (error instanceof GmailError)
-      throw error;
-    invalidArgument("Invalid JSON payload received.");
-  }
+function emailFrom(userId, c) {
+  return resolveUserEmail(userId, c.get("session"));
 }
 function stringField(body, name, required = false) {
   const value = body[name];
@@ -2811,54 +2794,26 @@ function stringArray(body, name, limit = 100) {
   }
   return [...new Set(value)];
 }
-function objectField(body, name, required = false) {
-  const value = body[name];
-  if (value === void 0 && !required)
-    return void 0;
-  if (!value || typeof value !== "object" || Array.isArray(value))
-    invalidArgument(`Invalid ${name}`);
-  return value;
-}
-function booleanQuery(c, name, fallback = false) {
-  const value = c.req.query(name);
-  if (value === void 0)
-    return fallback;
-  if (value === "true")
-    return true;
-  if (value === "false")
-    return false;
-  invalidArgument(`Invalid value for ${name}`);
-}
-function numberQuery(c, name, fallback, max) {
-  const raw = c.req.query(name);
-  if (raw === void 0)
-    return fallback;
-  const value = Number(raw);
-  if (!Number.isInteger(value) || value < 1 || value > max)
-    invalidArgument(`Invalid value for ${name}`);
-  return value;
-}
-function repeatedQuery(c, name) {
-  return new URL(c.req.url).searchParams.getAll(name);
-}
-function messageFormat(c, allowRaw = true) {
-  const raw = (c.req.query("format") ?? "full").toLowerCase();
-  const allowed = allowRaw ? ["minimal", "full", "raw", "metadata"] : ["minimal", "full", "metadata"];
-  if (!allowed.includes(raw))
-    invalidArgument("Invalid format");
-  return raw;
-}
-function rejectUnsupportedQuery(c, names) {
-  for (const name of names) {
-    if (booleanQuery(c, name, false))
+function rejectUnsupportedFlags(flags) {
+  for (const [name, value] of Object.entries(flags)) {
+    if (value)
       unsupported(`${name}=true is not supported by the Gmail twin`);
   }
 }
+function rejectResumable(uploadType) {
+  if (uploadType === "resumable")
+    unsupported("Resumable Gmail uploads are not supported");
+}
 function rejectClassification(body) {
   if (body.addClassificationLabels !== void 0 || body.removeClassificationLabelIds !== void 0) {
     unsupported("Gmail classification labels require Google Drive Labels and are not supported");
   }
 }
+function rejectClassificationValues(resource) {
+  if (resource.classificationLabelValues !== void 0) {
+    unsupported("Gmail classification labels require Google Drive Labels and are not supported");
+  }
+}
 function paginate2(items, options) {
   const offset = options.pageToken ? decodePageToken(options.pageToken, options.binding, options.snapshot) : 0;
   if (offset > items.length)
@@ -2879,146 +2834,407 @@ function asInputError(fn) {
     invalidArgument(error instanceof Error ? error.message : "Invalid request");
   }
 }
-
-// ../packages/twin-gmail/dist/src/rest-upload.js
-async function readMessageWrite(c, draftEnvelope = false) {
-  if (isResumable(c))
-    unsupported("Resumable Gmail uploads are not supported");
-  const contentType = c.req.header("content-type") ?? "";
-  if (/^multipart\/related\b/i.test(contentType)) {
-    const { metadata, media } = await readMultipart(c, contentType);
-    const resource2 = draftEnvelope ? objectField(metadata, "message") ?? metadata : metadata;
-    rejectMessageExtensions(resource2);
-    return {
-      raw: media,
-      threadId: stringField(resource2, "threadId"),
-      id: stringField(metadata, "id"),
-      labelIds: stringList(resource2, "labelIds")
-    };
-  }
-  if (!/^application\/json\b/i.test(contentType) && !/^text\/json\b/i.test(contentType)) {
-    const bytes = Buffer.from(await c.req.arrayBuffer());
-    if (!bytes.length)
-      invalidArgument("MIME message is empty");
-    return { raw: bytes };
-  }
-  const body = await readJsonObject(c);
-  const resource = draftEnvelope ? objectField(body, "message", true) : body;
-  rejectMessageExtensions(resource);
-  return {
-    raw: stringField(resource, "raw", true),
-    threadId: stringField(resource, "threadId"),
-    id: stringField(body, "id"),
-    labelIds: stringList(resource, "labelIds")
-  };
-}
-function rejectMessageExtensions(resource) {
-  if (resource.classificationLabelValues !== void 0) {
-    unsupported("Gmail classification labels require Google Drive Labels and are not supported");
-  }
-}
-function stringList(body, name) {
-  const value = body[name];
-  if (value === void 0)
-    return void 0;
-  if (!Array.isArray(value) || value.length > 100 || value.some((item) => typeof item !== "string")) {
-    invalidArgument(`Invalid ${name}`);
-  }
-  return [...new Set(value)];
-}
-async function readDraftSend(c) {
-  const contentType = c.req.header("content-type") ?? "";
-  if (/^application\/json\b/i.test(contentType) || /^text\/json\b/i.test(contentType)) {
-    const body = await readJsonObject(c);
-    const id = stringField(body, "id");
-    const message = objectField(body, "message");
-    if (!id && !message)
-      invalidArgument("Draft id is required");
-    return {
-      id,
-      ...message ? {
-        message: {
-          raw: stringField(message, "raw", true),
-          threadId: stringField(message, "threadId")
-        }
-      } : {}
-    };
-  }
-  return { message: await readMessageWrite(c, false) };
-}
-function isResumable(c) {
-  return c.req.path.startsWith("/resumable/") || c.req.query("uploadType") === "resumable";
-}
-async function readMultipart(c, contentType) {
-  const boundary = contentType.match(/boundary=(?:"([^"]+)"|([^;\s]+))/i)?.slice(1).find(Boolean);
-  if (!boundary)
-    invalidArgument("Multipart upload is missing a boundary");
-  const bytes = Buffer.from(await c.req.arrayBuffer());
-  const parts = splitMultipart2(bytes, boundary);
-  if (parts.length !== 2)
-    invalidArgument("Multipart upload must contain metadata and MIME media");
-  let metadata;
-  try {
-    metadata = JSON.parse(parts[0].body.toString("utf8"));
-  } catch {
-    invalidArgument("Invalid multipart metadata JSON");
-  }
-  if (!metadata || typeof metadata !== "object" || Array.isArray(metadata))
-    invalidArgument("Invalid multipart metadata JSON");
-  if (!parts[1].body.length)
-    invalidArgument("MIME message is empty");
-  return { metadata, media: parts[1].body };
-}
-function splitMultipart2(bytes, boundary) {
-  return asInputError(() => {
-    const marker = Buffer.from(`--${boundary}`);
-    const endMarker = Buffer.from(`--${boundary}--`);
-    const parts = [];
-    let cursor = 0;
-    while (cursor < bytes.length) {
-      const start = bytes.indexOf(marker, cursor);
-      if (start < 0 || bytes.subarray(start, start + endMarker.length).equals(endMarker))
-        break;
-      const lineEnd = bytes.indexOf(Buffer.from("\n"), start + marker.length);
-      if (lineEnd < 0)
-        throw new Error("Malformed multipart upload");
-      const next = bytes.indexOf(marker, lineEnd + 1);
-      if (next < 0)
-        throw new Error("Malformed multipart upload");
-      let chunk = bytes.subarray(lineEnd + 1, next);
-      while (chunk.length && (chunk.at(-1) === 10 || chunk.at(-1) === 13))
-        chunk = chunk.subarray(0, -1);
-      const crlf = chunk.indexOf(Buffer.from("\r\n\r\n"));
-      const lf = chunk.indexOf(Buffer.from("\n\n"));
-      const separator = crlf >= 0 ? { index: crlf, length: 4 } : { index: lf, length: 2 };
-      if (separator.index < 0)
-        throw new Error("Malformed multipart upload");
-      parts.push({
-        headers: chunk.subarray(0, separator.index).toString("latin1"),
-        body: Buffer.from(chunk.subarray(separator.index + separator.length))
-      });
-      cursor = next;
+var USERS = "/gmail/v1/users/:userId";
+var MESSAGES = `${USERS}/messages`;
+var MESSAGES_UPLOAD = "/upload/gmail/v1/users/:userId/messages";
+var DRAFTS = `${USERS}/drafts`;
+var DRAFTS_UPLOAD = "/upload/gmail/v1/users/:userId/drafts";
+var RESUMABLE = "/resumable/upload/gmail/v1/users/:userId";
+var USER = { userId: z.string().min(1) };
+var USER_ITEM = { ...USER, id: z.string().min(1) };
+var LIST_QUERY = {
+  maxResults: integerInput({ min: 1, max: 500 }).default(100),
+  pageToken: z.string().optional()
+};
+var SEARCH_QUERY = {
+  q: z.string().default(""),
+  includeSpamTrash: booleanInput.default(false)
+};
+var UPLOAD_QUERY = { uploadType: z.string().optional() };
+var MESSAGE_FORMAT_QUERY = {
+  format: z.enum(["minimal", "full", "raw", "metadata"]).default("full"),
+  metadataHeaders: repeatedInput()
+};
+var THREAD_FORMAT_QUERY = {
+  format: z.enum(["minimal", "full", "metadata"]).default("full"),
+  metadataHeaders: repeatedInput()
+};
+var unique = (values) => [...new Set(values)];
+var stringListInput = (max) => z.array(z.string()).max(max).transform(unique).default([]);
+var optionalStringListInput = (max) => z.array(z.string()).max(max).transform(unique).optional();
+var RAW_INPUT = z.union([
+  z.string().min(1),
+  z.instanceof(Uint8Array).refine((bytes) => bytes.byteLength > 0)
+]);
+var CLASSIFICATION_BODY = {
+  addClassificationLabels: z.unknown().optional(),
+  removeClassificationLabelIds: z.unknown().optional()
+};
+var LABEL_MODIFY_BODY = {
+  addLabelIds: stringListInput(100),
+  removeLabelIds: stringListInput(100)
+};
+var MESSAGE_RESOURCE = {
+  raw: RAW_INPUT,
+  threadId: z.string().optional(),
+  labelIds: optionalStringListInput(100),
+  /** Accepted, then answered 501. */
+  classificationLabelValues: z.unknown().optional()
+};
+var MESSAGE_WRITE_BODY = { ...MESSAGE_RESOURCE, id: z.string().optional() };
+var DRAFT_WRITE_BODY = {
+  message: z.object(MESSAGE_RESOURCE),
+  id: z.string().optional()
+};
+var DRAFT_UPDATE_BODY = {
+  message: z.object(MESSAGE_RESOURCE),
+  id: z.string().optional()
+};
+var DRAFT_SEND_BODY = {
+  id: z.string().optional(),
+  message: z.object({ raw: RAW_INPUT, threadId: z.string().optional() }).optional()
+};
+var LABEL_BODY = {
+  color: z.object({ textColor: z.string().optional(), backgroundColor: z.string().optional() }).optional(),
+  type: z.unknown().optional(),
+  labelListVisibility: z.unknown().optional(),
+  messageListVisibility: z.unknown().optional()
+};
+var jsonObjectInput = z.record(z.string(), z.unknown());
+var MESSAGE_SEND_SHAPE = {
+  method: "POST",
+  pathParams: USER,
+  query: UPLOAD_QUERY,
+  bodyEncoding: "media",
+  mediaField: "raw",
+  body: MESSAGE_WRITE_BODY
+};
+var MESSAGE_IMPORT_SHAPE = {
+  method: "POST",
+  pathParams: USER,
+  query: {
+    ...UPLOAD_QUERY,
+    deleted: booleanInput.default(false),
+    processForCalendar: booleanInput.default(false),
+    neverMarkSpam: booleanInput.default(false),
+    internalDateSource: z.enum(["receivedTime", "dateHeader"]).default("dateHeader")
+  },
+  bodyEncoding: "media",
+  mediaField: "raw",
+  body: MESSAGE_WRITE_BODY
+};
+var MESSAGE_INSERT_SHAPE = {
+  method: "POST",
+  pathParams: USER,
+  query: {
+    ...UPLOAD_QUERY,
+    deleted: booleanInput.default(false),
+    internalDateSource: z.enum(["receivedTime", "dateHeader"]).default("receivedTime")
+  },
+  bodyEncoding: "media",
+  mediaField: "raw",
+  body: MESSAGE_WRITE_BODY
+};
+var DRAFT_CREATE_SHAPE = {
+  method: "POST",
+  pathParams: USER,
+  query: UPLOAD_QUERY,
+  bodyEncoding: "media",
+  mediaField: "message.raw",
+  body: DRAFT_WRITE_BODY
+};
+var DRAFT_SEND_SHAPE = {
+  method: "POST",
+  pathParams: USER,
+  query: UPLOAD_QUERY,
+  bodyEncoding: "media",
+  mediaField: "message.raw",
+  body: DRAFT_SEND_BODY
+};
+var DRAFT_UPDATE_SHAPE = {
+  method: "PUT",
+  pathParams: USER_ITEM,
+  query: UPLOAD_QUERY,
+  bodyEncoding: "media",
+  mediaField: "message.raw",
+  body: DRAFT_UPDATE_BODY
+};
+var REFUSED = { method: "POST", pathParams: USER };
+var REFUSED_PUT = { method: "PUT", pathParams: USER };
+var REFUSED_ITEM = { method: "POST", pathParams: USER_ITEM };
+var REFUSED_ITEM_PUT = { method: "PUT", pathParams: USER_ITEM };
+var GMAIL_ROUTES = {
+  // messages
+  listMessages: declareRouteInputs({
+    method: "GET",
+    path: MESSAGES,
+    pathParams: USER,
+    query: { ...SEARCH_QUERY, ...LIST_QUERY, labelIds: repeatedInput() }
+  }),
+  batchModifyMessages: declareRouteInputs({
+    method: "POST",
+    path: `${MESSAGES}/batchModify`,
+    pathParams: USER,
+    bodyEncoding: "json",
+    body: {
+      ids: stringListInput(1e3),
+      ...LABEL_MODIFY_BODY,
+      ...CLASSIFICATION_BODY
     }
-    return parts;
-  });
-}
+  }),
+  batchDeleteMessages: declareRouteInputs({
+    method: "POST",
+    path: `${MESSAGES}/batchDelete`,
+    pathParams: USER,
+    bodyEncoding: "json",
+    body: { ids: stringListInput(1e3) }
+  }),
+  sendMessage: declareRouteInputs({ ...MESSAGE_SEND_SHAPE, path: `${MESSAGES}/send` }),
+  sendMessageUpload: declareRouteInputs({
+    ...MESSAGE_SEND_SHAPE,
+    path: `${MESSAGES_UPLOAD}/send`
+  }),
+  importMessage: declareRouteInputs({ ...MESSAGE_IMPORT_SHAPE, path: `${MESSAGES}/import` }),
+  importMessageUpload: declareRouteInputs({
+    ...MESSAGE_IMPORT_SHAPE,
+    path: `${MESSAGES_UPLOAD}/import`
+  }),
+  insertMessage: declareRouteInputs({ ...MESSAGE_INSERT_SHAPE, path: MESSAGES }),
+  insertMessageUpload: declareRouteInputs({ ...MESSAGE_INSERT_SHAPE, path: MESSAGES_UPLOAD }),
+  getMessage: declareRouteInputs({
+    method: "GET",
+    path: `${MESSAGES}/:id`,
+    pathParams: USER_ITEM,
+    query: MESSAGE_FORMAT_QUERY
+  }),
+  modifyMessage: declareRouteInputs({
+    method: "POST",
+    path: `${MESSAGES}/:id/modify`,
+    pathParams: USER_ITEM,
+    bodyEncoding: "json",
+    body: { ...LABEL_MODIFY_BODY, ...CLASSIFICATION_BODY }
+  }),
+  trashMessage: declareRouteInputs({
+    method: "POST",
+    path: `${MESSAGES}/:id/trash`,
+    pathParams: USER_ITEM
+  }),
+  untrashMessage: declareRouteInputs({
+    method: "POST",
+    path: `${MESSAGES}/:id/untrash`,
+    pathParams: USER_ITEM
+  }),
+  deleteMessage: declareRouteInputs({
+    method: "DELETE",
+    path: `${MESSAGES}/:id`,
+    pathParams: USER_ITEM
+  }),
+  getAttachment: declareRouteInputs({
+    method: "GET",
+    path: `${MESSAGES}/:messageId/attachments/:id`,
+    pathParams: { ...USER_ITEM, messageId: z.string().min(1) }
+  }),
+  resumableInsertMessage: declareRouteInputs({ ...REFUSED, path: `${RESUMABLE}/messages` }),
+  resumableInsertMessagePut: declareRouteInputs({
+    ...REFUSED_PUT,
+    path: `${RESUMABLE}/messages`
+  }),
+  resumableSendMessage: declareRouteInputs({ ...REFUSED, path: `${RESUMABLE}/messages/send` }),
+  resumableSendMessagePut: declareRouteInputs({
+    ...REFUSED_PUT,
+    path: `${RESUMABLE}/messages/send`
+  }),
+  resumableImportMessage: declareRouteInputs({
+    ...REFUSED,
+    path: `${RESUMABLE}/messages/import`
+  }),
+  resumableImportMessagePut: declareRouteInputs({
+    ...REFUSED_PUT,
+    path: `${RESUMABLE}/messages/import`
+  }),
+  // drafts
+  listDrafts: declareRouteInputs({
+    method: "GET",
+    path: DRAFTS,
+    pathParams: USER,
+    query: { ...SEARCH_QUERY, ...LIST_QUERY }
+  }),
+  createDraft: declareRouteInputs({ ...DRAFT_CREATE_SHAPE, path: DRAFTS }),
+  createDraftUpload: declareRouteInputs({ ...DRAFT_CREATE_SHAPE, path: DRAFTS_UPLOAD }),
+  sendDraft: declareRouteInputs({ ...DRAFT_SEND_SHAPE, path: `${DRAFTS}/send` }),
+  sendDraftUpload: declareRouteInputs({ ...DRAFT_SEND_SHAPE, path: `${DRAFTS_UPLOAD}/send` }),
+  getDraft: declareRouteInputs({
+    method: "GET",
+    path: `${DRAFTS}/:id`,
+    pathParams: USER_ITEM,
+    query: { format: MESSAGE_FORMAT_QUERY.format }
+  }),
+  updateDraft: declareRouteInputs({ ...DRAFT_UPDATE_SHAPE, path: `${DRAFTS}/:id` }),
+  updateDraftUpload: declareRouteInputs({
+    ...DRAFT_UPDATE_SHAPE,
+    path: `${DRAFTS_UPLOAD}/:id`
+  }),
+  deleteDraft: declareRouteInputs({
+    method: "DELETE",
+    path: `${DRAFTS}/:id`,
+    pathParams: USER_ITEM
+  }),
+  resumableCreateDraft: declareRouteInputs({ ...REFUSED, path: `${RESUMABLE}/drafts` }),
+  resumableCreateDraftPut: declareRouteInputs({ ...REFUSED_PUT, path: `${RESUMABLE}/drafts` }),
+  resumableSendDraft: declareRouteInputs({ ...REFUSED, path: `${RESUMABLE}/drafts/send` }),
+  resumableSendDraftPut: declareRouteInputs({
+    ...REFUSED_PUT,
+    path: `${RESUMABLE}/drafts/send`
+  }),
+  resumableUpdateDraft: declareRouteInputs({ ...REFUSED_ITEM, path: `${RESUMABLE}/drafts/:id` }),
+  resumableUpdateDraftPut: declareRouteInputs({
+    ...REFUSED_ITEM_PUT,
+    path: `${RESUMABLE}/drafts/:id`
+  }),
+  // profile, threads
+  getProfile: declareRouteInputs({ method: "GET", path: `${USERS}/profile`, pathParams: USER }),
+  listThreads: declareRouteInputs({
+    method: "GET",
+    path: `${USERS}/threads`,
+    pathParams: USER,
+    query: { ...SEARCH_QUERY, ...LIST_QUERY, labelIds: repeatedInput() }
+  }),
+  getThread: declareRouteInputs({
+    method: "GET",
+    path: `${USERS}/threads/:id`,
+    pathParams: USER_ITEM,
+    query: THREAD_FORMAT_QUERY
+  }),
+  modifyThread: declareRouteInputs({
+    method: "POST",
+    path: `${USERS}/threads/:id/modify`,
+    pathParams: USER_ITEM,
+    bodyEncoding: "json",
+    body: LABEL_MODIFY_BODY
+  }),
+  trashThread: declareRouteInputs({
+    method: "POST",
+    path: `${USERS}/threads/:id/trash`,
+    pathParams: USER_ITEM
+  }),
+  untrashThread: declareRouteInputs({
+    method: "POST",
+    path: `${USERS}/threads/:id/untrash`,
+    pathParams: USER_ITEM
+  }),
+  deleteThread: declareRouteInputs({
+    method: "DELETE",
+    path: `${USERS}/threads/:id`,
+    pathParams: USER_ITEM
+  }),
+  // labels
+  listLabels: declareRouteInputs({ method: "GET", path: `${USERS}/labels`, pathParams: USER }),
+  getLabel: declareRouteInputs({
+    method: "GET",
+    path: `${USERS}/labels/:id`,
+    pathParams: USER_ITEM
+  }),
+  createLabel: declareRouteInputs({
+    method: "POST",
+    path: `${USERS}/labels`,
+    pathParams: USER,
+    bodyEncoding: "json",
+    body: { name: z.string().min(1), ...LABEL_BODY }
+  }),
+  updateLabel: declareRouteInputs({
+    method: "PUT",
+    path: `${USERS}/labels/:id`,
+    pathParams: USER_ITEM,
+    bodyEncoding: "json",
+    body: { name: z.string().min(1), ...LABEL_BODY }
+  }),
+  patchLabel: declareRouteInputs({
+    method: "PATCH",
+    path: `${USERS}/labels/:id`,
+    pathParams: USER_ITEM,
+    bodyEncoding: "json",
+    // `stringField(body, "name")` let `""` through to the domain, which answers
+    // "Label name is required"; `.min(1)` here would move that error.
+    body: { name: z.string().optional(), ...LABEL_BODY }
+  }),
+  deleteLabel: declareRouteInputs({
+    method: "DELETE",
+    path: `${USERS}/labels/:id`,
+    pathParams: USER_ITEM
+  }),
+  // history
+  listHistory: declareRouteInputs({
+    method: "GET",
+    path: `${USERS}/history`,
+    pathParams: USER,
+    query: {
+      ...LIST_QUERY,
+      startHistoryId: z.string().min(1),
+      historyTypes: repeatedInput(),
+      labelId: z.string().optional()
+    }
+  }),
+  // settings
+  listFilters: declareRouteInputs({
+    method: "GET",
+    path: `${USERS}/settings/filters`,
+    pathParams: USER
+  }),
+  getFilter: declareRouteInputs({
+    method: "GET",
+    path: `${USERS}/settings/filters/:id`,
+    pathParams: USER_ITEM
+  }),
+  createFilter: declareRouteInputs({
+    method: "POST",
+    path: `${USERS}/settings/filters`,
+    pathParams: USER,
+    bodyEncoding: "json",
+    body: { criteria: jsonObjectInput.optional(), action: jsonObjectInput.optional() }
+  }),
+  deleteFilter: declareRouteInputs({
+    method: "DELETE",
+    path: `${USERS}/settings/filters/:id`,
+    pathParams: USER_ITEM
+  }),
+  listForwardingAddresses: declareRouteInputs({
+    method: "GET",
+    path: `${USERS}/settings/forwardingAddresses`,
+    pathParams: USER
+  }),
+  getForwardingAddress: declareRouteInputs({
+    method: "GET",
+    path: `${USERS}/settings/forwardingAddresses/:forwardingEmail`,
+    pathParams: { ...USER, forwardingEmail: z.string().min(1) }
+  }),
+  listSendAs: declareRouteInputs({
+    method: "GET",
+    path: `${USERS}/settings/sendAs`,
+    pathParams: USER
+  }),
+  getSendAs: declareRouteInputs({
+    method: "GET",
+    path: `${USERS}/settings/sendAs/:sendAsEmail`,
+    pathParams: { ...USER, sendAsEmail: z.string().min(1) }
+  }),
+  // Pub/Sub
+  watch: declareRouteInputs({ ...REFUSED, path: `${USERS}/watch` }),
+  stop: declareRouteInputs({ ...REFUSED, path: `${USERS}/stop` })
+};
 
 // ../packages/twin-gmail/dist/src/rest-routes-drafts.js
-var BASE = "/gmail/v1/users/:userId/drafts";
-var UPLOAD = "/upload/gmail/v1/users/:userId/drafts";
+var RESUMABLE2 = "Resumable Gmail uploads are not supported";
 function registerDraftRoutes(app, kit) {
   const { serializers, domain } = kit;
-  app.get(BASE, kit.read((c) => {
-    const email2 = emailFromContext(c);
-    const query = c.req.query("q") ?? "";
-    const includeSpamTrash = booleanQuery(c, "includeSpamTrash");
-    const drafts2 = asInputError(() => domain.drafts(email2, query, includeSpamTrash));
-    const maxResults = numberQuery(c, "maxResults", 100, 500);
+  kit.read(app, GMAIL_ROUTES.listDrafts, ({ path, query }, c) => {
+    const email2 = emailFrom(path.userId, c);
+    const { q, includeSpamTrash } = query;
+    const drafts2 = asInputError(() => domain.drafts(email2, q, includeSpamTrash));
     const snapshot = domain.currentHistoryIdFor(email2);
-    const binding = normalizeListBinding("drafts.list", email2, { query, includeSpamTrash });
+    const binding = normalizeListBinding("drafts.list", email2, { query: q, includeSpamTrash });
     const { page, nextPageToken } = paginate2(drafts2, {
-      maxResults,
-      pageToken: c.req.query("pageToken"),
+      maxResults: query.maxResults,
+      pageToken: query.pageToken,
       binding,
       snapshot
     });
@@ -3034,53 +3250,62 @@ function registerDraftRoutes(app, kit) {
         ...nextPageToken ? { nextPageToken } : {}
       }
     };
-  }));
-  const create = kit.write(async (c) => {
-    const email2 = emailFromContext(c);
-    const input = await readMessageWrite(c, true);
-    const draft2 = asInputError(() => domain.createDraft(email2, input.raw, { threadId: input.threadId }));
-    return { body: serializers.draft(email2, draft2, "full") };
   });
-  app.post(BASE, create);
-  app.post(UPLOAD, create);
-  const send = kit.write(async (c) => {
-    const email2 = emailFromContext(c);
-    const input = await readDraftSend(c);
-    if (input.id) {
-      if (input.message) {
-        asInputError(() => domain.updateDraft(email2, input.id, input.message.raw, { threadId: input.message.threadId }));
+  const create = ({ path, query, body }, c) => {
+    rejectResumable(query.uploadType);
+    rejectClassificationValues(body.message);
+    const email2 = emailFrom(path.userId, c);
+    const draft2 = asInputError(() => domain.createDraft(email2, body.message.raw, { threadId: body.message.threadId }));
+    return { body: serializers.draft(email2, draft2, "full") };
+  };
+  kit.write(app, GMAIL_ROUTES.createDraft, create);
+  kit.write(app, GMAIL_ROUTES.createDraftUpload, create);
+  const send = ({ path, query, body }, c) => {
+    if (body.message?.raw instanceof Uint8Array)
+      rejectResumable(query.uploadType);
+    if (!body.id && !body.message)
+      invalidArgument("Draft id is required");
+    const email2 = emailFrom(path.userId, c);
+    if (body.id) {
+      if (body.message) {
+        const message2 = body.message;
+        asInputError(() => domain.updateDraft(email2, body.id, message2.raw, { threadId: message2.threadId }));
       }
-      const sent2 = asInputError(() => domain.sendDraft(email2, input.id));
+      const sent2 = asInputError(() => domain.sendDraft(email2, body.id));
       return { body: serializers.message(email2, sent2.sender, "full") };
     }
-    const sent = asInputError(() => domain.sendMessage(email2, input.message.raw, { threadId: input.message.threadId }));
+    const message = body.message;
+    const sent = asInputError(() => domain.sendMessage(email2, message.raw, { threadId: message.threadId }));
     return { body: serializers.message(email2, sent.sender, "full") };
+  };
+  kit.write(app, GMAIL_ROUTES.sendDraft, send);
+  kit.write(app, GMAIL_ROUTES.sendDraftUpload, send);
+  kit.read(app, GMAIL_ROUTES.getDraft, ({ path, query }, c) => {
+    const email2 = emailFrom(path.userId, c);
+    return { body: serializers.draft(email2, domain.draft(email2, path.id), query.format) };
   });
-  app.post(`${BASE}/send`, send);
-  app.post(`${UPLOAD}/send`, send);
-  app.get(`${BASE}/:id`, kit.read((c) => {
-    const email2 = emailFromContext(c);
-    return { body: serializers.draft(email2, domain.draft(email2, routeParam(c, "id")), messageFormat(c)) };
-  }));
-  const update = kit.write(async (c) => {
-    const email2 = emailFromContext(c);
-    const input = await readMessageWrite(c, true);
-    const draft2 = asInputError(() => domain.updateDraft(email2, routeParam(c, "id"), input.raw, { threadId: input.threadId }));
+  const update = ({ path, query, body }, c) => {
+    rejectResumable(query.uploadType);
+    rejectClassificationValues(body.message);
+    const email2 = emailFrom(path.userId, c);
+    const draft2 = asInputError(() => domain.updateDraft(email2, path.id, body.message.raw, { threadId: body.message.threadId }));
     return { body: serializers.draft(email2, draft2, "full") };
-  });
-  app.put(`${BASE}/:id`, update);
-  app.put(`${UPLOAD}/:id`, update);
-  app.delete(`${BASE}/:id`, kit.write((c) => {
-    domain.deleteDraft(emailFromContext(c), routeParam(c, "id"));
+  };
+  kit.write(app, GMAIL_ROUTES.updateDraft, update);
+  kit.write(app, GMAIL_ROUTES.updateDraftUpload, update);
+  kit.write(app, GMAIL_ROUTES.deleteDraft, ({ path }, c) => {
+    domain.deleteDraft(emailFrom(path.userId, c), path.id);
     return { status: 204, body: null };
-  }));
-  for (const path of [
-    "/resumable/upload/gmail/v1/users/:userId/drafts",
-    "/resumable/upload/gmail/v1/users/:userId/drafts/send",
-    "/resumable/upload/gmail/v1/users/:userId/drafts/:id"
+  });
+  for (const declaration of [
+    GMAIL_ROUTES.resumableCreateDraft,
+    GMAIL_ROUTES.resumableCreateDraftPut,
+    GMAIL_ROUTES.resumableSendDraft,
+    GMAIL_ROUTES.resumableSendDraftPut,
+    GMAIL_ROUTES.resumableUpdateDraft,
+    GMAIL_ROUTES.resumableUpdateDraftPut
   ]) {
-    app.post(path, kit.unsupported("Resumable Gmail uploads are not supported"));
-    app.put(path, kit.unsupported("Resumable Gmail uploads are not supported"));
+    kit.unsupported(app, declaration, RESUMABLE2);
   }
 }
 
@@ -3240,16 +3465,17 @@ var GmailRouteKit = class {
   get domain() {
     return this.context.domain;
   }
-  read(fn) {
-    return this.context.recorder.handle({ mutation: false }, async (c) => {
-      const result = await fn(c);
+  read(app, declaration, fn) {
+    mountDeclaredRoute(app, declaration, this.context.recorder.handle({ mutation: false }, async (c) => {
+      const result = await fn(await parseDeclared(declaration, c), c);
       return { status: result.status ?? 200, body: result.body, mutation: false };
-    });
+    }));
   }
-  write(fn) {
-    return this.context.recorder.handle({ mutation: true }, async (c) => {
+  write(app, declaration, fn) {
+    mountDeclaredRoute(app, declaration, this.context.recorder.handle({ mutation: true }, async (c) => {
+      const input = await parseDeclared(declaration, c);
       const before = this.context.domain.exportState();
-      const result = await fn(c);
+      const result = await fn(input, c);
       const wantsMutation = result.mutation ?? true;
       const delta = wantsMutation ? gmailStateDelta(before, this.context.domain.exportState()) : null;
       const mutation = wantsMutation && delta !== null;
@@ -3259,10 +3485,19 @@ var GmailRouteKit = class {
         mutation,
         delta
       };
-    });
+    }));
   }
-  unsupported(message) {
-    return this.context.recorder.handle({ mutation: false, fidelity: "unsupported" }, () => ({
+  /**
+   * A route the twin serves only to answer 501.
+   *
+   * It does NOT parse its declaration: "this operation is not implemented" is
+   * the honest answer to a well-formed resumable-upload or Pub/Sub request, and
+   * parsing first would turn a real `users.watch` body into a 400 about an
+   * undeclared parameter. The declarations exist so the surface is published
+   * and so the mount point still has exactly one home.
+   */
+  unsupported(app, declaration, message) {
+    mountDeclaredRoute(app, declaration, this.context.recorder.handle({ mutation: false, fidelity: "unsupported" }, () => ({
       status: 501,
       body: {
         error: {
@@ -3273,32 +3508,40 @@ var GmailRouteKit = class {
         }
       },
       mutation: false
-    }));
+    })));
   }
 };
+async function parseDeclared(declaration, c) {
+  try {
+    return await declaration.parse(c.req);
+  } catch (error) {
+    if (error instanceof UndeclaredInputError) {
+      invalidArgument(`Invalid ${error.location} parameter: ${error.first}`);
+    }
+    if (error instanceof MalformedBodyError)
+      invalidArgument("Invalid JSON payload received.");
+    throw error;
+  }
+}
 
 // ../packages/twin-gmail/dist/src/rest-routes-messages.js
-var BASE2 = "/gmail/v1/users/:userId/messages";
-var UPLOAD2 = "/upload/gmail/v1/users/:userId/messages";
+var RESUMABLE3 = "Resumable Gmail uploads are not supported";
 function registerMessageRoutes(app, kit) {
   const { serializers, domain } = kit;
-  app.get(BASE2, kit.read((c) => {
-    const email2 = emailFromContext(c);
-    const query = c.req.query("q") ?? "";
-    const includeSpamTrash = booleanQuery(c, "includeSpamTrash");
-    const labelIds2 = repeatedQuery(c, "labelIds");
-    let messages = asInputError(() => domain.searchMessages(email2, query, { includeTrash: includeSpamTrash }));
-    if (!/\bin:draft\b/i.test(query))
+  kit.read(app, GMAIL_ROUTES.listMessages, ({ path, query }, c) => {
+    const email2 = emailFrom(path.userId, c);
+    const { q, includeSpamTrash, labelIds: labelIds2 } = query;
+    let messages = asInputError(() => domain.searchMessages(email2, q, { includeTrash: includeSpamTrash }));
+    if (!/\bin:draft\b/i.test(q))
       messages = messages.filter((message) => !message.labelIds.includes("DRAFT"));
     if (labelIds2.length) {
       messages = messages.filter((message) => labelIds2.every((labelId) => message.labelIds.includes(labelId)));
     }
-    const maxResults = numberQuery(c, "maxResults", 100, 500);
     const snapshot = domain.currentHistoryIdFor(email2);
-    const binding = normalizeListBinding("messages.list", email2, { query, includeSpamTrash, labelIds: labelIds2 });
+    const binding = normalizeListBinding("messages.list", email2, { query: q, includeSpamTrash, labelIds: labelIds2 });
     const { page, nextPageToken } = paginate2(messages, {
-      maxResults,
-      pageToken: c.req.query("pageToken"),
+      maxResults: query.maxResults,
+      pageToken: query.pageToken,
       binding,
       snapshot
     });
@@ -3309,135 +3552,118 @@ function registerMessageRoutes(app, kit) {
         ...nextPageToken ? { nextPageToken } : {}
       }
     };
-  }));
-  app.post(`${BASE2}/batchModify`, kit.write(async (c) => {
-    const email2 = emailFromContext(c);
-    const body = await readJsonObject(c);
+  });
+  kit.write(app, GMAIL_ROUTES.batchModifyMessages, ({ path, body }, c) => {
+    const email2 = emailFrom(path.userId, c);
     rejectClassification(body);
-    const ids = stringArray(body, "ids", 1e3);
-    if (!ids.length)
+    if (!body.ids.length)
       invalidArgument("ids is required");
-    const add = stringArray(body, "addLabelIds");
-    const remove = stringArray(body, "removeLabelIds");
     domain.db.transaction(() => {
-      for (const id of ids)
-        domain.modifyMessageLabels(email2, id, add, remove);
+      for (const id of body.ids)
+        domain.modifyMessageLabels(email2, id, body.addLabelIds, body.removeLabelIds);
     }).immediate();
     return { body: {} };
-  }));
-  app.post(`${BASE2}/batchDelete`, kit.write(async (c) => {
-    const email2 = emailFromContext(c);
-    const body = await readJsonObject(c);
-    const ids = stringArray(body, "ids", 1e3);
-    if (!ids.length)
+  });
+  kit.write(app, GMAIL_ROUTES.batchDeleteMessages, ({ path, body }, c) => {
+    const email2 = emailFrom(path.userId, c);
+    if (!body.ids.length)
       invalidArgument("ids is required");
-    domain.batchDeleteMessages(email2, ids);
+    domain.batchDeleteMessages(email2, body.ids);
     return { status: 204, body: null };
-  }));
-  const send = kit.write(async (c) => {
-    const email2 = emailFromContext(c);
-    const input = await readMessageWrite(c);
-    const result = asInputError(() => domain.sendMessage(email2, input.raw, { threadId: input.threadId }));
-    return { body: serializers.message(email2, result.sender, "full") };
   });
-  app.post(`${BASE2}/send`, send);
-  app.post(`${UPLOAD2}/send`, send);
-  const importMessage = kit.write(async (c) => {
-    const email2 = emailFromContext(c);
-    rejectUnsupportedQuery(c, ["deleted", "processForCalendar"]);
-    const source = internalDateSource(c, "dateHeader");
-    booleanQuery(c, "neverMarkSpam");
-    const input = await readMessageWrite(c);
-    const inserted = asInputError(() => domain.insertMessage(email2, input.raw, {
-      threadId: input.threadId,
-      labels: input.labelIds,
+  const send = ({ path, query, body }, c) => {
+    rejectResumable(query.uploadType);
+    rejectClassificationValues(body);
+    const email2 = emailFrom(path.userId, c);
+    const result = asInputError(() => domain.sendMessage(email2, body.raw, { threadId: body.threadId }));
+    return { body: serializers.message(email2, result.sender, "full") };
+  };
+  kit.write(app, GMAIL_ROUTES.sendMessage, send);
+  kit.write(app, GMAIL_ROUTES.sendMessageUpload, send);
+  const importMessage = ({ path, query, body }, c) => {
+    rejectResumable(query.uploadType);
+    rejectUnsupportedFlags({ deleted: query.deleted, processForCalendar: query.processForCalendar });
+    rejectClassificationValues(body);
+    const email2 = emailFrom(path.userId, c);
+    const inserted = asInputError(() => domain.insertMessage(email2, body.raw, {
+      threadId: body.threadId,
+      labels: body.labelIds,
       incoming: true
     }));
-    const message = domain.applyInternalDateSource(email2, inserted.id, source);
+    const message = domain.applyInternalDateSource(email2, inserted.id, query.internalDateSource);
     return { body: serializers.message(email2, message, "full") };
-  });
-  app.post(`${BASE2}/import`, importMessage);
-  app.post(`${UPLOAD2}/import`, importMessage);
-  const insert = kit.write(async (c) => {
-    const email2 = emailFromContext(c);
-    rejectUnsupportedQuery(c, ["deleted"]);
-    const source = internalDateSource(c, "receivedTime");
-    const input = await readMessageWrite(c);
-    const inserted = asInputError(() => domain.insertMessage(email2, input.raw, {
-      threadId: input.threadId,
-      labels: input.labelIds
-    }));
-    const message = domain.applyInternalDateSource(email2, inserted.id, source);
+  };
+  kit.write(app, GMAIL_ROUTES.importMessage, importMessage);
+  kit.write(app, GMAIL_ROUTES.importMessageUpload, importMessage);
+  const insert = ({ path, query, body }, c) => {
+    rejectResumable(query.uploadType);
+    rejectUnsupportedFlags({ deleted: query.deleted });
+    rejectClassificationValues(body);
+    const email2 = emailFrom(path.userId, c);
+    const inserted = asInputError(() => domain.insertMessage(email2, body.raw, { threadId: body.threadId, labels: body.labelIds }));
+    const message = domain.applyInternalDateSource(email2, inserted.id, query.internalDateSource);
     return { body: serializers.message(email2, message, "full") };
+  };
+  kit.write(app, GMAIL_ROUTES.insertMessage, insert);
+  kit.write(app, GMAIL_ROUTES.insertMessageUpload, insert);
+  kit.read(app, GMAIL_ROUTES.getMessage, ({ path, query }, c) => {
+    const email2 = emailFrom(path.userId, c);
+    const message = domain.getMessage(email2, path.id);
+    return { body: serializers.message(email2, message, query.format, query.metadataHeaders) };
   });
-  app.post(BASE2, insert);
-  app.post(UPLOAD2, insert);
-  app.get(`${BASE2}/:id`, kit.read((c) => {
-    const email2 = emailFromContext(c);
-    const format = messageFormat(c);
-    const message = domain.getMessage(email2, routeParam(c, "id"));
-    return { body: serializers.message(email2, message, format, repeatedQuery(c, "metadataHeaders")) };
-  }));
-  app.post(`${BASE2}/:id/modify`, kit.write(async (c) => {
-    const email2 = emailFromContext(c);
-    const body = await readJsonObject(c);
+  kit.write(app, GMAIL_ROUTES.modifyMessage, ({ path, body }, c) => {
+    const email2 = emailFrom(path.userId, c);
     rejectClassification(body);
-    const message = domain.modifyMessageLabels(email2, routeParam(c, "id"), stringArray(body, "addLabelIds"), stringArray(body, "removeLabelIds"));
+    const message = domain.modifyMessageLabels(email2, path.id, body.addLabelIds, body.removeLabelIds);
     return { body: serializers.message(email2, message, "minimal") };
-  }));
-  app.post(`${BASE2}/:id/trash`, kit.write((c) => {
-    const email2 = emailFromContext(c);
-    const message = domain.modifyMessageLabels(email2, routeParam(c, "id"), ["TRASH"], ["INBOX"]);
+  });
+  kit.write(app, GMAIL_ROUTES.trashMessage, ({ path }, c) => {
+    const email2 = emailFrom(path.userId, c);
+    const message = domain.modifyMessageLabels(email2, path.id, ["TRASH"], ["INBOX"]);
     return { body: serializers.message(email2, message, "minimal") };
-  }));
-  app.post(`${BASE2}/:id/untrash`, kit.write((c) => {
-    const email2 = emailFromContext(c);
-    const message = domain.modifyMessageLabels(email2, routeParam(c, "id"), [], ["TRASH"]);
+  });
+  kit.write(app, GMAIL_ROUTES.untrashMessage, ({ path }, c) => {
+    const email2 = emailFrom(path.userId, c);
+    const message = domain.modifyMessageLabels(email2, path.id, [], ["TRASH"]);
     return { body: serializers.message(email2, message, "minimal") };
-  }));
-  app.delete(`${BASE2}/:id`, kit.write((c) => {
-    domain.deleteMessage(emailFromContext(c), routeParam(c, "id"));
+  });
+  kit.write(app, GMAIL_ROUTES.deleteMessage, ({ path }, c) => {
+    domain.deleteMessage(emailFrom(path.userId, c), path.id);
     return { status: 204, body: null };
+  });
+  kit.read(app, GMAIL_ROUTES.getAttachment, ({ path }, c) => ({
+    body: domain.attachment(emailFrom(path.userId, c), path.messageId, path.id)
   }));
-  app.get(`${BASE2}/:messageId/attachments/:id`, kit.read((c) => ({
-    body: domain.attachment(emailFromContext(c), routeParam(c, "messageId"), routeParam(c, "id"))
-  })));
-  for (const path of [
-    "/resumable/upload/gmail/v1/users/:userId/messages",
-    "/resumable/upload/gmail/v1/users/:userId/messages/send",
-    "/resumable/upload/gmail/v1/users/:userId/messages/import"
+  for (const declaration of [
+    GMAIL_ROUTES.resumableInsertMessage,
+    GMAIL_ROUTES.resumableInsertMessagePut,
+    GMAIL_ROUTES.resumableSendMessage,
+    GMAIL_ROUTES.resumableSendMessagePut,
+    GMAIL_ROUTES.resumableImportMessage,
+    GMAIL_ROUTES.resumableImportMessagePut
   ]) {
-    app.post(path, kit.unsupported("Resumable Gmail uploads are not supported"));
-    app.put(path, kit.unsupported("Resumable Gmail uploads are not supported"));
+    kit.unsupported(app, declaration, RESUMABLE3);
   }
 }
-function internalDateSource(c, fallback) {
-  const value = c.req.query("internalDateSource") ?? fallback;
-  if (value !== "receivedTime" && value !== "dateHeader")
-    invalidArgument("Invalid internalDateSource");
-  return value;
-}
 
 // ../packages/twin-gmail/dist/src/rest-routes-resources.js
-var USERS = "/gmail/v1/users/:userId";
 function registerResourceRoutes(app, kit) {
   const { serializers, domain } = kit;
-  app.get(`${USERS}/profile`, kit.read((c) => ({ body: domain.profile(emailFromContext(c)) })));
-  app.get(`${USERS}/threads`, kit.read((c) => {
-    const email2 = emailFromContext(c);
-    const query = c.req.query("q") ?? "";
-    const includeSpamTrash = booleanQuery(c, "includeSpamTrash");
-    const labelIds2 = repeatedQuery(c, "labelIds");
-    let threads = asInputError(() => domain.searchThreads(email2, query, { includeTrash: includeSpamTrash }));
+  kit.read(app, GMAIL_ROUTES.getProfile, ({ path }, c) => ({
+    body: domain.profile(emailFrom(path.userId, c))
+  }));
+  kit.read(app, GMAIL_ROUTES.listThreads, ({ path, query }, c) => {
+    const email2 = emailFrom(path.userId, c);
+    const { q, includeSpamTrash, labelIds: labelIds2 } = query;
+    let threads = asInputError(() => domain.searchThreads(email2, q, { includeTrash: includeSpamTrash }));
     if (labelIds2.length) {
       threads = threads.filter((thread) => labelIds2.every((label2) => thread.labelIds.includes(label2)));
     }
-    const maxResults = numberQuery(c, "maxResults", 100, 500);
     const snapshot = domain.currentHistoryIdFor(email2);
-    const binding = normalizeListBinding("threads.list", email2, { query, includeSpamTrash, labelIds: labelIds2 });
+    const binding = normalizeListBinding("threads.list", email2, { query: q, includeSpamTrash, labelIds: labelIds2 });
     const { page, nextPageToken } = paginate2(threads, {
-      maxResults,
-      pageToken: c.req.query("pageToken"),
+      maxResults: query.maxResults,
+      pageToken: query.pageToken,
       binding,
       snapshot
     });
@@ -3454,85 +3680,79 @@ function registerResourceRoutes(app, kit) {
         ...nextPageToken ? { nextPageToken } : {}
       }
     };
-  }));
-  app.get(`${USERS}/threads/:id`, kit.read((c) => {
-    const email2 = emailFromContext(c);
-    const format = messageFormat(c, false);
+  });
+  kit.read(app, GMAIL_ROUTES.getThread, ({ path, query }, c) => {
+    const email2 = emailFrom(path.userId, c);
     return {
-      body: serializers.thread(email2, domain.getThread(email2, routeParam(c, "id")), format, repeatedQuery(c, "metadataHeaders"))
+      body: serializers.thread(email2, domain.getThread(email2, path.id), query.format, query.metadataHeaders)
     };
-  }));
-  app.post(`${USERS}/threads/:id/modify`, kit.write(async (c) => {
-    const email2 = emailFromContext(c);
-    const body = await readJsonObject(c);
-    const thread = domain.modifyThreadLabels(email2, routeParam(c, "id"), stringArray(body, "addLabelIds"), stringArray(body, "removeLabelIds"));
+  });
+  kit.write(app, GMAIL_ROUTES.modifyThread, ({ path, body }, c) => {
+    const email2 = emailFrom(path.userId, c);
+    const thread = domain.modifyThreadLabels(email2, path.id, body.addLabelIds, body.removeLabelIds);
     return { body: serializers.thread(email2, thread, "minimal") };
-  }));
-  app.post(`${USERS}/threads/:id/trash`, kit.write((c) => {
-    const email2 = emailFromContext(c);
+  });
+  kit.write(app, GMAIL_ROUTES.trashThread, ({ path }, c) => {
+    const email2 = emailFrom(path.userId, c);
     return {
-      body: serializers.thread(email2, domain.modifyThreadLabels(email2, routeParam(c, "id"), ["TRASH"], ["INBOX"]), "minimal")
+      body: serializers.thread(email2, domain.modifyThreadLabels(email2, path.id, ["TRASH"], ["INBOX"]), "minimal")
     };
-  }));
-  app.post(`${USERS}/threads/:id/untrash`, kit.write((c) => {
-    const email2 = emailFromContext(c);
+  });
+  kit.write(app, GMAIL_ROUTES.untrashThread, ({ path }, c) => {
+    const email2 = emailFrom(path.userId, c);
     return {
-      body: serializers.thread(email2, domain.modifyThreadLabels(email2, routeParam(c, "id"), [], ["TRASH"]), "minimal")
+      body: serializers.thread(email2, domain.modifyThreadLabels(email2, path.id, [], ["TRASH"]), "minimal")
     };
-  }));
-  app.delete(`${USERS}/threads/:id`, kit.write((c) => {
-    domain.deleteThread(emailFromContext(c), routeParam(c, "id"));
+  });
+  kit.write(app, GMAIL_ROUTES.deleteThread, ({ path }, c) => {
+    domain.deleteThread(emailFrom(path.userId, c), path.id);
     return { status: 204, body: null };
+  });
+  kit.read(app, GMAIL_ROUTES.listLabels, ({ path }, c) => ({
+    body: { labels: domain.labels(emailFrom(path.userId, c)).map(labelSummary) }
+  }));
+  kit.read(app, GMAIL_ROUTES.getLabel, ({ path }, c) => ({
+    body: labelDetail(domain.label(emailFrom(path.userId, c), path.id))
   }));
-  app.get(`${USERS}/labels`, kit.read((c) => ({ body: { labels: domain.labels(emailFromContext(c)).map(labelSummary) } })));
-  app.get(`${USERS}/labels/:id`, kit.read((c) => ({ body: labelDetail(domain.label(emailFromContext(c), routeParam(c, "id"))) })));
-  app.post(`${USERS}/labels`, kit.write(async (c) => {
-    const email2 = emailFromContext(c);
-    const body = await readJsonObject(c);
+  kit.write(app, GMAIL_ROUTES.createLabel, ({ path, body }, c) => {
+    const email2 = emailFrom(path.userId, c);
     if (body.type !== void 0 && body.type !== "user")
       invalidArgument("Only user labels can be created");
-    const created = domain.createLabel(email2, stringField(body, "name", true), colorInput(body));
+    const created = domain.createLabel(email2, body.name, body.color);
     return { body: labelDetail(domain.label(email2, created.id)) };
-  }));
-  app.put(`${USERS}/labels/:id`, kit.write(async (c) => {
-    const body = await readJsonObject(c);
-    const label2 = domain.updateLabel(emailFromContext(c), routeParam(c, "id"), { name: stringField(body, "name", true), color: colorInput(body) }, true);
+  });
+  kit.write(app, GMAIL_ROUTES.updateLabel, ({ path, body }, c) => {
+    const label2 = domain.updateLabel(emailFrom(path.userId, c), path.id, { name: body.name, color: body.color }, true);
     return { body: labelDetail(label2) };
-  }));
-  app.patch(`${USERS}/labels/:id`, kit.write(async (c) => {
-    const body = await readJsonObject(c);
-    const label2 = domain.updateLabel(emailFromContext(c), routeParam(c, "id"), { name: stringField(body, "name"), color: colorInput(body) }, false);
+  });
+  kit.write(app, GMAIL_ROUTES.patchLabel, ({ path, body }, c) => {
+    const label2 = domain.updateLabel(emailFrom(path.userId, c), path.id, { name: body.name, color: body.color }, false);
     return { body: labelDetail(label2) };
-  }));
-  app.delete(`${USERS}/labels/:id`, kit.write((c) => {
-    domain.deleteLabel(emailFromContext(c), routeParam(c, "id"));
+  });
+  kit.write(app, GMAIL_ROUTES.deleteLabel, ({ path }, c) => {
+    domain.deleteLabel(emailFrom(path.userId, c), path.id);
     return { status: 204, body: null };
-  }));
+  });
   registerHistory(app, kit);
   registerSettings(app, kit);
-  app.post(`${USERS}/watch`, kit.unsupported("users.watch requires Pub/Sub and is not supported"));
-  app.post(`${USERS}/stop`, kit.unsupported("users.stop requires Pub/Sub and is not supported"));
+  kit.unsupported(app, GMAIL_ROUTES.watch, "users.watch requires Pub/Sub and is not supported");
+  kit.unsupported(app, GMAIL_ROUTES.stop, "users.stop requires Pub/Sub and is not supported");
 }
 function registerHistory(app, kit) {
-  app.get(`${USERS}/history`, kit.read((c) => {
-    const email2 = emailFromContext(c);
-    const startHistoryId = c.req.query("startHistoryId");
-    if (!startHistoryId)
-      invalidArgument("startHistoryId is required");
-    const historyTypes = repeatedQuery(c, "historyTypes");
+  kit.read(app, GMAIL_ROUTES.listHistory, ({ path, query }, c) => {
+    const email2 = emailFrom(path.userId, c);
+    const { startHistoryId, historyTypes, labelId } = query;
     const allowed = /* @__PURE__ */ new Set(["messageAdded", "messageDeleted", "labelAdded", "labelRemoved"]);
     if (historyTypes.some((type) => !allowed.has(type)))
       invalidArgument("Invalid historyTypes");
     const result = kit.context.domain.listHistory(email2, startHistoryId, {
       types: historyTypes.length ? historyTypes : void 0
     });
-    const labelId = c.req.query("labelId");
     const resources = result.history.filter((event) => !labelId || event.labelIds.includes(labelId)).map(historyResource).filter((item) => item !== null);
-    const maxResults = numberQuery(c, "maxResults", 100, 500);
     const binding = normalizeListBinding("history.list", email2, { startHistoryId, historyTypes, labelId });
     const { page, nextPageToken } = paginate2(resources, {
-      maxResults,
-      pageToken: c.req.query("pageToken"),
+      maxResults: query.maxResults,
+      pageToken: query.pageToken,
       binding,
       snapshot: result.historyId
     });
@@ -3543,39 +3763,35 @@ function registerHistory(app, kit) {
         ...nextPageToken ? { nextPageToken } : {}
       }
     };
-  }));
+  });
 }
 function registerSettings(app, kit) {
   const { domain } = kit;
-  app.get(`${USERS}/settings/filters`, kit.read((c) => ({ body: { filter: domain.filters(emailFromContext(c)) } })));
-  app.get(`${USERS}/settings/filters/:id`, kit.read((c) => ({ body: domain.filter(emailFromContext(c), routeParam(c, "id")) })));
-  app.post(`${USERS}/settings/filters`, kit.write(async (c) => {
-    const body = await readJsonObject(c);
-    return {
-      body: asInputError(() => domain.createFilter(emailFromContext(c), filterCriteria(objectField(body, "criteria") ?? {}), filterAction(objectField(body, "action") ?? {})))
-    };
+  kit.read(app, GMAIL_ROUTES.listFilters, ({ path }, c) => ({
+    body: { filter: domain.filters(emailFrom(path.userId, c)) }
   }));
-  app.delete(`${USERS}/settings/filters/:id`, kit.write((c) => {
-    domain.deleteFilter(emailFromContext(c), routeParam(c, "id"));
+  kit.read(app, GMAIL_ROUTES.getFilter, ({ path }, c) => ({
+    body: domain.filter(emailFrom(path.userId, c), path.id)
+  }));
+  kit.write(app, GMAIL_ROUTES.createFilter, ({ path, body }, c) => ({
+    body: asInputError(() => domain.createFilter(emailFrom(path.userId, c), filterCriteria(body.criteria ?? {}), filterAction(body.action ?? {})))
+  }));
+  kit.write(app, GMAIL_ROUTES.deleteFilter, ({ path }, c) => {
+    domain.deleteFilter(emailFrom(path.userId, c), path.id);
     return { status: 204, body: null };
+  });
+  kit.read(app, GMAIL_ROUTES.listForwardingAddresses, ({ path }, c) => ({
+    body: { forwardingAddresses: domain.forwardingAddresses(emailFrom(path.userId, c)) }
+  }));
+  kit.read(app, GMAIL_ROUTES.getForwardingAddress, ({ path }, c) => ({
+    body: domain.forwardingAddress(emailFrom(path.userId, c), decodeURIComponent(path.forwardingEmail))
+  }));
+  kit.read(app, GMAIL_ROUTES.listSendAs, ({ path }, c) => ({
+    body: { sendAs: domain.sendAs(emailFrom(path.userId, c)) }
+  }));
+  kit.read(app, GMAIL_ROUTES.getSendAs, ({ path }, c) => ({
+    body: domain.sendAsAddress(emailFrom(path.userId, c), decodeURIComponent(path.sendAsEmail))
   }));
-  app.get(`${USERS}/settings/forwardingAddresses`, kit.read((c) => ({ body: { forwardingAddresses: domain.forwardingAddresses(emailFromContext(c)) } })));
-  app.get(`${USERS}/settings/forwardingAddresses/:forwardingEmail`, kit.read((c) => ({
-    body: domain.forwardingAddress(emailFromContext(c), decodeURIComponent(routeParam(c, "forwardingEmail")))
-  })));
-  app.get(`${USERS}/settings/sendAs`, kit.read((c) => ({ body: { sendAs: domain.sendAs(emailFromContext(c)) } })));
-  app.get(`${USERS}/settings/sendAs/:sendAsEmail`, kit.read((c) => ({
-    body: domain.sendAsAddress(emailFromContext(c), decodeURIComponent(routeParam(c, "sendAsEmail")))
-  })));
-}
-function colorInput(body) {
-  const color = objectField(body, "color");
-  if (!color)
-    return void 0;
-  return {
-    textColor: stringField(color, "textColor"),
-    backgroundColor: stringField(color, "backgroundColor")
-  };
 }
 function filterCriteria(body) {
   const criteria = {};