@pome-sh/cli 0.21.5 → 0.21.7

package/dist/{chunk-WVWV7DLA.js → src-FLTYWM6P.js}

@@ -1,686 +1,12 @@
-import { statePath, defineCheck, VACUITY_SENTINEL, childStatePath, VACUITY_SENTINEL_NUMBER } from './chunk-NY55QTVQ.js';
+export { GMAIL_CHECKS } from './chunk-5ETJZJR6.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 { defineTwin, openTwinDatabase, createApp } from './chunk-LZIPGCQJ.js';
-import { z, ZodError } from 'zod';
+import './chunk-VBATFCWR.js';
+import './chunk-SG6ZTIMT.js';
 import { createHash, createHmac, timingSafeEqual, randomBytes } from 'node:crypto';
-
-var GmailError = class extends Error {
-  status;
-  reason;
-  constructor(status, reason, message2) {
-    super(message2);
-    this.status = status;
-    this.reason = reason;
-    this.name = "GmailError";
-  }
-};
-function gmailErrorEnvelope(error) {
-  if (error instanceof GmailError) {
-    return {
-      status: error.status,
-      body: {
-        error: {
-          code: error.status,
-          message: error.message,
-          errors: [{ message: error.message, domain: "global", reason: error.reason }],
-          status: googleStatus(error.status)
-        }
-      }
-    };
-  }
-  if (error instanceof ZodError || error instanceof Error && error.name === "ZodError") {
-    return {
-      status: 400,
-      body: {
-        error: {
-          code: 400,
-          message: "Invalid request",
-          errors: [{ message: "Invalid request", domain: "global", reason: "invalidArgument" }],
-          status: "INVALID_ARGUMENT"
-        }
-      }
-    };
-  }
-  if (error instanceof SyntaxError) {
-    return {
-      status: 400,
-      body: {
-        error: {
-          code: 400,
-          message: "Invalid JSON",
-          errors: [{ message: "Invalid JSON", domain: "global", reason: "invalidArgument" }],
-          status: "INVALID_ARGUMENT"
-        }
-      }
-    };
-  }
-  if (error instanceof Error && (error.name === "TwinError" || error.name === "UnknownToolError")) {
-    const unknownTool = error.name === "UnknownToolError";
-    const status = unknownTool ? 404 : typeof error.status === "number" ? error.status : 400;
-    return {
-      status,
-      body: {
-        error: {
-          code: status,
-          message: error.message,
-          errors: [
-            {
-              message: error.message,
-              domain: "global",
-              reason: unknownTool ? "notFound" : "invalidArgument"
-            }
-          ],
-          status: googleStatus(status)
-        }
-      }
-    };
-  }
-  return {
-    status: 500,
-    body: {
-      error: {
-        code: 500,
-        message: "Internal error",
-        errors: [{ message: "Internal error", domain: "global", reason: "backendError" }],
-        status: "INTERNAL"
-      }
-    }
-  };
-}
-function notFound(resource = "Requested entity") {
-  throw new GmailError(404, "notFound", `${resource} was not found.`);
-}
-function invalidArgument(message2) {
-  throw new GmailError(400, "invalidArgument", message2);
-}
-function unsupported(message2) {
-  throw new GmailError(501, "notImplemented", message2);
-}
-function googleStatus(status) {
-  if (status === 400)
-    return "INVALID_ARGUMENT";
-  if (status === 401)
-    return "UNAUTHENTICATED";
-  if (status === 403)
-    return "PERMISSION_DENIED";
-  if (status === 404)
-    return "NOT_FOUND";
-  if (status === 429)
-    return "RESOURCE_EXHAUSTED";
-  if (status === 409)
-    return "ALREADY_EXISTS";
-  if (status === 501)
-    return "UNIMPLEMENTED";
-  return "INTERNAL";
-}
-var KNOWN_FAULT_NAMES = ["rate-limited"];
-var gmailFaultSchema = z.object({
-  name: z.enum(KNOWN_FAULT_NAMES),
-  target: z.string().min(1).max(128).default("messages.send"),
-  succeedFirst: z.number().int().nonnegative().max(1e3).default(2),
-  throttleFor: z.number().int().positive().max(1e3).default(3),
-  retryAfterSeconds: z.number().int().positive().max(3600).default(1)
-}).strict();
-function checkFault(db, operation) {
-  const fault = readFaults(db).find((f) => f.target === operation);
-  if (!fault)
-    return;
-  const calls = bumpFaultCounter(db, operation);
-  if (calls > fault.succeedFirst && calls <= fault.succeedFirst + fault.throttleFor) {
-    throw new GmailError(429, "rateLimitExceeded", `Rate limit exceeded for ${operation}. Retry after ${fault.retryAfterSeconds}s.`);
-  }
-}
-function readFaults(db) {
-  const row = db.prepare("SELECT value FROM gmail_config WHERE key = 'faults'").get();
-  if (!row)
-    return [];
-  try {
-    return JSON.parse(row.value);
-  } catch {
-    return [];
-  }
-}
-function bumpFaultCounter(db, operation) {
-  db.prepare("INSERT INTO fault_counters(operation, calls) VALUES (?, 1) ON CONFLICT(operation) DO UPDATE SET calls = calls + 1").run(operation);
-  const row = db.prepare("SELECT calls FROM fault_counters WHERE operation = ?").get(operation);
-  return row.calls;
-}
-
-// ../packages/twin-gmail/dist/src/search-parse.js
-var MAX_QUERY_BYTES = 4096;
-var MAX_TOKENS = 256;
-var MAX_DEPTH = 20;
-var MAX_BRANCHES = 256;
-var SEARCH_MAILBOX_MESSAGE_BUDGET = 1e4;
-var KNOWN_FIELDS = /* @__PURE__ */ new Set([
-  "from",
-  "to",
-  "cc",
-  "bcc",
-  "deliveredto",
-  "list",
-  "subject",
-  "rfc822msgid",
-  "filename",
-  "after",
-  "newer",
-  "before",
-  "older",
-  "newer_than",
-  "older_than",
-  "size",
-  "larger",
-  "smaller",
-  "label",
-  "category",
-  "in",
-  "is",
-  "has"
-]);
-var CATEGORY_LABELS = {
-  primary: "CATEGORY_PERSONAL",
-  personal: "CATEGORY_PERSONAL",
-  social: "CATEGORY_SOCIAL",
-  promotions: "CATEGORY_PROMOTIONS",
-  updates: "CATEGORY_UPDATES",
-  forums: "CATEGORY_FORUMS"
-};
-function validateSearchQuery(query) {
-  const node = parseSearchQuery(query);
-  const walk = (current) => {
-    switch (current.type) {
-      case "and":
-      case "or":
-        for (const child of current.children)
-          walk(child);
-        return;
-      case "not":
-        walk(current.child);
-        return;
-      case "around":
-        return;
-      case "term":
-        assertSearchTerm(current.field, current.value);
-        return;
-    }
-  };
-  walk(node);
-  return node;
-}
-function assertSearchTerm(field, value) {
-  if (!field)
-    return;
-  if (!KNOWN_FIELDS.has(field)) {
-    invalidArgument(`Unsupported search operator: ${field}`);
-  }
-  if (field === "category") {
-    if (!CATEGORY_LABELS[value.toLocaleLowerCase("en-US")]) {
-      invalidArgument(`Unsupported search category: ${value}`);
-    }
-    return;
-  }
-  if (field === "after" || field === "newer" || field === "before" || field === "older") {
-    parseDate(value);
-    return;
-  }
-  if (field === "newer_than" || field === "older_than") {
-    parseDuration(value);
-    return;
-  }
-  if (field === "size" || field === "larger" || field === "smaller") {
-    parseSize(value);
-    return;
-  }
-  if (field === "has") {
-    assertHasOperator(value);
-  }
-}
-function parseSearchQuery(query) {
-  if (Buffer.byteLength(query) > MAX_QUERY_BYTES)
-    invalidArgument("Search query exceeds limit");
-  const tokens = tokenize(query);
-  if (tokens.length > MAX_TOKENS)
-    invalidArgument("Search query has too many tokens");
-  if (tokens.length === 0)
-    return { type: "and", children: [] };
-  let position = 0;
-  const parseExpression = (depth, stop) => {
-    if (depth > MAX_DEPTH)
-      invalidArgument("Search query nesting exceeds limit");
-    const alternatives = [];
-    let conjunction = [];
-    const flush = () => {
-      alternatives.push(conjunction.length === 1 ? conjunction[0] : { type: "and", children: conjunction });
-      conjunction = [];
-    };
-    while (position < tokens.length) {
-      const token = tokens[position];
-      if (stop && token.value === stop)
-        break;
-      if (token.value.toUpperCase() === "OR") {
-        position++;
-        if (!conjunction.length)
-          invalidArgument("OR requires a left expression");
-        flush();
-        continue;
-      }
-      if (token.value.toUpperCase() === "AND") {
-        position++;
-        continue;
-      }
-      conjunction.push(parsePrimary(depth + 1));
-    }
-    if (conjunction.length)
-      flush();
-    if (!alternatives.length)
-      return { type: "and", children: [] };
-    return alternatives.length === 1 ? alternatives[0] : { type: "or", children: alternatives };
-  };
-  const parsePrimary = (depth) => {
-    const token = tokens[position++];
-    if (token.value === "(" || token.value === "{") {
-      const end = token.value === "(" ? ")" : "}";
-      const child = parseExpression(depth, end);
-      if (tokens[position]?.value !== end)
-        invalidArgument(`Unclosed ${token.value}`);
-      position++;
-      return token.value === "{" ? makeImplicitOr(child) : child;
-    }
-    if (token.value === ")" || token.value === "}")
-      invalidArgument(`Unexpected ${token.value}`);
-    let value = token.value;
-    let negate = false;
-    if (value === "-") {
-      negate = true;
-      const next = tokens[position++];
-      if (!next)
-        invalidArgument("Negation requires an expression");
-      position--;
-      const child = parsePrimary(depth + 1);
-      return { type: "not", child };
-    }
-    if (value.startsWith("-") && value.length > 1) {
-      negate = true;
-      value = value.slice(1);
-    }
-    const around = tokens[position]?.value.toUpperCase() === "AROUND";
-    if (around) {
-      position++;
-      const distance = Number(tokens[position++]?.value);
-      const right = tokens[position++]?.value;
-      if (!Number.isInteger(distance) || distance < 1 || distance > 100 || !right) {
-        invalidArgument("AROUND requires a distance and right term");
-      }
-      const node2 = { type: "around", left: value, right, distance };
-      return negate ? { type: "not", child: node2 } : node2;
-    }
-    const colon = value.indexOf(":");
-    let node;
-    if (colon > 0) {
-      const field = value.slice(0, colon).toLowerCase();
-      let fieldValue = value.slice(colon + 1);
-      if (!fieldValue && (tokens[position]?.value === "(" || tokens[position]?.value === "{")) {
-        node = parseFieldGroup(field, depth + 1);
-        return negate ? { type: "not", child: node } : node;
-      }
-      if (!fieldValue && tokens[position] && !["AND", "OR", ")", "}"].includes(tokens[position].value.toUpperCase())) {
-        fieldValue = tokens[position++].value;
-      }
-      node = { type: "term", field, value: fieldValue, exact: token.quoted };
-    } else {
-      node = { type: "term", value: value.startsWith("+") ? value.slice(1) : value, exact: token.quoted || value.startsWith("+") };
-    }
-    return negate ? { type: "not", child: node } : node;
-  };
-  const parseFieldGroup = (field, depth) => {
-    if (depth > MAX_DEPTH)
-      invalidArgument("Search query nesting exceeds limit");
-    const opening = tokens[position++].value;
-    const end = opening === "(" ? ")" : "}";
-    const groups = [[]];
-    while (position < tokens.length && tokens[position].value !== end) {
-      const token = tokens[position++];
-      if (token.value.toUpperCase() === "OR") {
-        groups.push([]);
-        continue;
-      }
-      if (token.value.toUpperCase() === "AND")
-        continue;
-      if (["(", "{", ")", "}"].includes(token.value))
-        invalidArgument("Nested field groups are unsupported");
-      let value = token.value;
-      let negate = false;
-      if (value.startsWith("-")) {
-        negate = true;
-        value = value.slice(1);
-      }
-      const term = { type: "term", field, value, exact: token.quoted };
-      groups.at(-1).push(negate ? { type: "not", child: term } : term);
-    }
-    if (tokens[position]?.value !== end)
-      invalidArgument(`Unclosed ${opening}`);
-    position++;
-    const nodes = groups.map((children) => children.length === 1 ? children[0] : { type: "and", children });
-    const useOr = opening === "{" || nodes.length > 1;
-    return useOr ? { type: "or", children: nodes } : nodes[0] ?? { type: "and", children: [] };
-  };
-  const root = parseExpression(0);
-  if (position !== tokens.length)
-    invalidArgument("Unexpected search token");
-  if (countBranches(root) > MAX_BRANCHES)
-    invalidArgument("Search query has too many branches");
-  return root;
-}
-function assertHasOperator(value) {
-  const normalized = value.toLocaleLowerCase("en-US");
-  if (normalized.endsWith("-star")) {
-    invalidArgument(`Unsupported colored-star operator: has:${value}; twin maps only STARRED via is:starred`);
-  }
-}
-function parseDate(value) {
-  const normalized = /^\d{4}\/\d{1,2}\/\d{1,2}$/.test(value) ? value.replaceAll("/", "-") : value;
-  const date = Date.parse(`${normalized}${/^\d{4}-\d/.test(normalized) ? "T00:00:00Z" : ""}`);
-  if (Number.isNaN(date))
-    invalidArgument(`Invalid search date: ${value}`);
-  return date;
-}
-function parseDuration(value) {
-  const match = value.match(/^(\d+)([dmy])$/i);
-  if (!match)
-    invalidArgument(`Invalid search duration: ${value}`);
-  const units = { d: 864e5, m: 30 * 864e5, y: 365 * 864e5 };
-  return Number(match[1]) * units[match[2].toLowerCase()];
-}
-function parseSize(value) {
-  const match = value.match(/^(\d+(?:\.\d+)?)([kmg])?$/i);
-  if (!match)
-    invalidArgument(`Invalid search size: ${value}`);
-  const scale = { k: 1024, m: 1024 ** 2, g: 1024 ** 3 };
-  return Math.floor(Number(match[1]) * (match[2] ? scale[match[2].toLowerCase()] : 1));
-}
-function countBranches(node) {
-  switch (node.type) {
-    case "and":
-    case "or":
-      return node.children.reduce((sum, child) => sum + countBranches(child), 0);
-    case "not":
-      return countBranches(node.child);
-    case "around":
-    case "term":
-      return 1;
-  }
-}
-function tokenize(query) {
-  const out = [];
-  let index = 0;
-  while (index < query.length) {
-    if (/\s/.test(query[index])) {
-      index++;
-      continue;
-    }
-    const char = query[index];
-    if ("(){}".includes(char)) {
-      out.push({ value: char });
-      index++;
-      continue;
-    }
-    let value = "";
-    let quoted = false;
-    while (index < query.length && !/\s/.test(query[index]) && !"(){}".includes(query[index])) {
-      if (query[index] === '"') {
-        quoted = true;
-        index++;
-        while (index < query.length && query[index] !== '"') {
-          if (query[index] === "\\" && index + 1 < query.length)
-            index++;
-          value += query[index++];
-        }
-        if (query[index] !== '"')
-          invalidArgument("Unclosed search quote");
-        index++;
-      } else {
-        value += query[index++];
-      }
-    }
-    if (value)
-      out.push({ value, quoted });
-  }
-  return out;
-}
-function makeImplicitOr(node) {
-  return node.type === "and" ? { type: "or", children: node.children } : node;
-}
-
-// ../packages/twin-gmail/dist/src/seed.js
-var email = z.string().trim().email().transform((value) => value.toLowerCase());
-var id = z.string().min(1).max(128).regex(/^[A-Za-z0-9_-]+$/);
-var attachmentSchema = z.object({
-  filename: z.string().max(512),
-  mimeType: z.string().min(1).max(255).default("application/octet-stream"),
-  disposition: z.enum(["attachment", "inline"]).default("attachment"),
-  contentId: z.string().max(998).optional(),
-  data: z.string().max(5e7)
-}).strict();
-var messageFields = {
-  id: id.optional(),
-  threadId: id.optional(),
-  raw: z.string().max(5e7).optional(),
-  from: email.optional(),
-  to: z.array(email).max(500).default([]),
-  cc: z.array(email).max(500).default([]),
-  bcc: z.array(email).max(500).default([]),
-  subject: z.string().max(998).default(""),
-  text: z.string().max(25e6).default(""),
-  html: z.string().max(25e6).default(""),
-  date: z.string().datetime({ offset: true }).optional(),
-  messageId: z.string().min(3).max(998).optional(),
-  inReplyTo: z.string().max(998).optional(),
-  references: z.array(z.string().max(998)).max(100).default([]),
-  attachments: z.array(attachmentSchema).max(100).default([])
-};
-var messageSchema = z.object({
-  ...messageFields,
-  labels: z.array(z.string().min(1).max(255)).max(100).default([])
-}).strict();
-var draftSchema = z.object(messageFields).strict();
-var labelSchema = z.object({
-  id: id.optional(),
-  name: z.string().trim().min(1).max(225),
-  color: z.object({
-    textColor: z.string().max(32).optional(),
-    backgroundColor: z.string().max(32).optional()
-  }).strict().optional()
-}).strict();
-var filterSchema = z.object({
-  id: id.optional(),
-  criteria: z.object({
-    from: z.string().max(998).optional(),
-    to: z.string().max(998).optional(),
-    subject: z.string().max(998).optional(),
-    query: z.string().max(4096).optional(),
-    negatedQuery: z.string().max(4096).optional(),
-    hasAttachment: z.boolean().optional(),
-    excludeChats: z.boolean().optional(),
-    size: z.number().int().nonnegative().optional(),
-    sizeComparison: z.enum(["larger", "smaller"]).optional()
-  }).strict().default({}),
-  action: z.object({
-    addLabelIds: z.array(z.string().min(1)).max(100).default([]),
-    removeLabelIds: z.array(z.string().min(1)).max(100).default([]),
-    forward: email.optional()
-  }).strict().default({ addLabelIds: [], removeLabelIds: [] })
-}).strict();
-var sendAsSchema = z.object({
-  sendAsEmail: email,
-  displayName: z.string().max(256).default(""),
-  replyToAddress: email.optional(),
-  isPrimary: z.boolean().default(false),
-  isDefault: z.boolean().default(false),
-  verificationStatus: z.enum(["accepted", "pending"]).default("accepted")
-}).strict();
-var mailboxSchema = z.object({
-  email,
-  displayName: z.string().max(256).default(""),
-  labels: z.array(labelSchema).max(5e3).default([]),
-  messages: z.array(messageSchema).max(1e4).default([]),
-  drafts: z.array(draftSchema).max(5e3).default([]),
-  filters: z.array(filterSchema).max(1e3).default([]),
-  forwardingAddresses: z.array(z.object({
-    forwardingEmail: email,
-    verificationStatus: z.enum(["accepted", "pending"]).default("pending")
-  }).strict()).max(1e3).default([]),
-  sendAs: z.array(sendAsSchema).max(1e3).default([])
-}).strict();
-var gmailSeedSchema = z.object({
-  primaryMailbox: mailboxSchema,
-  mailboxes: z.array(mailboxSchema).max(100).default([]),
-  deliveryMode: z.enum(["sender-only", "seeded-mailboxes"]).default("sender-only"),
-  clock: z.string().datetime({ offset: true }).default("2025-01-01T00:00:00.000Z"),
-  faults: z.array(gmailFaultSchema).max(50).default([])
-}).strict().superRefine((seed, ctx) => {
-  const emails = [seed.primaryMailbox.email, ...seed.mailboxes.map((mailbox) => mailbox.email)];
-  const seen = /* @__PURE__ */ new Set();
-  for (const mailboxEmail of emails) {
-    if (seen.has(mailboxEmail)) {
-      ctx.addIssue({ code: "custom", message: `Duplicate mailbox: ${mailboxEmail}` });
-    }
-    seen.add(mailboxEmail);
-  }
-  for (const mailbox of [seed.primaryMailbox, ...seed.mailboxes]) {
-    const labelNames = /* @__PURE__ */ new Set();
-    for (const label2 of mailbox.labels) {
-      const key = label2.name.toLowerCase();
-      if (labelNames.has(key)) {
-        ctx.addIssue({ code: "custom", message: `Duplicate label in ${mailbox.email}: ${label2.name}` });
-      }
-      labelNames.add(key);
-    }
-    for (const filter2 of mailbox.filters) {
-      if (filter2.action.forward) {
-        ctx.addIssue({
-          code: "custom",
-          message: `Filter forwarding is unsupported: ${mailbox.email}`
-        });
-      }
-      for (const key of ["query", "negatedQuery"]) {
-        const value = filter2.criteria[key];
-        if (!value)
-          continue;
-        try {
-          validateSearchQuery(value);
-        } catch (error) {
-          ctx.addIssue({
-            code: "custom",
-            message: `Invalid filter ${key} in ${mailbox.email}: ${error.message}`
-          });
-        }
-      }
-    }
-  }
-});
-function parseSeed(input) {
-  return gmailSeedSchema.parse(input);
-}
-function loadSeedFromEnv(env = process.env) {
-  const raw = env.POME_SEED_JSON;
-  if (!raw)
-    return parseSeed(defaultSeedState());
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch (error) {
-    throw new Error(`POME_SEED_JSON is not valid JSON: ${error.message}`);
-  }
-  return parseSeed(parsed);
-}
-var DEFAULT_GMAIL_AGENT_EMAIL = "pome-agent@pome-twin.test";
-function agentPathInboxMailbox(email3 = DEFAULT_GMAIL_AGENT_EMAIL) {
-  return {
-    email: email3,
-    displayName: "Pome Agent",
-    labels: [
-      { id: "Label_follow_up", name: "Follow Up" },
-      { id: "Label_build", name: "Build" }
-    ],
-    messages: [
-      {
-        id: "msg_welcome",
-        threadId: "thread_welcome",
-        from: "welcome@pome-twin.test",
-        to: [email3],
-        subject: "Welcome to your Pome Gmail twin",
-        text: "Your deterministic inbox is ready for agent testing.",
-        html: "<p>Your deterministic inbox is ready for agent testing.</p>",
-        date: "2026-07-18T09:00:00.000Z",
-        messageId: "welcome@pome-twin.test",
-        labels: ["INBOX"]
-      },
-      {
-        id: "msg_build",
-        threadId: "thread_build",
-        from: "ci@example.com",
-        to: [email3],
-        subject: "Build failed on main",
-        text: "The nightly build failed. See the attached log.",
-        date: "2026-07-19T10:00:00.000Z",
-        messageId: "build-001@example.com",
-        labels: ["INBOX", "UNREAD", "Build"],
-        attachments: [
-          {
-            filename: "build.log",
-            mimeType: "text/plain",
-            data: Buffer.from("BUILD FAILED step=test\n", "utf8").toString("base64")
-          }
-        ]
-      },
-      {
-        id: "msg_build_reply",
-        threadId: "thread_build",
-        from: email3,
-        to: ["ci@example.com"],
-        subject: "Re: Build failed on main",
-        text: "Looking into the failure now.",
-        date: "2026-07-19T11:00:00.000Z",
-        messageId: "build-reply@pome-twin.test",
-        inReplyTo: "build-001@example.com",
-        references: ["build-001@example.com"],
-        labels: ["SENT"]
-      },
-      {
-        id: "msg_support",
-        threadId: "thread_support",
-        from: "alice@example.com",
-        to: [email3],
-        subject: "Production export is stuck",
-        text: "Our production export has been stuck for an hour. Can you investigate?",
-        date: "2026-07-19T12:00:00.000Z",
-        messageId: "support-001@example.com",
-        labels: ["INBOX", "UNREAD"]
-      }
-    ],
-    drafts: [
-      {
-        id: "draft_ack",
-        threadId: "thread_draft_ack",
-        to: ["bob@example.com"],
-        subject: "Draft acknowledgment",
-        text: "Thanks \u2014 I'll follow up shortly.",
-        date: "2026-07-19T13:00:00.000Z",
-        messageId: "draft-ack@pome-twin.test"
-      }
-    ],
-    filters: [],
-    forwardingAddresses: [],
-    sendAs: []
-  };
-}
-function defaultSeedState() {
-  return {
-    primaryMailbox: agentPathInboxMailbox(),
-    mailboxes: [],
-    deliveryMode: "sender-only",
-    clock: "2026-07-20T00:00:00.000Z"
-  };
-}
+import { z } from 'zod';
 
 // ../packages/twin-gmail/dist/src/db.js
 var MIGRATION_SQL = `
@@ -1104,7 +430,7 @@ var MAX_RAW_BYTES = 36700160;
 var MAX_HEADERS = 1e3;
 var MAX_HEADER_BYTES = 256 * 1024;
 var MAX_PARTS = 500;
-var MAX_DEPTH2 = 20;
+var MAX_DEPTH = 20;
 function canonicalRaw(input) {
   const raw = typeof input === "string" ? Buffer.from(input, "utf8") : Buffer.from(input);
   if (raw.length === 0)
@@ -1263,7 +589,7 @@ function parseHeaders(raw) {
   });
 }
 function parsePart(body, headers2, contentType, state, depth) {
-  if (depth > MAX_DEPTH2 || ++state.parts > MAX_PARTS)
+  if (depth > MAX_DEPTH || ++state.parts > MAX_PARTS)
     invalidArgument("MIME nesting/part limit exceeded");
   if (contentType.type.startsWith("multipart/")) {
     const boundary = contentType.params.boundary;
@@ -1589,16 +915,16 @@ var SYSTEM_LABELS = [
   ["CATEGORY_UPDATES", "CATEGORY_UPDATES"],
   ["CATEGORY_FORUMS", "CATEGORY_FORUMS"]
 ];
-function createMailbox(db, email3, displayName, createdAt) {
-  const result = db.prepare("INSERT INTO mailboxes(email, display_name, created_at) VALUES (?, ?, ?)").run(email3, displayName, createdAt);
+function createMailbox(db, email2, displayName, createdAt) {
+  const result = db.prepare("INSERT INTO mailboxes(email, display_name, created_at) VALUES (?, ?, ?)").run(email2, displayName, createdAt);
   const mailboxId = Number(result.lastInsertRowid);
   db.prepare("INSERT INTO mailbox_counters(mailbox_id) VALUES (?)").run(mailboxId);
-  for (const [id2, name] of SYSTEM_LABELS) {
-    db.prepare("INSERT INTO labels(mailbox_id, id, name, type, text_color, background_color) VALUES (?, ?, ?, 'system', NULL, NULL)").run(mailboxId, id2, name);
+  for (const [id, name] of SYSTEM_LABELS) {
+    db.prepare("INSERT INTO labels(mailbox_id, id, name, type, text_color, background_color) VALUES (?, ?, ?, 'system', NULL, NULL)").run(mailboxId, id, name);
   }
   db.prepare(`INSERT INTO send_as(
       mailbox_id, email, display_name, is_primary, is_default, verification_status
-    ) VALUES (?, ?, ?, 1, 1, 'accepted')`).run(mailboxId, email3, displayName);
+    ) VALUES (?, ?, ?, 1, 1, 'accepted')`).run(mailboxId, email2, displayName);
   return mailboxId;
 }
 function nextId(db, mailboxId, counter, prefix) {
@@ -1612,17 +938,17 @@ function nextTimestamp(db, mailboxId) {
   const config = db.prepare("SELECT value FROM gmail_config WHERE key = 'clock'").get();
   return new Date(Date.parse(config.value) + row.logical_clock * 1e3).toISOString();
 }
-function addHistory(db, mailboxId, messageId2, threadId, eventType, labelIds2 = []) {
-  const id2 = nextId(db, mailboxId, "history_counter", "history").slice("history_".length);
-  const numeric = Number.parseInt(id2, 16);
+function addHistory(db, mailboxId, messageId, threadId, eventType, labelIds2 = []) {
+  const id = nextId(db, mailboxId, "history_counter", "history").slice("history_".length);
+  const numeric = Number.parseInt(id, 16);
   const timestamp = nextTimestamp(db, mailboxId);
   db.prepare(`INSERT INTO history(mailbox_id, id, message_id, thread_id, event_type, label_ids_json, created_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?)`).run(mailboxId, numeric, messageId2, threadId, eventType, JSON.stringify([...labelIds2].sort()), timestamp);
+     VALUES (?, ?, ?, ?, ?, ?, ?)`).run(mailboxId, numeric, messageId, threadId, eventType, JSON.stringify([...labelIds2].sort()), timestamp);
   return String(numeric);
 }
 function insertStoredMessage(db, mailboxId, raw, options = {}) {
   const parsed = parseMime(raw);
-  const messageId2 = options.id ?? nextId(db, mailboxId, "message_counter", "msg");
+  const messageId = options.id ?? nextId(db, mailboxId, "message_counter", "msg");
   const subjectKey = normalizeSubject(parsed.subject);
   const threadId = options.forceThreadId && options.threadId ? options.threadId : resolveThread(db, mailboxId, options.threadId, subjectKey, [
     ...parsed.inReplyTo ? [parsed.inReplyTo] : [],
@@ -1639,32 +965,32 @@ function insertStoredMessage(db, mailboxId, raw, options = {}) {
       mailbox_id, id, thread_id, rfc_message_id, internal_date, sent_at,
       from_address, to_json, cc_json, bcc_json, delivered_to, subject,
       normalized_subject, snippet, text_body, html_body, headers_json, size_estimate
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(mailboxId, messageId2, threadId, parsed.messageId || `${messageId2}@pome-twin.test`, internalDate, date, parsed.from, JSON.stringify(parsed.to), JSON.stringify(parsed.cc), JSON.stringify(parsed.bcc), options.deliveredTo ?? parsed.deliveredTo, parsed.subject, subjectKey, snippet, parsed.text, parsed.html, JSON.stringify(parsed.headers), raw.byteLength);
-  db.prepare("INSERT INTO message_blobs(mailbox_id, message_id, raw, sha256, size) VALUES (?, ?, ?, ?, ?)").run(mailboxId, messageId2, Buffer.from(raw), mimeSha256(raw), raw.byteLength);
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(mailboxId, messageId, threadId, parsed.messageId || `${messageId}@pome-twin.test`, internalDate, date, parsed.from, JSON.stringify(parsed.to), JSON.stringify(parsed.cc), JSON.stringify(parsed.bcc), options.deliveredTo ?? parsed.deliveredTo, parsed.subject, subjectKey, snippet, parsed.text, parsed.html, JSON.stringify(parsed.headers), raw.byteLength);
+  db.prepare("INSERT INTO message_blobs(mailbox_id, message_id, raw, sha256, size) VALUES (?, ?, ?, ?, ?)").run(mailboxId, messageId, Buffer.from(raw), mimeSha256(raw), raw.byteLength);
   parsed.attachments.forEach((attachment2, index) => {
     const attachmentId = nextId(db, mailboxId, "attachment_counter", "att");
     db.prepare(`INSERT INTO attachments(
         mailbox_id, message_id, id, part_index, filename, mime_type, disposition,
         content_id, sha256, size, data
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(mailboxId, messageId2, attachmentId, index, attachment2.filename, attachment2.mimeType, attachment2.disposition, attachment2.contentId ?? null, mimeSha256(attachment2.data), attachment2.data.byteLength, attachment2.data);
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(mailboxId, messageId, attachmentId, index, attachment2.filename, attachment2.mimeType, attachment2.disposition, attachment2.contentId ?? null, mimeSha256(attachment2.data), attachment2.data.byteLength, attachment2.data);
   });
   const labels2 = options.draft ? ["DRAFT"] : [...new Set(options.labels ?? [])];
   assertLabels(db, mailboxId, labels2);
   for (const label2 of labels2) {
-    db.prepare("INSERT INTO message_labels(mailbox_id, message_id, label_id) VALUES (?, ?, ?)").run(mailboxId, messageId2, label2);
+    db.prepare("INSERT INTO message_labels(mailbox_id, message_id, label_id) VALUES (?, ?, ?)").run(mailboxId, messageId, label2);
   }
   db.prepare("UPDATE threads SET updated_at = ? WHERE mailbox_id = ? AND id = ?").run(date, mailboxId, threadId);
   if (options.recordHistory !== false)
-    addHistory(db, mailboxId, messageId2, threadId, "messageAdded", labels2);
-  return semanticMessage(db, mailboxId, messageId2);
+    addHistory(db, mailboxId, messageId, threadId, "messageAdded", labels2);
+  return semanticMessage(db, mailboxId, messageId);
 }
-function semanticMessage(db, mailboxId, messageId2) {
-  const row = db.prepare("SELECT * FROM messages WHERE mailbox_id = ? AND id = ?").get(mailboxId, messageId2);
+function semanticMessage(db, mailboxId, messageId) {
+  const row = db.prepare("SELECT * FROM messages WHERE mailbox_id = ? AND id = ?").get(mailboxId, messageId);
   if (!row)
     notFound("Message");
-  const labels2 = db.prepare("SELECT label_id FROM message_labels WHERE mailbox_id = ? AND message_id = ? ORDER BY label_id").all(mailboxId, messageId2);
+  const labels2 = db.prepare("SELECT label_id FROM message_labels WHERE mailbox_id = ? AND message_id = ? ORDER BY label_id").all(mailboxId, messageId);
   const attachments = db.prepare(`SELECT id, filename, mime_type, disposition, content_id, sha256, size
-       FROM attachments WHERE mailbox_id = ? AND message_id = ? ORDER BY part_index`).all(mailboxId, messageId2);
+       FROM attachments WHERE mailbox_id = ? AND message_id = ? ORDER BY part_index`).all(mailboxId, messageId);
   return {
     id: row.id,
     threadId: row.thread_id,
@@ -1691,8 +1017,8 @@ function semanticMessage(db, mailboxId, messageId2) {
     }))
   };
 }
-function rawMessage(db, mailboxId, messageId2) {
-  const row = db.prepare("SELECT raw FROM message_blobs WHERE mailbox_id = ? AND message_id = ?").get(mailboxId, messageId2);
+function rawMessage(db, mailboxId, messageId) {
+  const row = db.prepare("SELECT raw FROM message_blobs WHERE mailbox_id = ? AND message_id = ?").get(mailboxId, messageId);
   if (!row)
     notFound("Message");
   return Buffer.from(row.raw);
@@ -1733,37 +1059,37 @@ function seedMailbox(db, mailbox) {
     db.prepare("INSERT INTO labels(mailbox_id, id, name, type, text_color, background_color) VALUES (?, ?, ?, 'user', ?, ?)").run(mailboxId, labelId, label2.name, label2.color?.textColor ?? null, label2.color?.backgroundColor ?? null);
     labelByName.set(label2.name.toLowerCase(), labelId);
   }
-  for (const message2 of mailbox.messages) {
-    if (message2.id)
+  for (const message of mailbox.messages) {
+    if (message.id)
       nextId(db, mailboxId, "message_counter", "msg");
-    if (message2.threadId)
+    if (message.threadId)
       nextId(db, mailboxId, "thread_counter", "thread");
-    const raw = seedRaw(db, mailbox, message2, mailboxId);
-    const labels2 = message2.labels.map((label2) => labelByName.get(label2.toLowerCase()) ?? label2);
+    const raw = seedRaw(db, mailbox, message, mailboxId);
+    const labels2 = message.labels.map((label2) => labelByName.get(label2.toLowerCase()) ?? label2);
     insertStoredMessage(db, mailboxId, raw, {
-      id: message2.id,
-      threadId: message2.threadId,
+      id: message.id,
+      threadId: message.threadId,
       labels: labels2,
       recordHistory: false,
-      forceThreadId: message2.threadId !== void 0
+      forceThreadId: message.threadId !== void 0
     });
   }
-  for (const draft3 of mailbox.drafts) {
-    if (draft3.id)
+  for (const draft2 of mailbox.drafts) {
+    if (draft2.id)
       nextId(db, mailboxId, "draft_counter", "draft");
-    if (draft3.threadId)
+    if (draft2.threadId)
       nextId(db, mailboxId, "thread_counter", "thread");
-    const raw = seedRaw(db, mailbox, draft3, mailboxId);
-    const message2 = insertStoredMessage(db, mailboxId, raw, {
-      id: draft3.id ? `${draft3.id}_message` : void 0,
-      threadId: draft3.threadId,
+    const raw = seedRaw(db, mailbox, draft2, mailboxId);
+    const message = insertStoredMessage(db, mailboxId, raw, {
+      id: draft2.id ? `${draft2.id}_message` : void 0,
+      threadId: draft2.threadId,
       draft: true,
       recordHistory: false,
-      forceThreadId: draft3.threadId !== void 0
+      forceThreadId: draft2.threadId !== void 0
     });
-    const draftId = draft3.id ?? nextId(db, mailboxId, "draft_counter", "draft");
-    const date = new Date(message2.internalDate).toISOString();
-    db.prepare("INSERT INTO drafts(mailbox_id, id, message_id, created_at, updated_at) VALUES (?, ?, ?, ?, ?)").run(mailboxId, draftId, message2.id, date, date);
+    const draftId = draft2.id ?? nextId(db, mailboxId, "draft_counter", "draft");
+    const date = new Date(message.internalDate).toISOString();
+    db.prepare("INSERT INTO drafts(mailbox_id, id, message_id, created_at, updated_at) VALUES (?, ?, ?, ?, ?)").run(mailboxId, draftId, message.id, date, date);
   }
   seedSettings(db, mailboxId, mailbox);
 }
@@ -1779,29 +1105,29 @@ function seedSettings(db, mailboxId, mailbox) {
   for (const filter2 of mailbox.filters) {
     if (filter2.id)
       nextId(db, mailboxId, "filter_counter", "filter");
-    const id2 = filter2.id ?? nextId(db, mailboxId, "filter_counter", "filter");
-    db.prepare("INSERT INTO filters(mailbox_id, id, criteria_json, action_json) VALUES (?, ?, ?, ?)").run(mailboxId, id2, JSON.stringify(filter2.criteria), JSON.stringify(filter2.action));
+    const id = filter2.id ?? nextId(db, mailboxId, "filter_counter", "filter");
+    db.prepare("INSERT INTO filters(mailbox_id, id, criteria_json, action_json) VALUES (?, ?, ?, ?)").run(mailboxId, id, JSON.stringify(filter2.criteria), JSON.stringify(filter2.action));
   }
 }
-function seedRaw(db, mailbox, message2, mailboxId) {
-  if (message2.raw !== void 0) {
-    return message2.raw.includes("\n") ? Buffer.from(message2.raw, "utf8") : decodeGmailRaw(message2.raw);
+function seedRaw(db, mailbox, message, mailboxId) {
+  if (message.raw !== void 0) {
+    return message.raw.includes("\n") ? Buffer.from(message.raw, "utf8") : decodeGmailRaw(message.raw);
   }
-  const date = message2.date ?? nextTimestamp(db, mailboxId);
-  const id2 = message2.messageId ?? `${nextId(db, mailboxId, "message_counter", "rfc")}@pome-twin.test`;
+  const date = message.date ?? nextTimestamp(db, mailboxId);
+  const id = message.messageId ?? `${nextId(db, mailboxId, "message_counter", "rfc")}@pome-twin.test`;
   return composeMime({
-    from: message2.from ?? mailbox.email,
-    to: message2.to,
-    cc: message2.cc,
-    bcc: message2.bcc,
-    subject: message2.subject,
-    text: message2.text,
-    html: message2.html,
+    from: message.from ?? mailbox.email,
+    to: message.to,
+    cc: message.cc,
+    bcc: message.bcc,
+    subject: message.subject,
+    text: message.text,
+    html: message.html,
     date,
-    messageId: id2,
-    inReplyTo: message2.inReplyTo,
-    references: message2.references,
-    attachments: message2.attachments
+    messageId: id,
+    inReplyTo: message.inReplyTo,
+    references: message.references,
+    attachments: message.attachments
   });
 }
 
@@ -1814,7 +1140,7 @@ function batchSemanticMessages(db, mailboxId, messageIds2) {
        WHERE mailbox_id = ? AND id IN (${placeholders})`).all(mailboxId, ...messageIds2);
   if (rows2.length !== messageIds2.length) {
     const found = new Set(rows2.map((row) => row.id));
-    const missing = messageIds2.find((id2) => !found.has(id2));
+    const missing = messageIds2.find((id) => !found.has(id));
     if (missing)
       notFound("Message");
   }
@@ -1846,8 +1172,8 @@ function batchSemanticMessages(db, mailboxId, messageIds2) {
     });
     attachmentsByMessage.set(row.message_id, list);
   }
-  return messageIds2.map((id2) => {
-    const row = byId.get(id2);
+  return messageIds2.map((id) => {
+    const row = byId.get(id);
     return {
       id: row.id,
       threadId: row.thread_id,
@@ -1862,15 +1188,15 @@ function batchSemanticMessages(db, mailboxId, messageIds2) {
       text: row.text_body,
       html: row.html_body,
       sizeEstimate: row.size_estimate,
-      labelIds: labelsByMessage.get(id2) ?? [],
-      attachments: attachmentsByMessage.get(id2) ?? []
+      labelIds: labelsByMessage.get(id) ?? [],
+      attachments: attachmentsByMessage.get(id) ?? []
     };
   });
 }
 function batchSearchDocuments(db, mailboxId, messages) {
   if (!messages.length)
     return [];
-  const ids = messages.map((message2) => message2.id);
+  const ids = messages.map((message) => message.id);
   const placeholders = ids.map(() => "?").join(", ");
   const metaRows = db.prepare(`SELECT id, delivered_to, headers_json FROM messages
        WHERE mailbox_id = ? AND id IN (${placeholders})`).all(mailboxId, ...ids);
@@ -1881,30 +1207,30 @@ function batchSearchDocuments(db, mailboxId, messages) {
        WHERE ml.mailbox_id = ? AND ml.message_id IN (${placeholders}) AND l.type = 'user'
        GROUP BY ml.message_id`).all(mailboxId, ...ids);
   const userLabelCount = new Map(userLabelRows.map((row) => [row.message_id, row.count]));
-  return messages.map((message2) => {
-    const meta = metaById.get(message2.id);
+  return messages.map((message) => {
+    const meta = metaById.get(message.id);
     return {
-      from: message2.from.toLowerCase(),
-      to: message2.to.map((item) => item.toLowerCase()),
-      cc: message2.cc.map((item) => item.toLowerCase()),
-      bcc: message2.bcc.map((item) => item.toLowerCase()),
+      from: message.from.toLowerCase(),
+      to: message.to.map((item) => item.toLowerCase()),
+      cc: message.cc.map((item) => item.toLowerCase()),
+      bcc: message.bcc.map((item) => item.toLowerCase()),
       deliveredTo: meta.delivered_to.toLowerCase(),
-      subject: message2.subject,
-      text: message2.text,
-      html: message2.html,
-      dateMs: message2.internalDate,
-      rfcMessageId: message2.rfcMessageId,
-      size: message2.sizeEstimate,
-      labels: message2.labelIds,
-      userLabelCount: userLabelCount.get(message2.id) ?? 0,
-      attachmentNames: message2.attachments.map((attachment2) => attachment2.filename),
-      attachmentMimeTypes: message2.attachments.map((attachment2) => attachment2.mimeType),
+      subject: message.subject,
+      text: message.text,
+      html: message.html,
+      dateMs: message.internalDate,
+      rfcMessageId: message.rfcMessageId,
+      size: message.sizeEstimate,
+      labels: message.labelIds,
+      userLabelCount: userLabelCount.get(message.id) ?? 0,
+      attachmentNames: message.attachments.map((attachment2) => attachment2.filename),
+      attachmentMimeTypes: message.attachments.map((attachment2) => attachment2.mimeType),
       headers: JSON.parse(meta.headers_json)
     };
   });
 }
-function searchDocument(db, mailboxId, message2) {
-  return batchSearchDocuments(db, mailboxId, [message2])[0];
+function searchDocument(db, mailboxId, message) {
+  return batchSearchDocuments(db, mailboxId, [message])[0];
 }
 function searchNow(db) {
   const clock = db.prepare("SELECT value FROM gmail_config WHERE key = 'clock'").get();
@@ -1913,56 +1239,56 @@ function searchNow(db) {
 }
 
 // ../packages/twin-gmail/dist/src/domain/filters.js
-function applyInboundFilters(db, mailboxId, messageId2) {
+function applyInboundFilters(db, mailboxId, messageId) {
   const filters2 = db.prepare("SELECT criteria_json, action_json FROM filters WHERE mailbox_id = ? ORDER BY id").all(mailboxId);
   for (const row of filters2) {
     const criteria = JSON.parse(row.criteria_json);
     const action = JSON.parse(row.action_json);
     if (action.forward)
       unsupported("Filter forwarding is not implemented");
-    const message2 = semanticMessage(db, mailboxId, messageId2);
-    const document = searchDocument(db, mailboxId, message2);
+    const message = semanticMessage(db, mailboxId, messageId);
+    const document = searchDocument(db, mailboxId, message);
     const criteriaTo = typeof criteria.to === "string" ? criteria.to.toLowerCase() : void 0;
     const now = searchNow(db);
     const matches = (typeof criteria.from !== "string" || document.from.includes(criteria.from.toLowerCase())) && (criteriaTo === void 0 || document.to.some((to) => to.includes(criteriaTo))) && (typeof criteria.subject !== "string" || document.subject.toLowerCase().includes(criteria.subject.toLowerCase())) && (criteria.hasAttachment !== true || document.attachmentNames.length > 0) && (typeof criteria.size !== "number" || (criteria.sizeComparison === "smaller" ? document.size < criteria.size : document.size > criteria.size)) && (typeof criteria.query !== "string" || matchesSearch(parseSearchQuery(criteria.query), document, now)) && (typeof criteria.negatedQuery !== "string" || !matchesSearch(parseSearchQuery(criteria.negatedQuery), document, now));
     if (!matches)
       continue;
     assertLabels(db, mailboxId, [...action.addLabelIds ?? [], ...action.removeLabelIds ?? []]);
-    const beforeLabels = new Set(message2.labelIds);
+    const beforeLabels = new Set(message.labelIds);
     const removed = [];
     const added = [];
     for (const label2 of action.removeLabelIds ?? []) {
-      const result = db.prepare("DELETE FROM message_labels WHERE mailbox_id = ? AND message_id = ? AND label_id = ?").run(mailboxId, messageId2, label2);
+      const result = db.prepare("DELETE FROM message_labels WHERE mailbox_id = ? AND message_id = ? AND label_id = ?").run(mailboxId, messageId, label2);
       if (result.changes > 0 && beforeLabels.has(label2))
         removed.push(label2);
     }
     for (const label2 of action.addLabelIds ?? []) {
-      const result = db.prepare("INSERT OR IGNORE INTO message_labels(mailbox_id, message_id, label_id) VALUES (?, ?, ?)").run(mailboxId, messageId2, label2);
+      const result = db.prepare("INSERT OR IGNORE INTO message_labels(mailbox_id, message_id, label_id) VALUES (?, ?, ?)").run(mailboxId, messageId, label2);
       if (result.changes > 0 && !beforeLabels.has(label2))
         added.push(label2);
     }
     if (added.length)
-      addHistory(db, mailboxId, messageId2, message2.threadId, "labelAdded", added);
+      addHistory(db, mailboxId, messageId, message.threadId, "labelAdded", added);
     if (removed.length)
-      addHistory(db, mailboxId, messageId2, message2.threadId, "labelRemoved", removed);
+      addHistory(db, mailboxId, messageId, message.threadId, "labelRemoved", removed);
   }
 }
-function filters(domain, email3) {
-  const mailboxId = domain.mailboxId(email3);
+function filters(domain, email2) {
+  const mailboxId = domain.mailboxId(email2);
   const rows2 = domain.db.prepare("SELECT id, criteria_json, action_json FROM filters WHERE mailbox_id = ? ORDER BY id").all(mailboxId);
   return rows2.map(toFilter);
 }
-function filter(domain, email3, filterId) {
-  const mailboxId = domain.mailboxId(email3);
+function filter(domain, email2, filterId) {
+  const mailboxId = domain.mailboxId(email2);
   const row = domain.db.prepare("SELECT id, criteria_json, action_json FROM filters WHERE mailbox_id = ? AND id = ?").get(mailboxId, filterId);
   if (!row)
     notFound("Filter");
   return toFilter(row);
 }
-function createFilter(domain, email3, criteria = {}, action = {}) {
+function createFilter(domain, email2, criteria = {}, action = {}) {
   if (action.forward)
     unsupported("Filter action.forward is not supported by the Gmail twin");
-  const mailboxId = domain.mailboxId(email3);
+  const mailboxId = domain.mailboxId(email2);
   const count = domain.db.prepare("SELECT COUNT(*) AS count FROM filters WHERE mailbox_id = ?").get(mailboxId);
   if (count.count >= 1e3)
     invalidArgument("Filter limit exceeded");
@@ -1971,12 +1297,12 @@ function createFilter(domain, email3, criteria = {}, action = {}) {
     validateSearchQuery(criteria.query);
   if (criteria.negatedQuery)
     validateSearchQuery(criteria.negatedQuery);
-  const id2 = nextId(domain.db, mailboxId, "filter_counter", "filter");
-  domain.db.prepare("INSERT INTO filters(mailbox_id, id, criteria_json, action_json) VALUES (?, ?, ?, ?)").run(mailboxId, id2, JSON.stringify(criteria), JSON.stringify(action));
-  return { id: id2, criteria, action };
+  const id = nextId(domain.db, mailboxId, "filter_counter", "filter");
+  domain.db.prepare("INSERT INTO filters(mailbox_id, id, criteria_json, action_json) VALUES (?, ?, ?, ?)").run(mailboxId, id, JSON.stringify(criteria), JSON.stringify(action));
+  return { id, criteria, action };
 }
-function deleteFilter(domain, email3, filterId) {
-  const mailboxId = domain.mailboxId(email3);
+function deleteFilter(domain, email2, filterId) {
+  const mailboxId = domain.mailboxId(email2);
   const result = domain.db.prepare("DELETE FROM filters WHERE mailbox_id = ? AND id = ?").run(mailboxId, filterId);
   if (result.changes === 0)
     notFound("Filter");
@@ -2159,47 +1485,47 @@ function pushNotHasLabel(clauses, params, labelId) {
 }
 
 // ../packages/twin-gmail/dist/src/domain/messages.js
-function getRaw(domain, email3, messageId2) {
-  return rawMessage(domain.db, domain.mailboxId(email3), messageId2);
+function getRaw(domain, email2, messageId) {
+  return rawMessage(domain.db, domain.mailboxId(email2), messageId);
 }
-function getMessage(domain, email3, messageId2) {
-  return semanticMessage(domain.db, domain.mailboxId(email3), messageId2);
+function getMessage(domain, email2, messageId) {
+  return semanticMessage(domain.db, domain.mailboxId(email2), messageId);
 }
-function getThread(domain, email3, threadId) {
-  const mailboxId = domain.mailboxId(email3);
+function getThread(domain, email2, threadId) {
+  const mailboxId = domain.mailboxId(email2);
   const rows2 = domain.db.prepare("SELECT id FROM messages WHERE mailbox_id = ? AND thread_id = ? ORDER BY internal_date, id").all(mailboxId, threadId);
   if (!rows2.length)
     notFound("Thread");
   const messages = batchSemanticMessages(domain.db, mailboxId, rows2.map((row) => row.id));
   return {
     id: threadId,
-    labelIds: [...new Set(messages.flatMap((message2) => message2.labelIds))].sort(),
+    labelIds: [...new Set(messages.flatMap((message) => message.labelIds))].sort(),
     messages
   };
 }
-function insertMessage(domain, email3, raw, options = {}) {
-  const mailboxId = domain.mailboxId(email3);
+function insertMessage(domain, email2, raw, options = {}) {
+  const mailboxId = domain.mailboxId(email2);
   const bytes = acceptedRaw(raw);
   return domain.db.transaction(() => {
-    const message2 = insertStoredMessage(domain.db, mailboxId, bytes, {
+    const message = insertStoredMessage(domain.db, mailboxId, bytes, {
       threadId: options.threadId,
       labels: options.labels ?? (options.incoming ? ["INBOX"] : []),
-      deliveredTo: options.incoming ? email3 : void 0
+      deliveredTo: options.incoming ? email2 : void 0
     });
     if (options.incoming)
-      applyInboundFilters(domain.db, mailboxId, message2.id);
-    return semanticMessage(domain.db, mailboxId, message2.id);
+      applyInboundFilters(domain.db, mailboxId, message.id);
+    return semanticMessage(domain.db, mailboxId, message.id);
   }).immediate();
 }
-function sendMessage(domain, email3, raw, options = {}) {
+function sendMessage(domain, email2, raw, options = {}) {
   checkFault(domain.db, "messages.send");
-  const senderMailboxId = domain.mailboxId(email3);
+  const senderMailboxId = domain.mailboxId(email2);
   const bytes = acceptedRaw(raw);
   const parsed = parseMime(bytes);
   assertAcceptedFrom(domain, senderMailboxId, parsed.from);
   return domain.db.transaction(() => {
     const recipientEmails = [...new Set([...parsed.to, ...parsed.cc, ...parsed.bcc].map((item) => item.toLowerCase()))];
-    const selfDelivery = deliveryMode(domain) === "seeded-mailboxes" && recipientEmails.includes(email3.toLowerCase());
+    const selfDelivery = deliveryMode(domain) === "seeded-mailboxes" && recipientEmails.includes(email2.toLowerCase());
     const sender = insertStoredMessage(domain.db, senderMailboxId, bytes, {
       threadId: options.threadId,
       labels: selfDelivery ? ["INBOX", "SENT"] : ["SENT"]
@@ -2210,7 +1536,7 @@ function sendMessage(domain, email3, raw, options = {}) {
     if (deliveryMode(domain) === "seeded-mailboxes") {
       const visibleRaw = stripBcc(bytes);
       for (const recipient of recipientEmails) {
-        if (recipient === email3.toLowerCase())
+        if (recipient === email2.toLowerCase())
           continue;
         const mailbox = domain.db.prepare("SELECT id, email FROM mailboxes WHERE email = ? COLLATE NOCASE").get(recipient);
         if (!mailbox)
@@ -2226,11 +1552,11 @@ function sendMessage(domain, email3, raw, options = {}) {
     return { sender: semanticMessage(domain.db, senderMailboxId, sender.id), deliveries };
   }).immediate();
 }
-function modifyMessageLabels(domain, email3, messageId2, add = [], remove = []) {
-  const mailboxId = domain.mailboxId(email3);
+function modifyMessageLabels(domain, email2, messageId, add = [], remove = []) {
+  const mailboxId = domain.mailboxId(email2);
   return domain.db.transaction(() => {
-    const before = semanticMessage(domain.db, mailboxId, messageId2);
-    if (before.labelIds.includes("DRAFT") && (add.some((id2) => id2 !== "DRAFT") || remove.includes("DRAFT"))) {
+    const before = semanticMessage(domain.db, mailboxId, messageId);
+    if (before.labelIds.includes("DRAFT") && (add.some((id) => id !== "DRAFT") || remove.includes("DRAFT"))) {
       invalidArgument("Draft messages may only carry the DRAFT label");
     }
     if (!before.labelIds.includes("DRAFT") && add.includes("DRAFT")) {
@@ -2246,87 +1572,87 @@ function modifyMessageLabels(domain, email3, messageId2, add = [], remove = [])
     const actualRemove = [...removeSet].filter((label2) => before.labelIds.includes(label2));
     const actualAdd = [...addSet].filter((label2) => !before.labelIds.includes(label2));
     for (const label2 of actualRemove) {
-      domain.db.prepare("DELETE FROM message_labels WHERE mailbox_id = ? AND message_id = ? AND label_id = ?").run(mailboxId, messageId2, label2);
+      domain.db.prepare("DELETE FROM message_labels WHERE mailbox_id = ? AND message_id = ? AND label_id = ?").run(mailboxId, messageId, label2);
     }
     for (const label2 of actualAdd) {
-      domain.db.prepare("INSERT OR IGNORE INTO message_labels(mailbox_id, message_id, label_id) VALUES (?, ?, ?)").run(mailboxId, messageId2, label2);
+      domain.db.prepare("INSERT OR IGNORE INTO message_labels(mailbox_id, message_id, label_id) VALUES (?, ?, ?)").run(mailboxId, messageId, label2);
     }
     if (actualAdd.length)
-      addHistory(domain.db, mailboxId, messageId2, before.threadId, "labelAdded", actualAdd);
+      addHistory(domain.db, mailboxId, messageId, before.threadId, "labelAdded", actualAdd);
     if (actualRemove.length) {
-      addHistory(domain.db, mailboxId, messageId2, before.threadId, "labelRemoved", actualRemove);
+      addHistory(domain.db, mailboxId, messageId, before.threadId, "labelRemoved", actualRemove);
     }
-    return semanticMessage(domain.db, mailboxId, messageId2);
+    return semanticMessage(domain.db, mailboxId, messageId);
   }).immediate();
 }
-function modifyThreadLabels(domain, email3, threadId, add = [], remove = []) {
+function modifyThreadLabels(domain, email2, threadId, add = [], remove = []) {
   return domain.db.transaction(() => {
-    const thread = getThread(domain, email3, threadId);
-    for (const message2 of thread.messages)
-      modifyMessageLabels(domain, email3, message2.id, add, remove);
-    return getThread(domain, email3, threadId);
+    const thread = getThread(domain, email2, threadId);
+    for (const message of thread.messages)
+      modifyMessageLabels(domain, email2, message.id, add, remove);
+    return getThread(domain, email2, threadId);
   }).immediate();
 }
-function deleteMessage(domain, email3, messageId2) {
-  const mailboxId = domain.mailboxId(email3);
+function deleteMessage(domain, email2, messageId) {
+  const mailboxId = domain.mailboxId(email2);
   domain.db.transaction(() => {
-    const message2 = semanticMessage(domain.db, mailboxId, messageId2);
-    domain.db.prepare("DELETE FROM messages WHERE mailbox_id = ? AND id = ?").run(mailboxId, messageId2);
-    addHistory(domain.db, mailboxId, messageId2, message2.threadId, "messageDeleted");
-    removeEmptyThread(domain, mailboxId, message2.threadId);
+    const message = semanticMessage(domain.db, mailboxId, messageId);
+    domain.db.prepare("DELETE FROM messages WHERE mailbox_id = ? AND id = ?").run(mailboxId, messageId);
+    addHistory(domain.db, mailboxId, messageId, message.threadId, "messageDeleted");
+    removeEmptyThread(domain, mailboxId, message.threadId);
   }).immediate();
 }
-function batchDeleteMessages(domain, email3, messageIds2) {
-  const mailboxId = domain.mailboxId(email3);
+function batchDeleteMessages(domain, email2, messageIds2) {
+  const mailboxId = domain.mailboxId(email2);
   domain.db.transaction(() => {
-    for (const messageId2 of messageIds2) {
-      const exists = domain.db.prepare("SELECT thread_id FROM messages WHERE mailbox_id = ? AND id = ?").get(mailboxId, messageId2);
+    for (const messageId of messageIds2) {
+      const exists = domain.db.prepare("SELECT thread_id FROM messages WHERE mailbox_id = ? AND id = ?").get(mailboxId, messageId);
       if (!exists)
         continue;
-      domain.db.prepare("DELETE FROM messages WHERE mailbox_id = ? AND id = ?").run(mailboxId, messageId2);
-      addHistory(domain.db, mailboxId, messageId2, exists.thread_id, "messageDeleted");
+      domain.db.prepare("DELETE FROM messages WHERE mailbox_id = ? AND id = ?").run(mailboxId, messageId);
+      addHistory(domain.db, mailboxId, messageId, exists.thread_id, "messageDeleted");
       removeEmptyThread(domain, mailboxId, exists.thread_id);
     }
   }).immediate();
 }
-function deleteThread(domain, email3, threadId) {
-  const mailboxId = domain.mailboxId(email3);
+function deleteThread(domain, email2, threadId) {
+  const mailboxId = domain.mailboxId(email2);
   domain.db.transaction(() => {
-    const thread = getThread(domain, email3, threadId);
+    const thread = getThread(domain, email2, threadId);
     domain.db.prepare("DELETE FROM threads WHERE mailbox_id = ? AND id = ?").run(mailboxId, threadId);
-    for (const message2 of thread.messages) {
-      addHistory(domain.db, mailboxId, message2.id, threadId, "messageDeleted");
+    for (const message of thread.messages) {
+      addHistory(domain.db, mailboxId, message.id, threadId, "messageDeleted");
     }
   }).immediate();
 }
-function headers(domain, email3, messageId2) {
-  const mailboxId = domain.mailboxId(email3);
-  const row = domain.db.prepare("SELECT headers_json FROM messages WHERE mailbox_id = ? AND id = ?").get(mailboxId, messageId2);
+function headers(domain, email2, messageId) {
+  const mailboxId = domain.mailboxId(email2);
+  const row = domain.db.prepare("SELECT headers_json FROM messages WHERE mailbox_id = ? AND id = ?").get(mailboxId, messageId);
   if (!row)
     notFound("Message");
   return JSON.parse(row.headers_json);
 }
-function attachment(domain, email3, messageId2, attachmentId) {
-  const mailboxId = domain.mailboxId(email3);
-  const row = domain.db.prepare("SELECT size, data FROM attachments WHERE mailbox_id = ? AND message_id = ? AND id = ?").get(mailboxId, messageId2, attachmentId);
+function attachment(domain, email2, messageId, attachmentId) {
+  const mailboxId = domain.mailboxId(email2);
+  const row = domain.db.prepare("SELECT size, data FROM attachments WHERE mailbox_id = ? AND message_id = ? AND id = ?").get(mailboxId, messageId, attachmentId);
   if (!row)
     notFound("Attachment");
   return { size: row.size, data: Buffer.from(row.data).toString("base64url") };
 }
-function applyInternalDateSource(domain, email3, messageId2, source) {
-  const mailboxId = domain.mailboxId(email3);
+function applyInternalDateSource(domain, email2, messageId, source) {
+  const mailboxId = domain.mailboxId(email2);
   if (source === "receivedTime") {
     const history = domain.db.prepare(`SELECT created_at FROM history
          WHERE mailbox_id = ? AND message_id = ? AND event_type = 'messageAdded'
-         ORDER BY id DESC LIMIT 1`).get(mailboxId, messageId2);
+         ORDER BY id DESC LIMIT 1`).get(mailboxId, messageId);
     if (history) {
-      domain.db.prepare("UPDATE messages SET internal_date = ? WHERE mailbox_id = ? AND id = ?").run(Date.parse(history.created_at), mailboxId, messageId2);
+      domain.db.prepare("UPDATE messages SET internal_date = ? WHERE mailbox_id = ? AND id = ?").run(Date.parse(history.created_at), mailboxId, messageId);
     }
   }
-  return semanticMessage(domain.db, mailboxId, messageId2);
+  return semanticMessage(domain.db, mailboxId, messageId);
 }
-function searchMessages(domain, email3, query = "", options = {}) {
-  const mailboxId = domain.mailboxId(email3);
+function searchMessages(domain, email2, query = "", options = {}) {
+  const mailboxId = domain.mailboxId(email2);
   const ast = validateSearchQuery(query);
   const explicitAnywhere = /\bin:(anywhere|trash|spam|draft)\b/i.test(query);
   const plan = compileSearchToSql(ast, {
@@ -2356,16 +1682,16 @@ function searchMessages(domain, email3, query = "", options = {}) {
     return messages;
   const now = searchNow(domain.db);
   const documents = batchSearchDocuments(domain.db, mailboxId, messages);
-  return messages.filter((message2, index) => {
-    if (!explicitAnywhere && !options.includeTrash && message2.labelIds.some((id2) => ["TRASH", "SPAM", "DRAFT"].includes(id2))) {
+  return messages.filter((message, index) => {
+    if (!explicitAnywhere && !options.includeTrash && message.labelIds.some((id) => ["TRASH", "SPAM", "DRAFT"].includes(id))) {
       return false;
     }
     return matchesSearch(ast, documents[index], now);
   });
 }
-function searchThreads(domain, email3, query = "", options = {}) {
-  const matches = searchMessages(domain, email3, query, options);
-  return [...new Set(matches.map((message2) => message2.threadId))].map((threadId) => getThread(domain, email3, threadId));
+function searchThreads(domain, email2, query = "", options = {}) {
+  const matches = searchMessages(domain, email2, query, options);
+  return [...new Set(matches.map((message) => message.threadId))].map((threadId) => getThread(domain, email2, threadId));
 }
 function removeEmptyThread(domain, mailboxId, threadId) {
   const member = domain.db.prepare("SELECT 1 FROM messages WHERE mailbox_id = ? AND thread_id = ? LIMIT 1").get(mailboxId, threadId);
@@ -2390,27 +1716,27 @@ function assertAcceptedFrom(domain, mailboxId, from) {
 }
 
 // ../packages/twin-gmail/dist/src/domain/drafts.js
-function createDraft(domain, email3, raw, options = {}) {
-  const mailboxId = domain.mailboxId(email3);
+function createDraft(domain, email2, raw, options = {}) {
+  const mailboxId = domain.mailboxId(email2);
   const bytes = acceptedRaw(raw);
   return domain.db.transaction(() => {
-    const message2 = insertStoredMessage(domain.db, mailboxId, bytes, {
+    const message = insertStoredMessage(domain.db, mailboxId, bytes, {
       threadId: options.threadId,
       draft: true
     });
     const draftId = nextId(domain.db, mailboxId, "draft_counter", "draft");
     const now = nextTimestamp(domain.db, mailboxId);
-    domain.db.prepare("INSERT INTO drafts(mailbox_id, id, message_id, created_at, updated_at) VALUES (?, ?, ?, ?, ?)").run(mailboxId, draftId, message2.id, now, now);
-    addHistory(domain.db, mailboxId, message2.id, message2.threadId, "draftCreated", ["DRAFT"]);
-    return { id: draftId, message: message2 };
+    domain.db.prepare("INSERT INTO drafts(mailbox_id, id, message_id, created_at, updated_at) VALUES (?, ?, ?, ?, ?)").run(mailboxId, draftId, message.id, now, now);
+    addHistory(domain.db, mailboxId, message.id, message.threadId, "draftCreated", ["DRAFT"]);
+    return { id: draftId, message };
   }).immediate();
 }
-function createComposedDraft(domain, email3, input) {
-  const mailboxId = domain.mailboxId(email3);
+function createComposedDraft(domain, email2, input) {
+  const mailboxId = domain.mailboxId(email2);
   return domain.db.transaction(() => {
     const reply = input.replyToMessageId ? semanticMessage(domain.db, mailboxId, input.replyToMessageId) : void 0;
     const raw = composeMime({
-      from: email3,
+      from: email2,
       to: input.to,
       cc: input.cc,
       bcc: input.bcc,
@@ -2423,20 +1749,20 @@ function createComposedDraft(domain, email3, input) {
       references: reply ? [reply.rfcMessageId] : void 0,
       attachments: input.attachments
     });
-    return createDraft(domain, email3, raw, { threadId: reply?.threadId });
+    return createDraft(domain, email2, raw, { threadId: reply?.threadId });
   }).immediate();
 }
-function listDrafts(domain, email3, query = "") {
-  const mailboxId = domain.mailboxId(email3);
+function listDrafts(domain, email2, query = "") {
+  const mailboxId = domain.mailboxId(email2);
   const rows2 = domain.db.prepare(`SELECT d.id, d.message_id
        FROM drafts d JOIN messages m ON m.mailbox_id = d.mailbox_id AND m.id = d.message_id
        WHERE d.mailbox_id = ? ORDER BY d.updated_at DESC, d.id DESC`).all(mailboxId);
-  const matchingIds = query ? new Set(searchMessages(domain, email3, `in:draft ${query}`, { includeTrash: true }).map((message2) => message2.id)) : void 0;
+  const matchingIds = query ? new Set(searchMessages(domain, email2, `in:draft ${query}`, { includeTrash: true }).map((message) => message.id)) : void 0;
   return rows2.filter((row) => matchingIds?.has(row.message_id) ?? true).map((row) => ({ id: row.id, message: semanticMessage(domain.db, mailboxId, row.message_id) }));
 }
-function drafts(domain, email3, query = "", includeTrash = false) {
-  const mailboxId = domain.mailboxId(email3);
-  const matching = query ? new Set(searchMessages(domain, email3, query, { includeTrash }).map((message2) => message2.id)) : null;
+function drafts(domain, email2, query = "", includeTrash = false) {
+  const mailboxId = domain.mailboxId(email2);
+  const matching = query ? new Set(searchMessages(domain, email2, query, { includeTrash }).map((message) => message.id)) : null;
   const rows2 = domain.db.prepare("SELECT id, message_id, updated_at FROM drafts WHERE mailbox_id = ? ORDER BY updated_at DESC, id DESC").all(mailboxId);
   return rows2.filter((row) => !matching || matching.has(row.message_id)).map((row) => ({
     id: row.id,
@@ -2444,15 +1770,15 @@ function drafts(domain, email3, query = "", includeTrash = false) {
     updatedAt: row.updated_at
   }));
 }
-function draft(domain, email3, draftId) {
-  const mailboxId = domain.mailboxId(email3);
+function draft(domain, email2, draftId) {
+  const mailboxId = domain.mailboxId(email2);
   const row = domain.db.prepare("SELECT id, message_id, updated_at FROM drafts WHERE mailbox_id = ? AND id = ?").get(mailboxId, draftId);
   if (!row)
     notFound("Draft");
   return { id: row.id, message: semanticMessage(domain.db, mailboxId, row.message_id), updatedAt: row.updated_at };
 }
-function updateDraft(domain, email3, draftId, raw, options = {}) {
-  const mailboxId = domain.mailboxId(email3);
+function updateDraft(domain, email2, draftId, raw, options = {}) {
+  const mailboxId = domain.mailboxId(email2);
   const bytes = acceptedRaw(raw);
   return domain.db.transaction(() => {
     const draftRow = requireDraft(domain, mailboxId, draftId);
@@ -2469,8 +1795,8 @@ function updateDraft(domain, email3, draftId, raw, options = {}) {
     return { id: draftId, message: replacement };
   }).immediate();
 }
-function sendDraft(domain, email3, draftId) {
-  const mailboxId = domain.mailboxId(email3);
+function sendDraft(domain, email2, draftId) {
+  const mailboxId = domain.mailboxId(email2);
   return domain.db.transaction(() => {
     const draftRow = requireDraft(domain, mailboxId, draftId);
     const raw = rawMessage(domain.db, mailboxId, draftRow.message_id);
@@ -2478,17 +1804,17 @@ function sendDraft(domain, email3, draftId) {
     domain.db.prepare("DELETE FROM drafts WHERE mailbox_id = ? AND id = ?").run(mailboxId, draftId);
     domain.db.prepare("DELETE FROM messages WHERE mailbox_id = ? AND id = ?").run(mailboxId, draftRow.message_id);
     addHistory(domain.db, mailboxId, draftRow.message_id, old.threadId, "draftSent");
-    return sendMessage(domain, email3, raw, { threadId: old.threadId });
+    return sendMessage(domain, email2, raw, { threadId: old.threadId });
   }).immediate();
 }
-function deleteDraft(domain, email3, draftId) {
-  const mailboxId = domain.mailboxId(email3);
+function deleteDraft(domain, email2, draftId) {
+  const mailboxId = domain.mailboxId(email2);
   domain.db.transaction(() => {
     const draftRow = requireDraft(domain, mailboxId, draftId);
-    const message2 = semanticMessage(domain.db, mailboxId, draftRow.message_id);
+    const message = semanticMessage(domain.db, mailboxId, draftRow.message_id);
     domain.db.prepare("DELETE FROM messages WHERE mailbox_id = ? AND id = ?").run(mailboxId, draftRow.message_id);
-    removeEmptyThread(domain, mailboxId, message2.threadId);
-    addHistory(domain.db, mailboxId, draftRow.message_id, message2.threadId, "draftDeleted");
+    removeEmptyThread(domain, mailboxId, message.threadId);
+    addHistory(domain.db, mailboxId, draftRow.message_id, message.threadId, "draftDeleted");
   }).immediate();
 }
 function requireDraft(domain, mailboxId, draftId) {
@@ -2499,22 +1825,22 @@ function requireDraft(domain, mailboxId, draftId) {
 }
 
 // ../packages/twin-gmail/dist/src/domain/labels.js
-function createLabel(domain, email3, name, color) {
-  const mailboxId = domain.mailboxId(email3);
+function createLabel(domain, email2, name, color) {
+  const mailboxId = domain.mailboxId(email2);
   if (!name.trim())
     invalidArgument("Label name is required");
   return domain.db.transaction(() => {
-    const id2 = nextId(domain.db, mailboxId, "label_counter", "Label");
+    const id = nextId(domain.db, mailboxId, "label_counter", "Label");
     try {
-      domain.db.prepare("INSERT INTO labels(mailbox_id, id, name, type, text_color, background_color) VALUES (?, ?, ?, 'user', ?, ?)").run(mailboxId, id2, name.trim(), color?.textColor ?? null, color?.backgroundColor ?? null);
+      domain.db.prepare("INSERT INTO labels(mailbox_id, id, name, type, text_color, background_color) VALUES (?, ?, ?, 'user', ?, ?)").run(mailboxId, id, name.trim(), color?.textColor ?? null, color?.backgroundColor ?? null);
     } catch {
       invalidArgument(`Label already exists: ${name}`);
     }
-    return { id: id2, name: name.trim() };
+    return { id, name: name.trim() };
   }).immediate();
 }
-function listUserLabels(domain, email3) {
-  const mailboxId = domain.mailboxId(email3);
+function listUserLabels(domain, email2) {
+  const mailboxId = domain.mailboxId(email2);
   const rows2 = domain.db.prepare(`SELECT l.id, l.name, l.text_color, l.background_color,
         COUNT(DISTINCT m.thread_id) AS threads_total,
         COUNT(DISTINCT CASE WHEN unread.message_id IS NOT NULL THEN m.thread_id END) AS threads_unread
@@ -2543,8 +1869,8 @@ function listUserLabels(domain, email3) {
     threadsUnread: row.threads_unread
   }));
 }
-function labels(domain, email3) {
-  const mailboxId = domain.mailboxId(email3);
+function labels(domain, email2) {
+  const mailboxId = domain.mailboxId(email2);
   const rows2 = domain.db.prepare(`SELECT l.id, l.name, l.type, l.text_color, l.background_color,
         COUNT(DISTINCT ml.message_id) AS messagesTotal,
         COUNT(DISTINCT CASE WHEN unread.message_id IS NOT NULL THEN ml.message_id END) AS messagesUnread,
@@ -2574,15 +1900,15 @@ function labels(domain, email3) {
     threadsUnread: row.threadsUnread
   }));
 }
-function label(domain, email3, labelId) {
-  const found = labels(domain, email3).find((item) => item.id === labelId);
+function label(domain, email2, labelId) {
+  const found = labels(domain, email2).find((item) => item.id === labelId);
   if (!found)
     notFound("Label");
   return found;
 }
-function updateLabel(domain, email3, labelId, input, replace) {
-  const mailboxId = domain.mailboxId(email3);
-  const current = label(domain, email3, labelId);
+function updateLabel(domain, email2, labelId, input, replace) {
+  const mailboxId = domain.mailboxId(email2);
+  const current = label(domain, email2, labelId);
   if (current.type !== "user")
     invalidArgument("System labels cannot be modified");
   const name = replace ? input.name : input.name ?? current.name;
@@ -2595,38 +1921,38 @@ function updateLabel(domain, email3, labelId, input, replace) {
   } catch {
     invalidArgument(`Label already exists: ${name}`);
   }
-  return label(domain, email3, labelId);
+  return label(domain, email2, labelId);
 }
-function deleteLabel(domain, email3, labelId) {
-  const mailboxId = domain.mailboxId(email3);
-  const current = label(domain, email3, labelId);
+function deleteLabel(domain, email2, labelId) {
+  const mailboxId = domain.mailboxId(email2);
+  const current = label(domain, email2, labelId);
   if (current.type !== "user")
     invalidArgument("System labels cannot be deleted");
   domain.db.prepare("DELETE FROM labels WHERE mailbox_id = ? AND id = ?").run(mailboxId, labelId);
 }
 
 // ../packages/twin-gmail/dist/src/domain/settings.js
-function profile(domain, email3) {
-  const mailboxId = domain.mailboxId(email3);
+function profile(domain, email2) {
+  const mailboxId = domain.mailboxId(email2);
   const totals = domain.db.prepare(`SELECT COUNT(*) AS messagesTotal, COUNT(DISTINCT thread_id) AS threadsTotal
        FROM messages WHERE mailbox_id = ?`).get(mailboxId);
-  return { emailAddress: email3, ...totals, historyId: currentHistoryId(domain, mailboxId) };
+  return { emailAddress: email2, ...totals, historyId: currentHistoryId(domain, mailboxId) };
 }
-function currentHistoryIdFor(domain, email3) {
-  return currentHistoryId(domain, domain.mailboxId(email3));
+function currentHistoryIdFor(domain, email2) {
+  return currentHistoryId(domain, domain.mailboxId(email2));
 }
-function latestMessageHistory(domain, email3, messageId2) {
-  const mailboxId = domain.mailboxId(email3);
-  const row = domain.db.prepare("SELECT MAX(id) AS id FROM history WHERE mailbox_id = ? AND message_id = ?").get(mailboxId, messageId2);
+function latestMessageHistory(domain, email2, messageId) {
+  const mailboxId = domain.mailboxId(email2);
+  const row = domain.db.prepare("SELECT MAX(id) AS id FROM history WHERE mailbox_id = ? AND message_id = ?").get(mailboxId, messageId);
   return String(row.id ?? Number(currentHistoryId(domain, mailboxId)));
 }
-function latestThreadHistory(domain, email3, threadId) {
-  const mailboxId = domain.mailboxId(email3);
+function latestThreadHistory(domain, email2, threadId) {
+  const mailboxId = domain.mailboxId(email2);
   const row = domain.db.prepare("SELECT MAX(id) AS id FROM history WHERE mailbox_id = ? AND thread_id = ?").get(mailboxId, threadId);
   return String(row.id ?? Number(currentHistoryId(domain, mailboxId)));
 }
-function listHistory(domain, email3, startHistoryId, options = {}) {
-  const mailboxId = domain.mailboxId(email3);
+function listHistory(domain, email2, startHistoryId, options = {}) {
+  const mailboxId = domain.mailboxId(email2);
   const start = Number(startHistoryId);
   if (!Number.isSafeInteger(start) || start < 0)
     invalidArgument("Invalid startHistoryId");
@@ -2649,19 +1975,19 @@ function listHistory(domain, email3, startHistoryId, options = {}) {
     historyId: String(current)
   };
 }
-function forwardingAddresses(domain, email3) {
-  const mailboxId = domain.mailboxId(email3);
+function forwardingAddresses(domain, email2) {
+  const mailboxId = domain.mailboxId(email2);
   const rows2 = domain.db.prepare("SELECT email, verification_status FROM forwarding_addresses WHERE mailbox_id = ? ORDER BY email COLLATE NOCASE").all(mailboxId);
   return rows2.map((row) => ({ forwardingEmail: row.email, verificationStatus: row.verification_status }));
 }
-function forwardingAddress(domain, email3, forwardingEmail) {
-  const found = forwardingAddresses(domain, email3).find((item) => item.forwardingEmail.toLowerCase() === forwardingEmail.toLowerCase());
+function forwardingAddress(domain, email2, forwardingEmail) {
+  const found = forwardingAddresses(domain, email2).find((item) => item.forwardingEmail.toLowerCase() === forwardingEmail.toLowerCase());
   if (!found)
     notFound("Forwarding address");
   return found;
 }
-function sendAs(domain, email3) {
-  const mailboxId = domain.mailboxId(email3);
+function sendAs(domain, email2) {
+  const mailboxId = domain.mailboxId(email2);
   const rows2 = domain.db.prepare(`SELECT email, display_name, reply_to_address, is_primary, is_default, verification_status
        FROM send_as WHERE mailbox_id = ? ORDER BY is_primary DESC, email COLLATE NOCASE`).all(mailboxId);
   return rows2.map((row) => ({
@@ -2675,8 +2001,8 @@ function sendAs(domain, email3) {
     signature: ""
   }));
 }
-function sendAsAddress(domain, email3, sendAsEmail) {
-  const found = sendAs(domain, email3).find((item) => String(item.sendAsEmail).toLowerCase() === sendAsEmail.toLowerCase());
+function sendAsAddress(domain, email2, sendAsEmail) {
+  const found = sendAs(domain, email2).find((item) => String(item.sendAsEmail).toLowerCase() === sendAsEmail.toLowerCase());
   if (!found)
     notFound("Send-as alias");
   return found;
@@ -2711,730 +2037,143 @@ var GmailDomain = class {
     this.seed(defaultSeedState());
     return { ok: true };
   }
-  mailboxId(email3) {
-    const row = this.db.prepare("SELECT id FROM mailboxes WHERE email = ? COLLATE NOCASE").get(email3);
+  mailboxId(email2) {
+    const row = this.db.prepare("SELECT id FROM mailboxes WHERE email = ? COLLATE NOCASE").get(email2);
     if (!row)
       notFound("User");
     return row.id;
   }
-  getRaw(email3, messageId2) {
-    return getRaw(this, email3, messageId2);
+  getRaw(email2, messageId) {
+    return getRaw(this, email2, messageId);
   }
-  getMessage(email3, messageId2) {
-    return getMessage(this, email3, messageId2);
+  getMessage(email2, messageId) {
+    return getMessage(this, email2, messageId);
   }
-  getThread(email3, threadId) {
-    return getThread(this, email3, threadId);
+  getThread(email2, threadId) {
+    return getThread(this, email2, threadId);
   }
-  insertMessage(email3, raw, options = {}) {
-    return insertMessage(this, email3, raw, options);
+  insertMessage(email2, raw, options = {}) {
+    return insertMessage(this, email2, raw, options);
   }
-  sendMessage(email3, raw, options = {}) {
-    return sendMessage(this, email3, raw, options);
+  sendMessage(email2, raw, options = {}) {
+    return sendMessage(this, email2, raw, options);
   }
-  createDraft(email3, raw, options = {}) {
-    return createDraft(this, email3, raw, options);
+  createDraft(email2, raw, options = {}) {
+    return createDraft(this, email2, raw, options);
   }
-  createComposedDraft(email3, input) {
-    return createComposedDraft(this, email3, input);
+  createComposedDraft(email2, input) {
+    return createComposedDraft(this, email2, input);
   }
-  listDrafts(email3, query = "") {
-    return listDrafts(this, email3, query);
+  listDrafts(email2, query = "") {
+    return listDrafts(this, email2, query);
   }
-  drafts(email3, query = "", includeTrash = false) {
-    return drafts(this, email3, query, includeTrash);
+  drafts(email2, query = "", includeTrash = false) {
+    return drafts(this, email2, query, includeTrash);
   }
-  draft(email3, draftId) {
-    return draft(this, email3, draftId);
+  draft(email2, draftId) {
+    return draft(this, email2, draftId);
   }
-  updateDraft(email3, draftId, raw, options = {}) {
-    return updateDraft(this, email3, draftId, raw, options);
+  updateDraft(email2, draftId, raw, options = {}) {
+    return updateDraft(this, email2, draftId, raw, options);
   }
-  sendDraft(email3, draftId) {
-    return sendDraft(this, email3, draftId);
+  sendDraft(email2, draftId) {
+    return sendDraft(this, email2, draftId);
   }
-  deleteDraft(email3, draftId) {
-    deleteDraft(this, email3, draftId);
+  deleteDraft(email2, draftId) {
+    deleteDraft(this, email2, draftId);
   }
-  modifyMessageLabels(email3, messageId2, add = [], remove = []) {
-    return modifyMessageLabels(this, email3, messageId2, add, remove);
+  modifyMessageLabels(email2, messageId, add = [], remove = []) {
+    return modifyMessageLabels(this, email2, messageId, add, remove);
   }
-  modifyThreadLabels(email3, threadId, add = [], remove = []) {
-    return modifyThreadLabels(this, email3, threadId, add, remove);
+  modifyThreadLabels(email2, threadId, add = [], remove = []) {
+    return modifyThreadLabels(this, email2, threadId, add, remove);
   }
-  deleteMessage(email3, messageId2) {
-    deleteMessage(this, email3, messageId2);
+  deleteMessage(email2, messageId) {
+    deleteMessage(this, email2, messageId);
   }
-  batchDeleteMessages(email3, messageIds2) {
-    batchDeleteMessages(this, email3, messageIds2);
+  batchDeleteMessages(email2, messageIds2) {
+    batchDeleteMessages(this, email2, messageIds2);
   }
-  deleteThread(email3, threadId) {
-    deleteThread(this, email3, threadId);
+  deleteThread(email2, threadId) {
+    deleteThread(this, email2, threadId);
   }
-  headers(email3, messageId2) {
-    return headers(this, email3, messageId2);
+  headers(email2, messageId) {
+    return headers(this, email2, messageId);
   }
-  attachment(email3, messageId2, attachmentId) {
-    return attachment(this, email3, messageId2, attachmentId);
+  attachment(email2, messageId, attachmentId) {
+    return attachment(this, email2, messageId, attachmentId);
   }
-  applyInternalDateSource(email3, messageId2, source) {
-    return applyInternalDateSource(this, email3, messageId2, source);
+  applyInternalDateSource(email2, messageId, source) {
+    return applyInternalDateSource(this, email2, messageId, source);
   }
-  createLabel(email3, name, color) {
-    return createLabel(this, email3, name, color);
+  createLabel(email2, name, color) {
+    return createLabel(this, email2, name, color);
   }
-  listUserLabels(email3) {
-    return listUserLabels(this, email3);
+  listUserLabels(email2) {
+    return listUserLabels(this, email2);
   }
-  labels(email3) {
-    return labels(this, email3);
+  labels(email2) {
+    return labels(this, email2);
   }
-  label(email3, labelId) {
-    return label(this, email3, labelId);
+  label(email2, labelId) {
+    return label(this, email2, labelId);
   }
-  updateLabel(email3, labelId, input, replace) {
-    return updateLabel(this, email3, labelId, input, replace);
+  updateLabel(email2, labelId, input, replace) {
+    return updateLabel(this, email2, labelId, input, replace);
   }
-  deleteLabel(email3, labelId) {
-    deleteLabel(this, email3, labelId);
+  deleteLabel(email2, labelId) {
+    deleteLabel(this, email2, labelId);
   }
-  filters(email3) {
-    return filters(this, email3);
+  filters(email2) {
+    return filters(this, email2);
   }
-  filter(email3, filterId) {
-    return filter(this, email3, filterId);
+  filter(email2, filterId) {
+    return filter(this, email2, filterId);
   }
-  createFilter(email3, criteria = {}, action = {}) {
-    return createFilter(this, email3, criteria, action);
+  createFilter(email2, criteria = {}, action = {}) {
+    return createFilter(this, email2, criteria, action);
   }
-  deleteFilter(email3, filterId) {
-    deleteFilter(this, email3, filterId);
+  deleteFilter(email2, filterId) {
+    deleteFilter(this, email2, filterId);
   }
-  listHistory(email3, startHistoryId, options = {}) {
-    return listHistory(this, email3, startHistoryId, options);
+  listHistory(email2, startHistoryId, options = {}) {
+    return listHistory(this, email2, startHistoryId, options);
   }
-  profile(email3) {
-    return profile(this, email3);
+  profile(email2) {
+    return profile(this, email2);
   }
-  currentHistoryIdFor(email3) {
-    return currentHistoryIdFor(this, email3);
+  currentHistoryIdFor(email2) {
+    return currentHistoryIdFor(this, email2);
   }
-  latestMessageHistory(email3, messageId2) {
-    return latestMessageHistory(this, email3, messageId2);
+  latestMessageHistory(email2, messageId) {
+    return latestMessageHistory(this, email2, messageId);
   }
-  latestThreadHistory(email3, threadId) {
-    return latestThreadHistory(this, email3, threadId);
+  latestThreadHistory(email2, threadId) {
+    return latestThreadHistory(this, email2, threadId);
   }
-  forwardingAddresses(email3) {
-    return forwardingAddresses(this, email3);
+  forwardingAddresses(email2) {
+    return forwardingAddresses(this, email2);
   }
-  forwardingAddress(email3, forwardingEmail) {
-    return forwardingAddress(this, email3, forwardingEmail);
+  forwardingAddress(email2, forwardingEmail) {
+    return forwardingAddress(this, email2, forwardingEmail);
   }
-  sendAs(email3) {
-    return sendAs(this, email3);
+  sendAs(email2) {
+    return sendAs(this, email2);
   }
-  sendAsAddress(email3, sendAsEmail) {
-    return sendAsAddress(this, email3, sendAsEmail);
+  sendAsAddress(email2, sendAsEmail) {
+    return sendAsAddress(this, email2, sendAsEmail);
   }
-  searchMessages(email3, query = "", options = {}) {
-    return searchMessages(this, email3, query, options);
+  searchMessages(email2, query = "", options = {}) {
+    return searchMessages(this, email2, query, options);
   }
-  searchThreads(email3, query = "", options = {}) {
-    return searchThreads(this, email3, query, options);
+  searchThreads(email2, query = "", options = {}) {
+    return searchThreads(this, email2, query, options);
   }
   exportState() {
     return exportGmailState(this.db);
   }
 };
 
-// ../packages/twin-gmail/dist/src/check-params.js
-var messageId = {
-  name: "message",
-  pattern: "[A-Za-z0-9_-]{1,128}",
-  example: "msg_support",
-  render: (value) => value,
-  parse: (raw) => raw
-};
-var labelRef = {
-  name: "label",
-  pattern: "[A-Za-z0-9_-]{1,128}",
-  example: "STARRED",
-  render: (value) => value,
-  parse: (raw) => raw
-};
-var labelName = {
-  name: "label",
-  pattern: "[A-Za-z0-9][A-Za-z0-9 _-]{0,127}",
-  example: "Parity Complete",
-  render: (value) => value,
-  parse: (raw) => raw
-};
-var emailAddress = {
-  name: "email",
-  pattern: "[^\\s@\"'`]+@[^\\s@\"'`]+",
-  example: "alice@example.com",
-  render: (value) => value,
-  parse: (raw) => raw
-};
-var mailboxRef = {
-  name: "mailbox",
-  pattern: "[^\\s@\"'`]+@[^\\s@\"'`]+",
-  example: "pome-agent@pome-twin.test",
-  render: (value) => value,
-  parse: (raw) => raw
-};
-var exactCount = {
-  name: "count",
-  pattern: "\\d{1,9}",
-  example: "5",
-  render: (value) => value,
-  parse: (raw) => raw
-};
-var countWord = {
-  name: "count",
-  pattern: "(?:\\d{1,9}|zero|one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve)",
-  example: "two",
-  render: (value) => value,
-  parse: (raw) => raw
-};
-var NUMBER_WORDS = {
-  zero: 0,
-  one: 1,
-  two: 2,
-  three: 3,
-  four: 4,
-  five: 5,
-  six: 6,
-  seven: 7,
-  eight: 8,
-  nine: 9,
-  ten: 10,
-  eleven: 11,
-  twelve: 12
-};
-function parseCount(raw) {
-  const trimmed = raw.trim().toLowerCase();
-  if (/^\d+$/.test(trimmed))
-    return Number(trimmed);
-  return NUMBER_WORDS[trimmed] ?? null;
-}
-
-// ../packages/twin-gmail/dist/src/check-state.js
-var MESSAGES_PATH = statePath("messages");
-var DRAFTS_PATH = statePath("drafts");
-var LABELS_PATH = statePath("labels");
-var MESSAGE_LABELS_PATH = statePath("messageLabels");
-function missSkip(miss) {
-  const outcome = { passed: false, status: "skipped", reason: miss.missing };
-  if (miss.searched === void 0)
-    return outcome;
-  return { ...outcome, evidenceStatePaths: [miss.searched] };
-}
-var lower = (value) => (value ?? "").toLowerCase();
-function isTruncated(state, collection) {
-  return (state.exportBounds?.truncatedCollections ?? []).includes(collection);
-}
-function resolveMessage(state, id2) {
-  if (state.messages == null)
-    return { missing: "state_incomplete" };
-  const indices = state.messages.map((message2, index) => lower(message2.id) === lower(id2) ? index : -1).filter((index) => index >= 0);
-  if (indices.length > 1) {
-    return {
-      missing: `message_ambiguous ("${id2}" exists in ${indices.length} mailboxes)`,
-      searched: MESSAGES_PATH
-    };
-  }
-  if (indices.length === 1) {
-    const index = indices[0];
-    return { found: state.messages[index], path: childStatePath(MESSAGES_PATH, index) };
-  }
-  if (isTruncated(state, "messages")) {
-    return { missing: 'collection_truncated ("messages")', searched: MESSAGES_PATH };
-  }
-  return { missing: `message_not_found ("${id2}")`, searched: MESSAGES_PATH };
-}
-function labelIdsFor(state, wanted) {
-  const ids = /* @__PURE__ */ new Set([lower(wanted)]);
-  for (const label2 of state.labels ?? []) {
-    const matches = lower(label2.name) === lower(wanted) || lower(label2.id) === lower(wanted);
-    if (matches && label2.id != null)
-      ids.add(lower(label2.id));
-  }
-  return ids;
-}
-function messageCarriesLabel(state, messageId2, wanted) {
-  if (state.messageLabels == null)
-    return { missing: "state_incomplete" };
-  const ids = labelIdsFor(state, wanted);
-  const carried = state.messageLabels.some((row) => lower(row.messageId) === lower(messageId2) && ids.has(lower(row.labelId)));
-  if (!carried && isTruncated(state, "messageLabels")) {
-    return { missing: 'collection_truncated ("messageLabels")', searched: MESSAGE_LABELS_PATH };
-  }
-  return { found: carried, path: MESSAGE_LABELS_PATH };
-}
-function resolveLabelByName(state, name) {
-  if (state.labels == null)
-    return { missing: "state_incomplete" };
-  const index = state.labels.findIndex((label2) => lower(label2.name) === lower(name));
-  if (index >= 0) {
-    return { found: state.labels[index], path: childStatePath(LABELS_PATH, index) };
-  }
-  if (isTruncated(state, "labels")) {
-    return { missing: 'collection_truncated ("labels")', searched: LABELS_PATH };
-  }
-  return { missing: `label_not_found ("${name}")`, searched: LABELS_PATH };
-}
-function draftRecipients(state, draft3) {
-  const message2 = (state.messages ?? []).find((candidate) => lower(candidate.id) === lower(draft3.messageId));
-  if (!message2)
-    return [];
-  return [...message2.to ?? [], ...message2.cc ?? []];
-}
-
-// ../packages/twin-gmail/dist/src/check-worlds.js
-var FIXTURE_MAILBOX = "pome-agent@pome-twin.test";
-function gmailState(parts = {}) {
-  return {
-    mailboxes: [{ email: FIXTURE_MAILBOX }],
-    messages: [],
-    drafts: [],
-    labels: [],
-    messageLabels: [],
-    exportBounds: { messageBodiesOmitted: true, largeMailbox: false, truncatedCollections: [] },
-    ...parts
-  };
-}
-function finalWorld(final) {
-  return { seed: null, final, tape: null };
-}
-function tapeWorld(tape) {
-  return { seed: null, final: gmailState(), tape };
-}
-function message(id2, parts = {}) {
-  return { mailboxEmail: FIXTURE_MAILBOX, id: id2, to: [FIXTURE_MAILBOX], bodyOmitted: true, ...parts };
-}
-function systemLabel(name) {
-  return { mailboxEmail: FIXTURE_MAILBOX, id: name, name, type: "system" };
-}
-function userLabel(id2, name) {
-  return { mailboxEmail: FIXTURE_MAILBOX, id: id2, name, type: "user" };
-}
-function messageLabel(messageId2, labelId) {
-  return { mailboxEmail: FIXTURE_MAILBOX, messageId: messageId2, labelId };
-}
-function draft2(id2, messageId2) {
-  return { mailboxEmail: FIXTURE_MAILBOX, id: id2, messageId: messageId2 };
-}
-function draftAddressedTo(id2, recipients) {
-  const messageId2 = `${id2}_message`;
-  return {
-    draft: draft2(id2, messageId2),
-    message: message(messageId2, { to: recipients })
-  };
-}
-
-// ../packages/twin-gmail/dist/src/check-drafts.js
-var draftAddressedTo2 = defineCheck({
-  id: "gmail.draft-addressed-to",
-  description: "Joins every draft to its backing message and asks whether any of them addresses this recipient in `to` or `cc`, compared case-insensitively as an EXACT address rather than a substring. It asserts nothing about the draft's body \u2014 message bodies are digested out of the state export unconditionally, so no check on this twin can read one \u2014 and nothing about whether the draft was left unsent, which is a separate claim. A draft whose backing message did not survive the export contributes no recipients rather than throwing.",
-  template: "A draft addressed to {email} exists",
-  params: { email: emailAddress },
-  substrate: "final",
-  // An achievement: task 22's seed ships one draft addressed to bob, so an
-  // examinee that does nothing does not satisfy this.
-  polarity: () => "positive",
-  //
-  // THE LOAD-BEARING DECLARATION ON THIS CHECK.
-  //
-  // pome-cloud's `corpus.ts` has carried a prediction about this exact criterion
-  // since F-1028: `22-gmail-inbox-triage`'s `alice@example.com` "becomes visible
-  // here as 'unguarded' the day a gmail draft-recipient predicate lands without a
-  // `subject`, which is precisely when it starts to matter." An email address is
-  // squarely inside what a team's redaction config may destroy. Without this
-  // field the evaluator has no way to turn an impossible comparison into an
-  // honest skip, so the criterion scores a vacuous verdict at both doors
-  // instead — and the count of unguarded hazards must stay at zero.
-  subject: ({ email: email3 }) => email3,
-  // The address is the scanned literal, so the mutant points at it. It stays
-  // email-shaped so it re-binds to this same check: a mutant that stops matching
-  // evaluates to `unmatched`, which reads as "the verdict moved -> healthy" and
-  // hands the criterion a clean bill it did not earn.
-  vacuityMutant: (args) => ({ ...args, email: `${VACUITY_SENTINEL}@example.invalid` }),
-  discriminatingWorlds: ({ email: email3 }) => {
-    const wanted = draftAddressedTo("draft_target", [email3]);
-    const other = draftAddressedTo("draft_other", ["someone-else@example.com"]);
-    return {
-      passing: finalWorld(gmailState({ drafts: [wanted.draft], messages: [wanted.message] })),
-      failing: finalWorld(gmailState({ drafts: [other.draft], messages: [other.message] }))
-    };
-  },
-  evaluate({ email: email3 }, { final }) {
-    if (final.drafts == null || final.messages == null) {
-      return { passed: false, status: "skipped", reason: "state_incomplete" };
-    }
-    const wanted = email3.toLowerCase();
-    const index = final.drafts.findIndex((entry) => draftRecipients(final, entry).some((to) => to.toLowerCase() === wanted));
-    if (index >= 0) {
-      const hit = final.drafts[index];
-      return {
-        passed: true,
-        reason: `draft ${hit.id ?? "?"} is addressed to ${email3}`,
-        // The DRAFT row, not the backing message that actually holds the
-        // address. A reader following this pointer lands on the thing the
-        // sentence is about — "a draft addressed to X" — and the join to the
-        // message is an implementation detail of how the twin exports, not the
-        // claim (F-1197).
-        evidenceStatePaths: [childStatePath(DRAFTS_PATH, index)]
-      };
-    }
-    if (isTruncated(final, "drafts") || isTruncated(final, "messages")) {
-      return { passed: false, status: "skipped", reason: "collection_truncated" };
-    }
-    return {
-      passed: false,
-      reason: `no draft is addressed to ${email3} (${final.drafts.length} draft(s) inspected)`,
-      evidenceStatePaths: [DRAFTS_PATH]
-    };
-  }
-});
-var draftCountAtLeast = defineCheck({
-  id: "gmail.draft-count-at-least",
-  description: "Counts the rows in the exported `drafts` collection and asserts there are AT LEAST this many \u2014 a lower bound, so a mailbox with more drafts than asked still passes. It counts drafts the SEED placed there as well as any the examinee created, which means a criterion whose number the seed already satisfies can be passed by an agent that does nothing. That is a property of the task, not of this check, and `measure-criterion-discrimination` is where it surfaces.",
-  template: "At least {count} drafts exist",
-  params: { count: countWord },
-  substrate: "final",
-  polarity: () => "positive",
-  // A threshold, not a literal hunted for inside state — there is nothing here a
-  // redactor could silently delete.
-  subject: () => null,
-  //
-  // The NUMERIC sentinel, and the argument D10 demands before it may be used.
-  //
-  // In every other pattern a numeric capture is a SELECTOR — an issue number, a
-  // PR number — that the predicate RESOLVES before it scans anything, so
-  // falsifying it early-returns "not found" and moves the verdict for a reason
-  // that never reaches the assertion. Here the count is the ONLY slot and there
-  // is nothing to resolve: it is compared directly against a cardinality the
-  // predicate computes, so falsifying it moves the verdict THROUGH the
-  // assertion. That is the same argument `stripe.payment-intent-amount` makes,
-  // and it is why this check is the second entry in pome-cloud's
-  // `NUMERIC_SENTINEL_ALLOWED`.
-  vacuityMutant: (args) => ({ ...args, count: String(VACUITY_SENTINEL_NUMBER) }),
-  discriminatingWorlds: ({ count }) => {
-    const wanted = parseCount(count) ?? 1;
-    const build = (n) => {
-      const pairs = Array.from({ length: n }, (_, i) => draftAddressedTo(`draft_${i}`, ["a@example.com"]));
-      return gmailState({
-        drafts: pairs.map((p) => p.draft),
-        messages: pairs.map((p) => p.message)
-      });
-    };
-    return { passing: finalWorld(build(wanted)), failing: finalWorld(build(Math.max(0, wanted - 1))) };
-  },
-  evaluate({ count }, { final }) {
-    const wanted = parseCount(count);
-    if (wanted === null) {
-      return { passed: false, status: "skipped", reason: `uncountable ("${count}")` };
-    }
-    if (final.drafts == null)
-      return { passed: false, status: "skipped", reason: "state_incomplete" };
-    const total = final.drafts.length;
-    if (total < wanted && isTruncated(final, "drafts")) {
-      return { passed: false, status: "skipped", reason: 'collection_truncated ("drafts")' };
-    }
-    return {
-      passed: total >= wanted,
-      reason: `${total} draft(s) exist (wanted at least ${wanted})`,
-      // The collection whose LENGTH is the assertion. There is no narrower
-      // address for a cardinality.
-      evidenceStatePaths: [DRAFTS_PATH]
-    };
-  }
-});
-
-// ../packages/twin-gmail/dist/src/check-labels.js
-var labelExists = defineCheck({
-  id: "gmail.label-exists",
-  description: "Asks whether the mailbox defines a label with this DISPLAY NAME, compared case-insensitively the way the twin's own seeder keys its uniqueness lookup. It reads the `labels` collection only \u2014 a label that exists but has been applied to nothing still passes, and a message carrying a label is `gmail.message-has-label`'s question, not this one. It deliberately does NOT match on the minted id: `Label_follow_up` is an id and `Follow Up` is the name of that same label, and letting one sentence mean both would make the assertion unreadable.",
-  // The name slot admits spaces, which is what the corpus needs (`Parity
-  // Complete`) and what separates this template from `gmail.message-has-label`'s
-  // id slot. The two cannot claim one sentence: this one says "A label named",
-  // that one says "Message ... has label".
-  template: "A label named {label} exists",
-  params: { label: labelName },
-  substrate: "final",
-  // An achievement — task 23's seed defines no `Parity Complete`, so the
-  // examinee has to create it.
-  polarity: () => "positive",
-  // The name is a caller-supplied literal compared against state.
-  subject: ({ label: label2 }) => label2,
-  vacuityMutant: (args) => ({ ...args, label: VACUITY_SENTINEL }),
-  discriminatingWorlds: ({ label: label2 }) => ({
-    // Both worlds carry a non-empty `labels` collection, so the failing world
-    // fails on the ASSERTION (`label_not_found`) rather than reproducing the
-    // `state_incomplete` an empty world gives — the degenerate arm the probe
-    // rejects.
-    passing: finalWorld(gmailState({ labels: [systemLabel("INBOX"), userLabel("Label_1", label2)] })),
-    failing: finalWorld(gmailState({ labels: [systemLabel("INBOX")] }))
-  }),
-  evaluate({ label: label2 }, { final }) {
-    const found = resolveLabelByName(final, label2);
-    if ("missing" in found) {
-      if (found.missing.startsWith("label_not_found")) {
-        return {
-          passed: false,
-          reason: `no label named "${label2}" exists`,
-          // The label COLLECTION — the honest citation for a lookup that found
-          // nothing, and the arm a reader most wants to open: see for yourself
-          // that the name is not in it (F-1197).
-          ...found.searched === void 0 ? {} : { evidenceStatePaths: [found.searched] }
-        };
-      }
-      return missSkip(found);
-    }
-    return {
-      passed: true,
-      reason: `label "${label2}" exists (id ${found.found.id ?? "?"})`,
-      evidenceStatePaths: [found.path]
-    };
-  }
-});
-
-// ../packages/twin-gmail/dist/src/check-messages.js
-var messageHasLabel = defineCheck({
-  id: "gmail.message-has-label",
-  description: "Looks the message up by id, then asks the `messageLabels` JOIN whether any row links it to the named label. The label may be given as its minted id (`Label_follow_up`) or as the display name of the same label (`Follow Up`); a system label carries both as one string (`INBOX`, `STARRED`). It asserts nothing about the message's OTHER labels \u2014 a message carrying the named label plus five more passes. A message the export does not carry is a SKIP, not a fail, and so is a label collection the export truncated: absent from a capped list is not absent.",
-  template: "Message {message} has label {label}",
-  params: { message: messageId, label: labelRef },
-  substrate: "final",
-  // An achievement. The seed leaves `msg_support` on INBOX/UNREAD only, so the
-  // examinee has to act for this to hold.
-  polarity: () => "positive",
-  // The label is a caller-supplied literal compared against state, so it is
-  // declared. No first-party redactor pattern touches a Gmail label id, which is
-  // exactly why declaring it keeps that a verified fact rather than an
-  // assumption — a team's own redaction config is not first-party.
-  subject: ({ label: label2 }) => label2,
-  // The message id only SELECTS; falsifying it moves the verdict through the
-  // lookup rather than the assertion. The label is the scanned literal.
-  vacuityMutant: (args) => ({ ...args, label: VACUITY_SENTINEL }),
-  discriminatingWorlds: ({ message: id2, label: label2 }) => {
-    const labels2 = [systemLabel("INBOX"), userLabel(label2, label2)];
-    const base = { messages: [message(id2)], labels: labels2 };
-    return {
-      passing: finalWorld(gmailState({ ...base, messageLabels: [messageLabel(id2, "INBOX"), messageLabel(id2, label2)] })),
-      failing: finalWorld(gmailState({ ...base, messageLabels: [messageLabel(id2, "INBOX")] }))
-    };
-  },
-  evaluate({ message: id2, label: label2 }, { final }) {
-    const found = resolveMessage(final, id2);
-    if ("missing" in found)
-      return missSkip(found);
-    const carried = messageCarriesLabel(final, id2, label2);
-    if ("missing" in carried)
-      return missSkip(carried);
-    return {
-      passed: carried.found,
-      reason: carried.found ? `message ${id2} carries label ${label2}` : `message ${id2} does not carry label ${label2}`,
-      // BOTH halves of the lookup, because the predicate really does read two
-      // places: the message row it resolved by id, and the join table it then
-      // questioned. Labels are not nested under their message in this export —
-      // that is the whole reason `messageCarriesLabel` exists — so one pointer
-      // could not say where this verdict came from (F-1197).
-      evidenceStatePaths: [found.path, carried.path]
-    };
-  }
-});
-var mailboxLabelCount = defineCheck({
-  id: "gmail.mailbox-label-count",
-  description: "Counts the messages in the named mailbox that the `messageLabels` JOIN links to the named label, and asserts the total is EXACTLY the number given. Not 'at least' \u2014 a mailbox with six SENT messages fails a criterion asking for five, which is what makes it able to catch a duplicate send. A mailbox the export lists but does not contain is a SKIP; so is a truncated collection.",
-  template: "The mailbox `{mailbox}` has exactly {count} messages labeled {label}",
-  params: { mailbox: mailboxRef, count: exactCount, label: labelRef },
-  substrate: "final",
-  // The count carries the direction: asserting zero is a prohibition, any
-  // other count is work the examinee must do. Preserved from the legacy rule,
-  // which computed the same thing per match.
-  polarity: ({ count }) => Number(count) === 0 ? "negative" : "positive",
-  subject: ({ label: label2 }) => label2,
-  // The mailbox resolves and the count is compared to a derived total; the
-  // label is the literal actually scanned in state. Pointing the mutant at the
-  // count would falsify a threshold rather than a lookup — see
-  // `gmail.draft-count-at-least`, where the count IS the only slot.
-  vacuityMutant: (args) => ({ ...args, label: VACUITY_SENTINEL }),
-  discriminatingWorlds: ({ mailbox, count, label: label2 }) => {
-    const wanted = Number(count);
-    const world = (n) => {
-      const messages = Array.from({ length: n }, (_, i) => message(`msg_${i}`, { mailboxEmail: mailbox }));
-      return gmailState({
-        mailboxes: [{ email: mailbox }],
-        messages,
-        labels: [systemLabel(label2)],
-        messageLabels: messages.map((m) => ({ mailboxEmail: mailbox, messageId: m.id, labelId: label2 }))
-      });
-    };
-    return { passing: finalWorld(world(wanted)), failing: finalWorld(world(wanted + 1)) };
-  },
-  evaluate({ mailbox, count, label: label2 }, { final }) {
-    const wanted = Number(count);
-    if (final.messages == null || final.messageLabels == null) {
-      return { passed: false, status: "skipped", reason: "state_incomplete" };
-    }
-    if (isTruncated(final, "messages") || isTruncated(final, "messageLabels")) {
-      return { passed: false, status: "skipped", reason: "collection_truncated" };
-    }
-    if (final.mailboxes != null && !final.mailboxes.some((mb) => (mb.email ?? "").toLowerCase() === mailbox.toLowerCase())) {
-      return { passed: false, status: "skipped", reason: `mailbox_not_found ("${mailbox}")` };
-    }
-    const ids = labelIdsFor(final, label2);
-    const labeled = new Set(final.messageLabels.filter((row) => ids.has((row.labelId ?? "").toLowerCase())).map((row) => (row.messageId ?? "").toLowerCase()));
-    const total = final.messages.filter((msg) => (msg.mailboxEmail ?? "").toLowerCase() === mailbox.toLowerCase() && msg.id != null && labeled.has(msg.id.toLowerCase())).length;
-    return {
-      passed: total === wanted,
-      reason: `mailbox "${mailbox}" has ${total} message(s) labeled ${label2} (wanted ${wanted})`,
-      // The two collections the count is computed FROM. The count itself lives
-      // nowhere in the tree, so there is no narrower honest address — and the
-      // guards above already established that both collections are present and
-      // un-capped, which is what makes these pointers resolve.
-      evidenceStatePaths: [MESSAGES_PATH, MESSAGE_LABELS_PATH]
-    };
-  }
-});
-var oneMessagePerRecipient = defineCheck({
-  id: "gmail.one-message-per-recipient",
-  description: "Flattens every addressee across the messages carrying the named label and asserts each address appears EXACTLY ONCE \u2014 and, when a count is named, that there are that many messages, that many distinct recipients, and no more addressee slots than that. It is the assertion that separates 'sent to everyone' from 'sent to everyone, some of them twice', which an exact total alone cannot do.",
-  template: "Exactly one {label} message is addressed to each of the {count} recipients",
-  params: { label: labelRef, count: countWord },
-  substrate: "final",
-  polarity: () => "positive",
-  subject: ({ label: label2 }) => label2,
-  // The label is scanned; the count is a declared arity compared to a derived
-  // one. Same argument as `mailboxLabelCount`.
-  vacuityMutant: (args) => ({ ...args, label: VACUITY_SENTINEL }),
-  discriminatingWorlds: ({ label: label2, count }) => {
-    const wanted = parseCount(count) ?? 1;
-    const recipients = Array.from({ length: wanted }, (_, i) => `user${i}@example.com`);
-    const build = (addressees) => {
-      const messages = addressees.map((to, i) => message(`msg_${i}`, { to }));
-      return finalWorld(gmailState({
-        messages,
-        labels: [systemLabel(label2)],
-        messageLabels: messages.map((m) => messageLabel(m.id, label2))
-      }));
-    };
-    return {
-      passing: build(recipients.map((r) => [r])),
-      // The DUPLICATE SEND, not a missing one: the same number of messages, one
-      // recipient served twice and another not at all. A world with fewer
-      // messages would fail on arity, which the exact-count check already covers.
-      failing: build([[recipients[0]], ...recipients.slice(2).map((r) => [r]), [recipients[0]]])
-    };
-  },
-  evaluate({ label: label2, count }, { final }) {
-    const wanted = parseCount(count);
-    if (final.messages == null || final.messageLabels == null) {
-      return { passed: false, status: "skipped", reason: "state_incomplete" };
-    }
-    if (isTruncated(final, "messages") || isTruncated(final, "messageLabels")) {
-      return { passed: false, status: "skipped", reason: "collection_truncated" };
-    }
-    const ids = labelIdsFor(final, label2);
-    const labeled = new Set(final.messageLabels.filter((row) => ids.has((row.labelId ?? "").toLowerCase())).map((row) => (row.messageId ?? "").toLowerCase()));
-    const sent = final.messages.filter((msg) => msg.id != null && labeled.has(msg.id.toLowerCase()));
-    const addressees = sent.flatMap((msg) => (msg.to ?? []).map((to) => to.toLowerCase()));
-    const distinct = new Set(addressees);
-    const noDuplicates = addressees.length === distinct.size;
-    const arityOk = wanted == null ? sent.length === distinct.size : sent.length === wanted && distinct.size === wanted && addressees.length === wanted;
-    const passed = noDuplicates && arityOk;
-    return {
-      passed,
-      reason: passed ? `${sent.length} ${label2} message(s), one per distinct recipient, no duplicates` : `${sent.length} ${label2} message(s) to ${distinct.size} distinct recipient(s) (${addressees.length} addressee slot(s)${wanted == null ? "" : `, wanted ${wanted}`}${noDuplicates ? "" : ", duplicate send detected"})`,
-      // Same two collections, same reason: the duplicate this check exists to
-      // catch is a property of the addressee lists across `messages`, filtered
-      // by `messageLabels`, and neither the flattened list nor its distinct set
-      // is anything the tree holds.
-      evidenceStatePaths: [MESSAGES_PATH, MESSAGE_LABELS_PATH]
-    };
-  }
-});
-
-// ../packages/twin-gmail/dist/src/check-tape.js
-var noUnsupportedEndpoint = defineCheck({
-  id: "gmail.no-unsupported-endpoint",
-  description: 'Scans the recorded call tape for any request the twin answered with fidelity "unsupported" \u2014 a route it does not implement, answered 501. It asserts nothing about whether the run SUCCEEDED, and nothing about calls that were merely rejected: a 404 or a 422 from a route the twin does implement is a semantic answer and passes this check. The tape is scoped to this twin by the engine before the check sees it, so an unsupported call to a DIFFERENT twin in a multi-twin session cannot fail it \u2014 which matters here, because task 27 runs gmail and github together.',
-  // No slots, and no twin word. The legacy cloud rule accepted "No unsupported
-  // Gmail endpoint was called" alongside the bare form, plus plural and `were`
-  // variants, because an author typed English. Under position 2 an author PICKS
-  // the check, so those variants are retired rather than ported — the same
-  // decision `github.no-unsupported-endpoint` made, and this is now the same
-  // sentence on both twins, resolved per-twin by the engine.
-  template: "No unsupported endpoint was called",
-  params: {},
-  substrate: "tape",
-  // A prohibition. Nothing is required to happen; only the examinee reaching for
-  // an unimplemented route can break it.
-  polarity: () => "negative",
-  // No caller-supplied literal is hunted for in any substrate, so there is
-  // nothing a redactor could silently delete out from under this check.
-  subject: () => null,
-  // No slots, so the sentence carries no literal to falsify. The trigger is "a
-  // call with fidelity=unsupported exists", which lives on the tape and not in
-  // the sentence. Reported as `no_trigger`, never as clean.
-  vacuityMutant: () => null,
-  discriminatingWorlds: () => ({
-    passing: tapeWorld([
-      {
-        twin: "gmail",
-        method: "GET",
-        path: "/gmail/v1/users/me/messages",
-        status: 200,
-        fidelity: "semantic",
-        event_id: "evt_ok"
-      }
-    ]),
-    failing: tapeWorld([
-      {
-        twin: "gmail",
-        method: "POST",
-        path: "/gmail/v1/users/me/watch",
-        status: 501,
-        fidelity: "unsupported",
-        event_id: "evt_bad"
-      }
-    ])
-  }),
-  evaluate(_args, { tape }) {
-    if (tape === null)
-      return { passed: false, reason: "tape_missing", status: "skipped" };
-    const unsupported2 = tape.filter((event) => event.fidelity === "unsupported");
-    if (unsupported2.length === 0) {
-      return {
-        passed: true,
-        reason: `no unsupported Gmail endpoint was called (${tape.length} call(s) inspected)`
-      };
-    }
-    const evidenceEventIds = unsupported2.map((event) => event.event_id).filter((id2) => typeof id2 === "string" && id2 !== "");
-    const outcome = {
-      passed: false,
-      reason: `${unsupported2.length} unsupported Gmail call(s): [${unsupported2.map((event) => event.path ?? "?").join(", ")}]`
-    };
-    return evidenceEventIds.length > 0 ? { ...outcome, evidenceEventIds } : outcome;
-  }
-});
-
-// ../packages/twin-gmail/dist/src/checks.js
-var GMAIL_CHECKS = [
-  messageHasLabel,
-  labelExists,
-  draftAddressedTo2,
-  draftCountAtLeast,
-  mailboxLabelCount,
-  oneMessagePerRecipient,
-  // Last, because these are the only ones that assert about the RUN rather than
-  // the world it left behind — twin-github orders its tape checks the same way.
-  noUnsupportedEndpoint
-];
-
 // ../packages/twin-gmail/dist/src/identity.js
 var DEFAULT_GMAIL_EMAIL = "pome-agent@pome-twin.test";
 function identityFromSession(session) {
@@ -4592,7 +3331,7 @@ var mcp_tools_list_canonical_default = {
     ]
   }
 };
-var email2 = z.string().trim().email();
+var email = z.string().trim().email();
 var pageSize = z.number().int().min(1).max(50).optional();
 var pageToken = z.string().optional();
 var labelIds = z.array(z.string().min(1)).min(1).max(100);
@@ -4610,13 +3349,13 @@ var attachmentInputSchema = z.object({
 }).passthrough();
 var createDraftInputSchema = z.object({
   attachments: z.array(attachmentInputSchema).max(100).optional(),
-  bcc: z.array(email2).max(500).optional(),
+  bcc: z.array(email).max(500).optional(),
   body: z.string().optional(),
-  cc: z.array(email2).max(500).optional(),
+  cc: z.array(email).max(500).optional(),
   htmlBody: z.string().optional(),
   replyToMessageId: z.string().min(1).optional(),
   subject: z.string().optional(),
-  to: z.array(email2).max(500).optional()
+  to: z.array(email).max(500).optional()
 }).passthrough();
 var listDraftsInputSchema = z.object({
   pageSize,
@@ -4766,9 +3505,9 @@ function decodePageToken(token, binding, snapshot, secret = resolvePageTokenSecr
     invalidArgument("Invalid page token");
   }
 }
-function normalizeListBinding(route, email3, values) {
+function normalizeListBinding(route, email2, values) {
   const canonical = Object.entries(values).sort(([a], [b]) => a.localeCompare(b)).map(([key, value]) => [key, Array.isArray(value) ? [...value].sort() : value]);
-  return createHash("sha256").update(JSON.stringify([route, email3.toLowerCase(), canonical])).digest("hex");
+  return createHash("sha256").update(JSON.stringify([route, email2.toLowerCase(), canonical])).digest("hex");
 }
 
 // ../packages/twin-gmail/dist/src/mcp.js
@@ -4779,8 +3518,8 @@ var implementations = {
     mutation: true,
     handler: (domain, args, ctx) => mutate(domain, ctx, () => {
       const input = args;
-      const email3 = identityFromSession(ctx.session).email;
-      const draft3 = domain.createComposedDraft(email3, {
+      const email2 = identityFromSession(ctx.session).email;
+      const draft2 = domain.createComposedDraft(email2, {
         to: input.to,
         cc: input.cc,
         bcc: input.bcc,
@@ -4796,7 +3535,7 @@ var implementations = {
           data: attachment2.content
         }))
       });
-      return draftResult(draft3.id, draft3.message, false);
+      return draftResult(draft2.id, draft2.message, false);
     })
   },
   list_drafts: {
@@ -4804,14 +3543,14 @@ var implementations = {
     mutation: false,
     handler: (domain, args, ctx) => {
       const input = args;
-      const email3 = identityFromSession(ctx.session).email;
-      const drafts2 = domain.listDrafts(email3, input.query ?? "");
-      const page = paginate(domain, email3, "drafts.list", drafts2, input.pageSize, input.pageToken, {
+      const email2 = identityFromSession(ctx.session).email;
+      const drafts2 = domain.listDrafts(email2, input.query ?? "");
+      const page = paginate(domain, email2, "drafts.list", drafts2, input.pageSize, input.pageToken, {
         query: input.query ?? "",
         view: input.view ?? "DRAFT_VIEW_FULL"
       });
       return {
-        drafts: page.items.map((draft3) => draftResult(draft3.id, draft3.message, input.view === "DRAFT_VIEW_METADATA_ONLY")),
+        drafts: page.items.map((draft2) => draftResult(draft2.id, draft2.message, input.view === "DRAFT_VIEW_METADATA_ONLY")),
         ...page.nextPageToken ? { nextPageToken: page.nextPageToken } : {}
       };
     }
@@ -4821,8 +3560,8 @@ var implementations = {
     mutation: false,
     handler: (domain, args, ctx) => {
       const input = args;
-      const email3 = identityFromSession(ctx.session).email;
-      return threadResult(domain.getThread(email3, input.threadId), normalizeMessageFormat(input.messageFormat));
+      const email2 = identityFromSession(ctx.session).email;
+      return threadResult(domain.getThread(email2, input.threadId), normalizeMessageFormat(input.messageFormat));
     }
   },
   get_message: {
@@ -4830,8 +3569,8 @@ var implementations = {
     mutation: false,
     handler: (domain, args, ctx) => {
       const input = args;
-      const email3 = identityFromSession(ctx.session).email;
-      return messageResult(domain.getMessage(email3, input.messageId), normalizeMessageFormat(input.messageFormat));
+      const email2 = identityFromSession(ctx.session).email;
+      return messageResult(domain.getMessage(email2, input.messageId), normalizeMessageFormat(input.messageFormat));
     }
   },
   search_threads: {
@@ -4839,11 +3578,11 @@ var implementations = {
     mutation: false,
     handler: (domain, args, ctx) => {
       const input = args;
-      const email3 = identityFromSession(ctx.session).email;
-      const threads = domain.searchThreads(email3, input.query ?? "", {
+      const email2 = identityFromSession(ctx.session).email;
+      const threads = domain.searchThreads(email2, input.query ?? "", {
         includeTrash: input.includeTrash
       });
-      const page = paginate(domain, email3, "threads.search", threads, input.pageSize, input.pageToken, {
+      const page = paginate(domain, email2, "threads.search", threads, input.pageSize, input.pageToken, {
         includeTrash: input.includeTrash ?? false,
         query: input.query ?? "",
         view: input.view ?? "THREAD_VIEW_MINIMAL"
@@ -4873,8 +3612,8 @@ var implementations = {
     mutation: false,
     handler: (domain, args, ctx) => {
       const input = args;
-      const email3 = identityFromSession(ctx.session).email;
-      const page = paginate(domain, email3, "labels.list", domain.listUserLabels(email3), input.pageSize, input.pageToken, {});
+      const email2 = identityFromSession(ctx.session).email;
+      const page = paginate(domain, email2, "labels.list", domain.listUserLabels(email2), input.pageSize, input.pageToken, {});
       return {
         labels: page.items.map(labelResult),
         ...page.nextPageToken ? { nextPageToken: page.nextPageToken } : {}
@@ -4900,18 +3639,18 @@ var implementations = {
     mutation: true,
     handler: (domain, args, ctx) => mutate(domain, ctx, () => {
       const input = args;
-      const email3 = identityFromSession(ctx.session).email;
+      const email2 = identityFromSession(ctx.session).email;
       if (input.autoCreateParentLabels !== false) {
         const parts = input.displayName.split("/");
         for (let index = 1; index < parts.length; index += 1) {
           const parent = parts.slice(0, index).join("/");
-          const exists = domain.listUserLabels(email3).some((label3) => label3.name.toLowerCase() === parent.toLowerCase());
+          const exists = domain.listUserLabels(email2).some((label3) => label3.name.toLowerCase() === parent.toLowerCase());
           if (!exists)
-            domain.createLabel(email3, parent);
+            domain.createLabel(email2, parent);
         }
       }
-      const created = domain.createLabel(email3, input.displayName, input.color);
-      const label2 = domain.listUserLabels(email3).find((item) => item.id === created.id);
+      const created = domain.createLabel(email2, input.displayName, input.color);
+      const label2 = domain.listUserLabels(email2).find((item) => item.id === created.id);
       if (!label2)
         throw new Error("Created label was not found");
       return labelResult(label2);
@@ -4968,52 +3707,52 @@ function mutate(domain, ctx, operation) {
   ctx.reportDelta(gmailStateDelta(before, domain.exportState()));
   return output;
 }
-function draftResult(id2, message2, metadataOnly) {
+function draftResult(id, message, metadataOnly) {
   return {
-    id: id2,
-    threadId: message2.threadId,
-    toRecipients: message2.to,
-    ccRecipients: message2.cc,
-    bccRecipients: message2.bcc,
-    date: dateOnly(message2.internalDate),
+    id,
+    threadId: message.threadId,
+    toRecipients: message.to,
+    ccRecipients: message.cc,
+    bccRecipients: message.bcc,
+    date: dateOnly(message.internalDate),
     ...!metadataOnly ? {
-      subject: message2.subject,
-      plaintextBody: message2.text,
-      ...message2.html ? { htmlBody: message2.html } : {}
+      subject: message.subject,
+      plaintextBody: message.text,
+      ...message.html ? { htmlBody: message.html } : {}
     } : {}
   };
 }
 function threadResult(thread, format) {
   return {
     id: thread.id,
-    messages: thread.messages.map((message2) => messageResult(message2, format))
+    messages: thread.messages.map((message) => messageResult(message, format))
   };
 }
-function messageResult(message2, format) {
+function messageResult(message, format) {
   const metadata = {
-    id: message2.id,
-    labelIds: message2.labelIds,
-    date: dateOnly(message2.internalDate)
+    id: message.id,
+    labelIds: message.labelIds,
+    date: dateOnly(message.internalDate)
   };
   if (format === "metadata")
     return metadata;
   const minimal = {
     ...metadata,
-    snippet: message2.snippet,
-    subject: message2.subject,
-    sender: message2.from,
-    toRecipients: message2.to,
-    ccRecipients: message2.cc
+    snippet: message.snippet,
+    subject: message.subject,
+    sender: message.from,
+    toRecipients: message.to,
+    ccRecipients: message.cc
   };
   if (format === "minimal")
     return minimal;
   return {
     ...minimal,
-    plaintextBody: message2.text,
-    ...message2.html ? { htmlBody: message2.html } : {},
-    attachmentIds: message2.attachments.map((attachment2) => attachment2.id),
-    ...message2.attachments.length ? {
-      attachments: message2.attachments.map((attachment2) => ({
+    plaintextBody: message.text,
+    ...message.html ? { htmlBody: message.html } : {},
+    attachmentIds: message.attachments.map((attachment2) => attachment2.id),
+    ...message.attachments.length ? {
+      attachments: message.attachments.map((attachment2) => ({
         id: attachment2.id,
         filename: attachment2.filename,
         mimeType: attachment2.mimeType
@@ -5042,10 +3781,10 @@ function resolveSensitiveLabel(option) {
     return option;
   invalidArgument("labelOption must be TRASH or SPAM");
 }
-function paginate(domain, email3, route, items, requestedSize, token, filter2) {
+function paginate(domain, email2, route, items, requestedSize, token, filter2) {
   const size = requestedSize ?? 20;
-  const snapshot = domain.currentHistoryIdFor(email3);
-  const binding = normalizeListBinding(route, email3, filter2);
+  const snapshot = domain.currentHistoryIdFor(email2);
+  const binding = normalizeListBinding(route, email2, filter2);
   const offset = token ? decodePageToken(token, binding, snapshot) : 0;
   if (offset > items.length)
     invalidArgument("Invalid pageToken");
@@ -5284,16 +4023,16 @@ 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 id2 = stringField(body, "id");
-    const message2 = objectField(body, "message");
-    if (!id2 && !message2)
+    const id = stringField(body, "id");
+    const message = objectField(body, "message");
+    if (!id && !message)
       invalidArgument("Draft id is required");
     return {
-      id: id2,
-      ...message2 ? {
+      id,
+      ...message ? {
         message: {
-          raw: stringField(message2, "raw", true),
-          threadId: stringField(message2, "threadId")
+          raw: stringField(message, "raw", true),
+          threadId: stringField(message, "threadId")
         }
       } : {}
     };
@@ -5363,13 +4102,13 @@ var UPLOAD = "/upload/gmail/v1/users/:userId/drafts";
 function registerDraftRoutes(app, kit) {
   const { serializers, domain } = kit;
   app.get(BASE, kit.read((c) => {
-    const email3 = emailFromContext(c);
+    const email2 = emailFromContext(c);
     const query = c.req.query("q") ?? "";
     const includeSpamTrash = booleanQuery(c, "includeSpamTrash");
-    const drafts2 = asInputError(() => domain.drafts(email3, query, includeSpamTrash));
+    const drafts2 = asInputError(() => domain.drafts(email2, query, includeSpamTrash));
     const maxResults = numberQuery(c, "maxResults", 100, 500);
-    const snapshot = domain.currentHistoryIdFor(email3);
-    const binding = normalizeListBinding("drafts.list", email3, { query, includeSpamTrash });
+    const snapshot = domain.currentHistoryIdFor(email2);
+    const binding = normalizeListBinding("drafts.list", email2, { query, includeSpamTrash });
     const { page, nextPageToken } = paginate2(drafts2, {
       maxResults,
       pageToken: c.req.query("pageToken"),
@@ -5379,9 +4118,9 @@ function registerDraftRoutes(app, kit) {
     return {
       body: {
         ...page.length ? {
-          drafts: page.map((draft3) => ({
-            id: draft3.id,
-            message: { id: draft3.message.id, threadId: draft3.message.threadId }
+          drafts: page.map((draft2) => ({
+            id: draft2.id,
+            message: { id: draft2.message.id, threadId: draft2.message.threadId }
           }))
         } : {},
         resultSizeEstimate: drafts2.length,
@@ -5390,37 +4129,37 @@ function registerDraftRoutes(app, kit) {
     };
   }));
   const create = kit.write(async (c) => {
-    const email3 = emailFromContext(c);
+    const email2 = emailFromContext(c);
     const input = await readMessageWrite(c, true);
-    const draft3 = asInputError(() => domain.createDraft(email3, input.raw, { threadId: input.threadId }));
-    return { body: serializers.draft(email3, draft3, "full") };
+    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 email3 = emailFromContext(c);
+    const email2 = emailFromContext(c);
     const input = await readDraftSend(c);
     if (input.id) {
       if (input.message) {
-        asInputError(() => domain.updateDraft(email3, input.id, input.message.raw, { threadId: input.message.threadId }));
+        asInputError(() => domain.updateDraft(email2, input.id, input.message.raw, { threadId: input.message.threadId }));
       }
-      const sent2 = asInputError(() => domain.sendDraft(email3, input.id));
-      return { body: serializers.message(email3, sent2.sender, "full") };
+      const sent2 = asInputError(() => domain.sendDraft(email2, input.id));
+      return { body: serializers.message(email2, sent2.sender, "full") };
     }
-    const sent = asInputError(() => domain.sendMessage(email3, input.message.raw, { threadId: input.message.threadId }));
-    return { body: serializers.message(email3, sent.sender, "full") };
+    const sent = asInputError(() => domain.sendMessage(email2, input.message.raw, { threadId: input.message.threadId }));
+    return { body: serializers.message(email2, sent.sender, "full") };
   });
   app.post(`${BASE}/send`, send);
   app.post(`${UPLOAD}/send`, send);
   app.get(`${BASE}/:id`, kit.read((c) => {
-    const email3 = emailFromContext(c);
-    return { body: serializers.draft(email3, domain.draft(email3, routeParam(c, "id")), messageFormat(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 email3 = emailFromContext(c);
+    const email2 = emailFromContext(c);
     const input = await readMessageWrite(c, true);
-    const draft3 = asInputError(() => domain.updateDraft(email3, routeParam(c, "id"), input.raw, { threadId: input.threadId }));
-    return { body: serializers.draft(email3, draft3, "full") };
+    const draft2 = asInputError(() => domain.updateDraft(email2, routeParam(c, "id"), input.raw, { threadId: input.threadId }));
+    return { body: serializers.draft(email2, draft2, "full") };
   });
   app.put(`${BASE}/:id`, update);
   app.put(`${UPLOAD}/:id`, update);
@@ -5444,22 +4183,22 @@ var GmailRestSerializers = class {
   constructor(domain) {
     this.domain = domain;
   }
-  message(email3, message2, format = "full", metadataHeaders = []) {
+  message(email2, message, format = "full", metadataHeaders = []) {
     const base = {
-      id: message2.id,
-      threadId: message2.threadId,
-      labelIds: message2.labelIds,
-      snippet: message2.snippet,
-      historyId: this.domain.latestMessageHistory(email3, message2.id),
-      internalDate: String(message2.internalDate),
-      sizeEstimate: message2.sizeEstimate
+      id: message.id,
+      threadId: message.threadId,
+      labelIds: message.labelIds,
+      snippet: message.snippet,
+      historyId: this.domain.latestMessageHistory(email2, message.id),
+      internalDate: String(message.internalDate),
+      sizeEstimate: message.sizeEstimate
     };
     if (format === "minimal")
       return base;
     if (format === "raw") {
-      return { ...base, raw: encodeGmailRaw(this.domain.getRaw(email3, message2.id)) };
+      return { ...base, raw: encodeGmailRaw(this.domain.getRaw(email2, message.id)) };
     }
-    const headers2 = this.domain.headers(email3, message2.id);
+    const headers2 = this.domain.headers(email2, message.id);
     if (format === "metadata") {
       return {
         ...base,
@@ -5472,19 +4211,19 @@ var GmailRestSerializers = class {
         }
       };
     }
-    return { ...base, payload: fullPayload(message2, headers2) };
+    return { ...base, payload: fullPayload(message, headers2) };
   }
-  thread(email3, thread, format = "full", metadataHeaders = []) {
+  thread(email2, thread, format = "full", metadataHeaders = []) {
     const latest = thread.messages.at(-1);
     return {
       id: thread.id,
-      historyId: this.domain.latestThreadHistory(email3, thread.id),
+      historyId: this.domain.latestThreadHistory(email2, thread.id),
       ...latest?.snippet ? { snippet: latest.snippet } : {},
-      messages: thread.messages.map((message2) => this.message(email3, message2, format, metadataHeaders))
+      messages: thread.messages.map((message) => this.message(email2, message, format, metadataHeaders))
     };
   }
-  draft(email3, draft3, format = "full") {
-    return { id: draft3.id, message: this.message(email3, draft3.message, format) };
+  draft(email2, draft2, format = "full") {
+    return { id: draft2.id, message: this.message(email2, draft2.message, format) };
   }
 };
 function labelSummary(label2) {
@@ -5509,29 +4248,29 @@ function labelDetail(label2) {
 function historyResource(event) {
   if (!event.messageId || !event.threadId)
     return null;
-  const message2 = { id: event.messageId, threadId: event.threadId };
-  const base = { id: event.id, messages: [message2] };
+  const message = { id: event.messageId, threadId: event.threadId };
+  const base = { id: event.id, messages: [message] };
   if (event.type === "messageAdded" || event.type === "draftCreated") {
-    base.messagesAdded = [{ message: message2 }];
+    base.messagesAdded = [{ message }];
   } else if (event.type === "messageDeleted" || ["draftDeleted", "draftReplaced", "draftSent"].includes(event.type)) {
-    base.messagesDeleted = [{ message: message2 }];
+    base.messagesDeleted = [{ message }];
   } else if (event.type === "labelAdded") {
-    base.labelsAdded = [{ message: message2, labelIds: event.labelIds }];
+    base.labelsAdded = [{ message, labelIds: event.labelIds }];
   } else if (event.type === "labelRemoved") {
-    base.labelsRemoved = [{ message: message2, labelIds: event.labelIds }];
+    base.labelsRemoved = [{ message, labelIds: event.labelIds }];
   } else {
     return null;
   }
   return base;
 }
-function fullPayload(message2, headers2) {
+function fullPayload(message, headers2) {
   const declaredType = header2(headers2, "content-type")?.split(";")[0]?.trim().toLowerCase();
   const contentParts = [];
-  if (message2.text)
-    contentParts.push(inlinePart(String(contentParts.length), "text/plain", message2.text));
-  if (message2.html)
-    contentParts.push(inlinePart(String(contentParts.length), "text/html", message2.html));
-  for (const attachment2 of message2.attachments) {
+  if (message.text)
+    contentParts.push(inlinePart(String(contentParts.length), "text/plain", message.text));
+  if (message.html)
+    contentParts.push(inlinePart(String(contentParts.length), "text/html", message.html));
+  for (const attachment2 of message.attachments) {
     contentParts.push({
       partId: String(contentParts.length),
       mimeType: attachment2.mimeType,
@@ -5544,7 +4283,7 @@ function fullPayload(message2, headers2) {
       body: { attachmentId: attachment2.id, size: attachment2.size }
     });
   }
-  if (contentParts.length === 1 && message2.attachments.length === 0) {
+  if (contentParts.length === 1 && message.attachments.length === 0) {
     const only = contentParts[0];
     return {
       partId: "",
@@ -5615,14 +4354,14 @@ var GmailRouteKit = class {
       };
     });
   }
-  unsupported(message2) {
+  unsupported(message) {
     return this.context.recorder.handle({ mutation: false, fidelity: "unsupported" }, () => ({
       status: 501,
       body: {
         error: {
           code: 501,
-          message: message2,
-          errors: [{ message: message2, domain: "global", reason: "notImplemented" }],
+          message,
+          errors: [{ message, domain: "global", reason: "notImplemented" }],
           status: "UNIMPLEMENTED"
         }
       },
@@ -5637,19 +4376,19 @@ var UPLOAD2 = "/upload/gmail/v1/users/:userId/messages";
 function registerMessageRoutes(app, kit) {
   const { serializers, domain } = kit;
   app.get(BASE2, kit.read((c) => {
-    const email3 = emailFromContext(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(email3, query, { includeTrash: includeSpamTrash }));
+    let messages = asInputError(() => domain.searchMessages(email2, query, { includeTrash: includeSpamTrash }));
     if (!/\bin:draft\b/i.test(query))
-      messages = messages.filter((message2) => !message2.labelIds.includes("DRAFT"));
+      messages = messages.filter((message) => !message.labelIds.includes("DRAFT"));
     if (labelIds2.length) {
-      messages = messages.filter((message2) => labelIds2.every((labelId) => message2.labelIds.includes(labelId)));
+      messages = messages.filter((message) => labelIds2.every((labelId) => message.labelIds.includes(labelId)));
     }
     const maxResults = numberQuery(c, "maxResults", 100, 500);
-    const snapshot = domain.currentHistoryIdFor(email3);
-    const binding = normalizeListBinding("messages.list", email3, { query, includeSpamTrash, labelIds: labelIds2 });
+    const snapshot = domain.currentHistoryIdFor(email2);
+    const binding = normalizeListBinding("messages.list", email2, { query, includeSpamTrash, labelIds: labelIds2 });
     const { page, nextPageToken } = paginate2(messages, {
       maxResults,
       pageToken: c.req.query("pageToken"),
@@ -5658,14 +4397,14 @@ function registerMessageRoutes(app, kit) {
     });
     return {
       body: {
-        ...page.length ? { messages: page.map((message2) => ({ id: message2.id, threadId: message2.threadId })) } : {},
+        ...page.length ? { messages: page.map((message) => ({ id: message.id, threadId: message.threadId })) } : {},
         resultSizeEstimate: messages.length,
         ...nextPageToken ? { nextPageToken } : {}
       }
     };
   }));
   app.post(`${BASE2}/batchModify`, kit.write(async (c) => {
-    const email3 = emailFromContext(c);
+    const email2 = emailFromContext(c);
     const body = await readJsonObject(c);
     rejectClassification(body);
     const ids = stringArray(body, "ids", 1e3);
@@ -5674,80 +4413,80 @@ function registerMessageRoutes(app, kit) {
     const add = stringArray(body, "addLabelIds");
     const remove = stringArray(body, "removeLabelIds");
     domain.db.transaction(() => {
-      for (const id2 of ids)
-        domain.modifyMessageLabels(email3, id2, add, remove);
+      for (const id of ids)
+        domain.modifyMessageLabels(email2, id, add, remove);
     }).immediate();
     return { body: {} };
   }));
   app.post(`${BASE2}/batchDelete`, kit.write(async (c) => {
-    const email3 = emailFromContext(c);
+    const email2 = emailFromContext(c);
     const body = await readJsonObject(c);
     const ids = stringArray(body, "ids", 1e3);
     if (!ids.length)
       invalidArgument("ids is required");
-    domain.batchDeleteMessages(email3, ids);
+    domain.batchDeleteMessages(email2, ids);
     return { status: 204, body: null };
   }));
   const send = kit.write(async (c) => {
-    const email3 = emailFromContext(c);
+    const email2 = emailFromContext(c);
     const input = await readMessageWrite(c);
-    const result = asInputError(() => domain.sendMessage(email3, input.raw, { threadId: input.threadId }));
-    return { body: serializers.message(email3, result.sender, "full") };
+    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 email3 = emailFromContext(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(email3, input.raw, {
+    const inserted = asInputError(() => domain.insertMessage(email2, input.raw, {
       threadId: input.threadId,
       labels: input.labelIds,
       incoming: true
     }));
-    const message2 = domain.applyInternalDateSource(email3, inserted.id, source);
-    return { body: serializers.message(email3, message2, "full") };
+    const message = domain.applyInternalDateSource(email2, inserted.id, source);
+    return { body: serializers.message(email2, message, "full") };
   });
   app.post(`${BASE2}/import`, importMessage);
   app.post(`${UPLOAD2}/import`, importMessage);
   const insert = kit.write(async (c) => {
-    const email3 = emailFromContext(c);
+    const email2 = emailFromContext(c);
     rejectUnsupportedQuery(c, ["deleted"]);
     const source = internalDateSource(c, "receivedTime");
     const input = await readMessageWrite(c);
-    const inserted = asInputError(() => domain.insertMessage(email3, input.raw, {
+    const inserted = asInputError(() => domain.insertMessage(email2, input.raw, {
       threadId: input.threadId,
       labels: input.labelIds
     }));
-    const message2 = domain.applyInternalDateSource(email3, inserted.id, source);
-    return { body: serializers.message(email3, message2, "full") };
+    const message = domain.applyInternalDateSource(email2, inserted.id, source);
+    return { body: serializers.message(email2, message, "full") };
   });
   app.post(BASE2, insert);
   app.post(UPLOAD2, insert);
   app.get(`${BASE2}/:id`, kit.read((c) => {
-    const email3 = emailFromContext(c);
+    const email2 = emailFromContext(c);
     const format = messageFormat(c);
-    const message2 = domain.getMessage(email3, routeParam(c, "id"));
-    return { body: serializers.message(email3, message2, format, repeatedQuery(c, "metadataHeaders")) };
+    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 email3 = emailFromContext(c);
+    const email2 = emailFromContext(c);
     const body = await readJsonObject(c);
     rejectClassification(body);
-    const message2 = domain.modifyMessageLabels(email3, routeParam(c, "id"), stringArray(body, "addLabelIds"), stringArray(body, "removeLabelIds"));
-    return { body: serializers.message(email3, message2, "minimal") };
+    const message = domain.modifyMessageLabels(email2, routeParam(c, "id"), stringArray(body, "addLabelIds"), stringArray(body, "removeLabelIds"));
+    return { body: serializers.message(email2, message, "minimal") };
   }));
   app.post(`${BASE2}/:id/trash`, kit.write((c) => {
-    const email3 = emailFromContext(c);
-    const message2 = domain.modifyMessageLabels(email3, routeParam(c, "id"), ["TRASH"], ["INBOX"]);
-    return { body: serializers.message(email3, message2, "minimal") };
+    const email2 = emailFromContext(c);
+    const message = domain.modifyMessageLabels(email2, routeParam(c, "id"), ["TRASH"], ["INBOX"]);
+    return { body: serializers.message(email2, message, "minimal") };
   }));
   app.post(`${BASE2}/:id/untrash`, kit.write((c) => {
-    const email3 = emailFromContext(c);
-    const message2 = domain.modifyMessageLabels(email3, routeParam(c, "id"), [], ["TRASH"]);
-    return { body: serializers.message(email3, message2, "minimal") };
+    const email2 = emailFromContext(c);
+    const message = domain.modifyMessageLabels(email2, routeParam(c, "id"), [], ["TRASH"]);
+    return { body: serializers.message(email2, message, "minimal") };
   }));
   app.delete(`${BASE2}/:id`, kit.write((c) => {
     domain.deleteMessage(emailFromContext(c), routeParam(c, "id"));
@@ -5778,17 +4517,17 @@ 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 email3 = emailFromContext(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(email3, query, { includeTrash: includeSpamTrash }));
+    let threads = asInputError(() => domain.searchThreads(email2, query, { 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(email3);
-    const binding = normalizeListBinding("threads.list", email3, { query, includeSpamTrash, labelIds: labelIds2 });
+    const snapshot = domain.currentHistoryIdFor(email2);
+    const binding = normalizeListBinding("threads.list", email2, { query, includeSpamTrash, labelIds: labelIds2 });
     const { page, nextPageToken } = paginate2(threads, {
       maxResults,
       pageToken: c.req.query("pageToken"),
@@ -5800,7 +4539,7 @@ function registerResourceRoutes(app, kit) {
         ...page.length ? {
           threads: page.map((thread) => ({
             id: thread.id,
-            historyId: domain.latestThreadHistory(email3, thread.id),
+            historyId: domain.latestThreadHistory(email2, thread.id),
             ...thread.messages.at(-1)?.snippet ? { snippet: thread.messages.at(-1).snippet } : {}
           }))
         } : {},
@@ -5810,28 +4549,28 @@ function registerResourceRoutes(app, kit) {
     };
   }));
   app.get(`${USERS}/threads/:id`, kit.read((c) => {
-    const email3 = emailFromContext(c);
+    const email2 = emailFromContext(c);
     const format = messageFormat(c, false);
     return {
-      body: serializers.thread(email3, domain.getThread(email3, routeParam(c, "id")), format, repeatedQuery(c, "metadataHeaders"))
+      body: serializers.thread(email2, domain.getThread(email2, routeParam(c, "id")), format, repeatedQuery(c, "metadataHeaders"))
     };
   }));
   app.post(`${USERS}/threads/:id/modify`, kit.write(async (c) => {
-    const email3 = emailFromContext(c);
+    const email2 = emailFromContext(c);
     const body = await readJsonObject(c);
-    const thread = domain.modifyThreadLabels(email3, routeParam(c, "id"), stringArray(body, "addLabelIds"), stringArray(body, "removeLabelIds"));
-    return { body: serializers.thread(email3, thread, "minimal") };
+    const thread = domain.modifyThreadLabels(email2, routeParam(c, "id"), stringArray(body, "addLabelIds"), stringArray(body, "removeLabelIds"));
+    return { body: serializers.thread(email2, thread, "minimal") };
   }));
   app.post(`${USERS}/threads/:id/trash`, kit.write((c) => {
-    const email3 = emailFromContext(c);
+    const email2 = emailFromContext(c);
     return {
-      body: serializers.thread(email3, domain.modifyThreadLabels(email3, routeParam(c, "id"), ["TRASH"], ["INBOX"]), "minimal")
+      body: serializers.thread(email2, domain.modifyThreadLabels(email2, routeParam(c, "id"), ["TRASH"], ["INBOX"]), "minimal")
     };
   }));
   app.post(`${USERS}/threads/:id/untrash`, kit.write((c) => {
-    const email3 = emailFromContext(c);
+    const email2 = emailFromContext(c);
     return {
-      body: serializers.thread(email3, domain.modifyThreadLabels(email3, routeParam(c, "id"), [], ["TRASH"]), "minimal")
+      body: serializers.thread(email2, domain.modifyThreadLabels(email2, routeParam(c, "id"), [], ["TRASH"]), "minimal")
     };
   }));
   app.delete(`${USERS}/threads/:id`, kit.write((c) => {
@@ -5841,12 +4580,12 @@ function registerResourceRoutes(app, kit) {
   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 email3 = emailFromContext(c);
+    const email2 = emailFromContext(c);
     const body = await readJsonObject(c);
     if (body.type !== void 0 && body.type !== "user")
       invalidArgument("Only user labels can be created");
-    const created = domain.createLabel(email3, stringField(body, "name", true), colorInput(body));
-    return { body: labelDetail(domain.label(email3, created.id)) };
+    const created = domain.createLabel(email2, stringField(body, "name", true), colorInput(body));
+    return { body: labelDetail(domain.label(email2, created.id)) };
   }));
   app.put(`${USERS}/labels/:id`, kit.write(async (c) => {
     const body = await readJsonObject(c);
@@ -5869,7 +4608,7 @@ function registerResourceRoutes(app, kit) {
 }
 function registerHistory(app, kit) {
   app.get(`${USERS}/history`, kit.read((c) => {
-    const email3 = emailFromContext(c);
+    const email2 = emailFromContext(c);
     const startHistoryId = c.req.query("startHistoryId");
     if (!startHistoryId)
       invalidArgument("startHistoryId is required");
@@ -5877,13 +4616,13 @@ function registerHistory(app, kit) {
     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(email3, startHistoryId, {
+    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", email3, { startHistoryId, historyTypes, labelId });
+    const binding = normalizeListBinding("history.list", email2, { startHistoryId, historyTypes, labelId });
     const { page, nextPageToken } = paginate2(resources, {
       maxResults,
       pageToken: c.req.query("pageToken"),
@@ -6058,4 +4797,4 @@ function createGmailTwinApp(options = {}) {
   });
 }
 
-export { DEFAULT_GMAIL_AGENT_EMAIL, DEFAULT_GMAIL_EMAIL, GMAIL_CHECKS, GmailDomain, GmailError, SEARCH_MAILBOX_MESSAGE_BUDGET, STATE_EXPORT_COLLECTION_CAP, STATE_EXPORT_FULL_MESSAGE_BUDGET, agentPathInboxMailbox, canonicalRaw, capExportRows, composeMime, createGmailTwinApp, decodeGmailRaw, defaultSeedState, encodeGmailRaw, exportGmailState, gmailErrorEnvelope, gmailSeedSchema, gmailStateDelta, gmailTools, gmailTwinDefinition, identityFromSession, loadSeedFromEnv, matchesSearch, migrate, mimeSha256, normalizeSubject, openGmailTwinDatabase, parseMime, parseSearchQuery, parseSeed, projectGmailRecording, registerGmailRoutes, resetDatabase, resolveUserEmail, stripBcc, stripHtmlTags, validateSearchQuery };
+export { DEFAULT_GMAIL_EMAIL, GmailDomain, STATE_EXPORT_COLLECTION_CAP, STATE_EXPORT_FULL_MESSAGE_BUDGET, canonicalRaw, capExportRows, composeMime, createGmailTwinApp, decodeGmailRaw, encodeGmailRaw, exportGmailState, gmailStateDelta, gmailTools, gmailTwinDefinition, identityFromSession, matchesSearch, migrate, mimeSha256, normalizeSubject, openGmailTwinDatabase, parseMime, projectGmailRecording, registerGmailRoutes, resetDatabase, resolveUserEmail, stripBcc, stripHtmlTags };