@marlinjai/mail-contract 0.10.0 → 0.11.0

package/dist/index.mjs

@@ -77,6 +77,12 @@ var ERROR_STATUS = {
   invalid_mjml: 422,
   missing_unsubscribe_url: 422,
   mailing_not_ready: 422,
+  /**
+   * A value placed inside a link's address comes out empty for at least one
+   * recipient, so the mailing does not start; `details.values` lists each such
+   * value with how many recipients it is empty for.
+   */
+  unfilled_link: 422,
   unknown_topic: 422,
   unknown_provider: 422,
   /**
@@ -145,10 +151,10 @@ var API_VERSION_PREFIX = "/v1";
 var HEALTH_PATH = "/healthz";
 
 // src/workspace.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 
 // src/automations.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 
 // src/templates.ts
 import { z as z5 } from "zod";
@@ -169,11 +175,11 @@ var RESERVED_MERGE_FIELDS = {
 };
 var MERGE_FIELD_PATTERN = /\{\{\s*([a-z][a-z0-9_]*)\s*(?:\|([^}]*))?\}\}/g;
 function findMergeFields(html) {
-  const uses = [];
+  const uses2 = [];
   for (const match of html.matchAll(MERGE_FIELD_PATTERN)) {
-    uses.push({ name: match[1], fallback: match[2] === void 0 ? null : match[2].trim() });
+    uses2.push({ name: match[1], fallback: match[2] === void 0 ? null : match[2].trim() });
   }
-  return uses;
+  return uses2;
 }
 function missingRequiredMergeFields(html) {
   const used = new Set(findMergeFields(html).map((u) => u.name));
@@ -856,10 +862,10 @@ function exportFilename(name, format) {
 }
 
 // src/platform.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // src/mailings.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 
 // src/ab-test.ts
 import { z as z6 } from "zod";
@@ -910,6 +916,167 @@ function testGroupSize(total, fraction, variants) {
   return Math.min(total, Math.max(variants, Math.ceil(total * fraction)));
 }
 
+// src/values.ts
+import { z as z7 } from "zod";
+var MAX_MERGE_DEFAULTS = 50;
+var MAX_MERGE_DEFAULT_LENGTH = 2e3;
+var MergeFieldName = z7.string().regex(/^[a-z][a-z0-9_]*$/, "a merge-field name: lowercase letters, digits and underscores, starting with a letter").max(64);
+var MergeDefaultValue = z7.union([z7.string().max(MAX_MERGE_DEFAULT_LENGTH), z7.number().finite(), z7.boolean()]);
+var MailingMerge = z7.record(MergeFieldName, MergeDefaultValue).refine((m) => Object.keys(m).length <= MAX_MERGE_DEFAULTS, `at most ${MAX_MERGE_DEFAULTS} values on a mailing`).refine((m) => !Object.keys(m).some((k) => SERVICE_FILLED_MERGE_FIELDS.includes(k)), {
+  message: `the service fills ${SERVICE_FILLED_MERGE_FIELDS.join(" and ")}; a mailing cannot set them`
+});
+var LETTER_ONLY_MERGE_FIELDS = ["first_name", "last_name"];
+var NAME_ON_BROADCAST_REFUSAL = "name_on_broadcast";
+function letterOnlyValues(merge) {
+  return LETTER_ONLY_MERGE_FIELDS.filter((name) => ownEntry(merge, name) !== void 0);
+}
+var VALUE_LAYERS = ["recipient", "mailing", "contact", "workspace", "fallback", "empty"];
+var ValueLayer = z7.enum(VALUE_LAYERS);
+var ResolvedValue = z7.object({ text: z7.string(), layer: ValueLayer });
+var MessageValues = z7.record(ResolvedValue);
+function scalarText(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" && Number.isFinite(value)) return String(value);
+  if (typeof value === "boolean") return String(value);
+  return null;
+}
+function isNameField(name) {
+  return name === "first_name" || name === "last_name";
+}
+function rawMergeValue(name, sources) {
+  const own = ownEntry(sources.recipient, name);
+  if (scalarText(own) !== null) return { value: own, layer: "recipient" };
+  const held = ownEntry(sources.mailing, name);
+  if (scalarText(held) !== null) return { value: held, layer: "mailing" };
+  if (isNameField(name)) {
+    const stored = sources.contact?.[name];
+    return typeof stored === "string" ? { value: stored, layer: "contact" } : null;
+  }
+  const property = ownEntry(sources.contact?.properties, name);
+  if (scalarText(property) !== null) return { value: property, layer: "contact" };
+  const byDefault = ownEntry(sources.workspace, name);
+  return scalarText(byDefault) !== null ? { value: byDefault, layer: "workspace" } : null;
+}
+function resolveValue(name, fallback, sources) {
+  const found = rawMergeValue(name, sources);
+  const text = found === null ? null : scalarText(found.value);
+  if (found !== null && text !== null && text.trim() !== "") return { text, layer: found.layer };
+  const instead = fallback?.trim() ?? "";
+  return instead === "" ? { text: "", layer: "empty" } : { text: instead, layer: "fallback" };
+}
+function pattern2() {
+  return new RegExp(MERGE_FIELD_PATTERN.source, "g");
+}
+function isServiceFilled(name) {
+  return SERVICE_FILLED_MERGE_FIELDS.includes(name);
+}
+function uses(text) {
+  return [...text.matchAll(pattern2())].map((m) => ({ name: m[1], fallback: m[2] === void 0 ? null : m[2].trim() }));
+}
+function valueNames(texts, insertions) {
+  const names = [];
+  const add = (name) => {
+    if (!isServiceFilled(name) && !names.includes(name)) names.push(name);
+  };
+  for (const text of texts) {
+    for (const use of uses(text ?? "")) {
+      const def = ownEntry(insertions, use.name);
+      if (!def) {
+        add(use.name);
+        continue;
+      }
+      add(def.by);
+      for (const inner of [...Object.values(def.choices), def.filled ?? "", def.otherwise]) for (const u of uses(inner)) add(u.name);
+    }
+  }
+  return names;
+}
+function printedFields(texts, insertions, chosen2) {
+  const out = [];
+  const add = (use) => {
+    if (isServiceFilled(use.name)) return;
+    if (!out.some((o) => o.name === use.name && o.fallback === use.fallback)) out.push(use);
+  };
+  for (const text of texts) {
+    for (const use of uses(text ?? "")) {
+      if (!ownEntry(insertions, use.name)) add(use);
+      else for (const inner of uses(ownEntry(chosen2, use.name)?.text ?? "")) add(inner);
+    }
+  }
+  return out;
+}
+function valuesRead(texts, insertions, chosen2, resolve) {
+  const out = {};
+  const read = (use) => {
+    if (isServiceFilled(use.name)) return;
+    const value = resolve(use.name, use.fallback);
+    const seen = ownEntry(out, use.name);
+    if (seen === void 0 || value.layer === "empty" && seen.layer !== "empty") out[use.name] = value;
+  };
+  for (const text of texts) {
+    for (const use of uses(text ?? "")) {
+      const def = ownEntry(insertions, use.name);
+      if (!def) {
+        read(use);
+        continue;
+      }
+      read({ name: def.by, fallback: null });
+      for (const inner of uses(ownEntry(chosen2, use.name)?.text ?? "")) read(inner);
+    }
+  }
+  return out;
+}
+var HREF = /\bhref\s*=\s*(?:"([^"]*)"|'([^']*)')/gi;
+function linkTokens(html) {
+  const out = [];
+  for (const match of html.matchAll(HREF)) {
+    for (const use of uses(match[1] ?? match[2] ?? "")) {
+      if (isServiceFilled(use.name)) continue;
+      if (!out.some((o) => o.name === use.name && o.fallback === use.fallback)) out.push(use);
+    }
+  }
+  return out;
+}
+function emptyLinkValues(tokens, p) {
+  const empty = [];
+  for (const token of tokens) {
+    const ins = ownEntry(p.insertions, token.name);
+    const text = ins ? ins.text.replace(pattern2(), (_m, name, fallback) => p.value(name, fallback)) : p.value(token.name, token.fallback ?? void 0);
+    if (text.trim() === "" && !empty.includes(token.name)) empty.push(token.name);
+  }
+  return empty;
+}
+var UnfilledLink = z7.object({
+  /** The value, or the insertion, that comes out empty. */
+  value: z7.string(),
+  /** How many recipients it is empty for. */
+  recipients: z7.number().int().min(1)
+});
+var RESOLVE_PROBLEMS = ["unfilled_link", "empty_value", "insertion_miss"];
+var ResolveProblem = z7.object({
+  kind: z7.enum(RESOLVE_PROBLEMS),
+  severity: z7.enum(["blocking", "note"]),
+  value: z7.string(),
+  message: z7.string()
+});
+var ResolvedRecipient = z7.object({
+  /** The recipient's index in the request; null for the reader with nothing of their own. */
+  index: z7.number().int().min(0).nullable(),
+  /** The address the message would go to; null for the reader with nothing of their own. */
+  email: Email.nullable(),
+  /** The contact found for the recipient; null when the address has none yet (a send creates it, empty). */
+  contact_id: Id.nullable(),
+  /** The language version this recipient would get. */
+  locale: LocaleTag,
+  /** The subject line as they would read it. */
+  subject: z7.string(),
+  values: MessageValues,
+  /** The choice each insertion would make; null when the content has none. */
+  insertions: InsertionChoices.nullable(),
+  problems: z7.array(ResolveProblem)
+});
+var RESOLVE_REJECTIONS = ["unknown_contact", "duplicate_in_batch"];
+
 // src/mailings.ts
 var MAILING_STATUSES = [
   "draft",
@@ -920,9 +1087,9 @@ var MAILING_STATUSES = [
   "partially_failed",
   "cancelled"
 ];
-var MailingStatus = z7.enum(MAILING_STATUSES);
+var MailingStatus = z8.enum(MAILING_STATUSES);
 var MAILING_ACTIONS = ["send", "schedule", "unschedule", "pause", "resume", "cancel", "retry-failed"];
-var MailingAction = z7.enum(MAILING_ACTIONS);
+var MailingAction = z8.enum(MAILING_ACTIONS);
 var MAILING_TRANSITIONS = {
   draft: ["send", "schedule", "cancel"],
   scheduled: ["send", "schedule", "unschedule", "cancel"],
@@ -937,23 +1104,23 @@ function canTransition(status, action) {
 }
 var EDITABLE_MAILING_STATUSES = ["draft", "scheduled"];
 var TERMINAL_MAILING_STATUSES = ["sent", "cancelled"];
-var MailingMetadata = z7.record(z7.string().max(500)).refine((v) => Object.keys(v).length <= 20, "at most 20 keys").refine((v) => Object.keys(v).every((k) => k.length >= 1 && k.length <= 64), "keys are 1 to 64 characters");
-var MailingCounts = z7.object({
-  total: z7.number().int().min(0),
-  queued: z7.number().int().min(0),
-  sending: z7.number().int().min(0),
-  sent: z7.number().int().min(0),
-  failed: z7.number().int().min(0),
-  skipped: z7.number().int().min(0)
+var MailingMetadata = z8.record(z8.string().max(500)).refine((v) => Object.keys(v).length <= 20, "at most 20 keys").refine((v) => Object.keys(v).every((k) => k.length >= 1 && k.length <= 64), "keys are 1 to 64 characters");
+var MailingCounts = z8.object({
+  total: z8.number().int().min(0),
+  queued: z8.number().int().min(0),
+  sending: z8.number().int().min(0),
+  sent: z8.number().int().min(0),
+  failed: z8.number().int().min(0),
+  skipped: z8.number().int().min(0)
 });
 var MAILING_KINDS = ["broadcast", "automation", "notification"];
-var MailingKind = z7.enum(MAILING_KINDS);
-var Mailing = z7.object({
+var MailingKind = z8.enum(MAILING_KINDS);
+var Mailing = z8.object({
   id: Id,
   kind: MailingKind,
-  name: z7.string().max(200).nullable(),
-  subject: z7.string().min(1).max(998),
-  preheader: z7.string().max(500).nullable(),
+  name: z8.string().max(200).nullable(),
+  subject: z8.string().min(1).max(998),
+  preheader: z8.string().max(500).nullable(),
   /**
    * The template the document was taken from, if any. The snapshot is what is
    * sent in the main language; the template's other language versions are
@@ -995,6 +1162,12 @@ var Mailing = z7.object({
   status: MailingStatus,
   counts: MailingCounts,
   metadata: MailingMetadata,
+  /**
+   * The values held on this mailing (see `MailingMerge`): the same for
+   * everyone who gets it, above the contact's stored name and properties and
+   * the workspace's defaults, below the recipient's own. Empty by default.
+   */
+  merge: MailingMerge.default({}),
   scheduled_at: Timestamp.nullable(),
   /** The A/B test on subject or content (S4), null when there is none. */
   ab_test: AbTestState.nullable(),
@@ -1006,15 +1179,15 @@ var Mailing = z7.object({
    * recipients refused as dead addresses in one run (see the provider's
    * `rejections.anomaly`). Resuming clears it and starts a new run.
    */
-  pause_reason: z7.string().nullable().default(null),
+  pause_reason: z8.string().nullable().default(null),
   created_at: Timestamp,
   updated_at: Timestamp
 });
 var MailingSummary = Mailing.omit({ document: true });
 var MailingContent = {
-  name: z7.string().max(200).optional(),
-  subject: z7.string().min(1).max(998),
-  preheader: z7.string().max(500).optional(),
+  name: z8.string().max(200).optional(),
+  subject: z8.string().min(1).max(998),
+  preheader: z8.string().max(500).optional(),
   /** See `Mailing.send_locale`. */
   send_locale: LocaleTag.nullable().optional(),
   /**
@@ -1025,9 +1198,11 @@ var MailingContent = {
    */
   topic: Slug.nullable().optional(),
   provider_id: Id,
-  metadata: MailingMetadata.optional()
+  metadata: MailingMetadata.optional(),
+  /** See `Mailing.merge`. `first_name` and `last_name` only on a letter (no topic). */
+  merge: MailingMerge.optional()
 };
-var MailingCreate = z7.object({
+var MailingCreate = z8.object({
   ...MailingContent,
   subject: MailingContent.subject.optional(),
   document: TemplateDocument.optional(),
@@ -1043,15 +1218,22 @@ var MailingCreate = z7.object({
   message: "a mailing made from a document needs a subject",
   path: ["subject"]
 });
-var MailingUpdate = z7.object({
-  name: z7.string().max(200).nullable().optional(),
+var MailingUpdate = z8.object({
+  name: z8.string().max(200).nullable().optional(),
   subject: MailingContent.subject.optional(),
-  preheader: z7.string().max(500).nullable().optional(),
+  preheader: z8.string().max(500).nullable().optional(),
   /** Null turns a draft into a letter, which it can only be with at most one recipient. */
   topic: Slug.nullable().optional(),
   send_locale: LocaleTag.nullable().optional(),
   provider_id: Id.optional(),
   metadata: MailingMetadata.optional(),
+  /**
+   * Replaces the mailing's values whole (see `Mailing.merge`). Giving a
+   * mailing that holds `first_name` or `last_name` a topic is refused
+   * (`name_on_broadcast`) unless the same call replaces its values without
+   * them.
+   */
+  merge: MailingMerge.optional(),
   document: TemplateDocument.optional()
 }).refine((v) => Object.keys(v).length > 0, "at least one field");
 var MailingListQuery = PageQuery.extend({
@@ -1060,30 +1242,30 @@ var MailingListQuery = PageQuery.extend({
   kind: MailingKind.optional(),
   automation_id: Id.optional()
 });
-var MailingSendRequest = z7.object({}).strict();
-var MailingRetryFailedRequest = z7.object({
+var MailingSendRequest = z8.object({}).strict();
+var MailingRetryFailedRequest = z8.object({
   /**
    * Also requeue recipients whose outcome is unknown after a crash. They may
    * already have received the message, so this is a human's decision, never a
    * default.
    */
-  include_outcome_unknown: z7.boolean().optional()
+  include_outcome_unknown: z8.boolean().optional()
 }).strict();
-var MailingActionRequest = z7.object({}).strict();
-var MailingTestRequest = z7.object({
+var MailingActionRequest = z8.object({}).strict();
+var MailingTestRequest = z8.object({
   to: Email,
   merge: Properties.optional(),
   locale: LocaleTag.optional()
 });
-var MailingTestResult = z7.object({
+var MailingTestResult = z8.object({
   message_id: Id,
-  provider_message_id: z7.string().nullable()
+  provider_message_id: z8.string().nullable()
 });
 var RECIPIENT_STATUSES = ["queued", "sending", "sent", "failed", "skipped"];
-var RecipientStatus = z7.enum(RECIPIENT_STATUSES);
+var RecipientStatus = z8.enum(RECIPIENT_STATUSES);
 var SKIP_REASONS = ["suppressed", "not_subscribed", "contact_erased", "cancelled", "outcome_unknown"];
-var SkipReason = z7.enum(SKIP_REASONS);
-var Recipient = z7.object({
+var SkipReason = z8.enum(SKIP_REASONS);
+var Recipient = z8.object({
   id: Id,
   mailing_id: Id,
   contact_id: Id.nullable(),
@@ -1091,55 +1273,55 @@ var Recipient = z7.object({
   merge: Properties,
   status: RecipientStatus,
   skip_reason: SkipReason.nullable(),
-  attempts: z7.number().int().min(0),
+  attempts: z8.number().int().min(0),
   message_id: Id.nullable(),
-  last_error: z7.string().nullable(),
+  last_error: z8.string().nullable(),
   created_at: Timestamp,
   updated_at: Timestamp
 });
 var MAX_RECIPIENTS_PER_BATCH = 1e3;
 var MAX_LETTER_RECIPIENTS = 1;
 var LETTER_RECIPIENT_REFUSAL = "letter_has_one_recipient";
-var RecipientInput = z7.object({
+var RecipientInput = z8.object({
   contact_id: Id.optional(),
-  external_id: z7.string().min(1).max(255).optional(),
+  external_id: z8.string().min(1).max(255).optional(),
   email: Email.optional(),
   merge: Properties.optional()
 }).refine((v) => v.contact_id !== void 0 || v.external_id !== void 0 || v.email !== void 0, {
   message: "contact_id, external_id or email is required",
   path: ["email"]
 });
-var RecipientBatch = z7.object({
-  recipients: z7.array(RecipientInput).min(1).max(MAX_RECIPIENTS_PER_BATCH)
+var RecipientBatch = z8.object({
+  recipients: z8.array(RecipientInput).min(1).max(MAX_RECIPIENTS_PER_BATCH)
 });
 var RECIPIENT_REJECTIONS = ["unknown_contact", "duplicate_in_batch"];
-var RecipientBatchResult = z7.object({
+var RecipientBatchResult = z8.object({
   /** Newly queued. */
-  added: z7.number().int().min(0),
+  added: z8.number().int().min(0),
   /** Already on the mailing from an earlier batch: left unchanged. */
-  already_present: z7.number().int().min(0),
+  already_present: z8.number().int().min(0),
   /** Items not added, by their index in the request. */
-  rejected: z7.array(z7.object({ index: z7.number().int().min(0), reason: z7.enum(RECIPIENT_REJECTIONS) }))
+  rejected: z8.array(z8.object({ index: z8.number().int().min(0), reason: z8.enum(RECIPIENT_REJECTIONS) }))
 });
 var RecipientListQuery = PageQuery.extend({
   status: RecipientStatus.optional(),
   skip_reason: SkipReason.optional()
 });
 var MESSAGE_OUTCOMES = ["sent", "failed"];
-var MessageOutcome = z7.enum(MESSAGE_OUTCOMES);
-var MessageSummary = z7.object({
+var MessageOutcome = z8.enum(MESSAGE_OUTCOMES);
+var MessageSummary = z8.object({
   id: Id,
   mailing_id: Id.nullable(),
   recipient_id: Id.nullable(),
   contact_id: Id.nullable(),
   to: Email,
-  subject: z7.string(),
+  subject: z8.string(),
   provider_id: Id,
-  provider_message_id: z7.string().nullable(),
+  provider_message_id: z8.string().nullable(),
   outcome: MessageOutcome,
-  error: z7.string().nullable(),
-  is_test: z7.boolean(),
-  recipient_count: z7.number().int().min(1),
+  error: z8.string().nullable(),
+  is_test: z8.boolean(),
+  recipient_count: z8.number().int().min(1),
   /** The language version the message was sent in; null for messages archived before languages existed. */
   locale: LocaleTag.nullable(),
   /**
@@ -1149,24 +1331,32 @@ var MessageSummary = z7.object({
    * "otherwise" text. Null when the message had no insertions.
    */
   insertions: InsertionChoices.nullable(),
+  /**
+   * The values the message was written with, by name: the text each one
+   * printed and the layer it came from (see `MessageValues`), recorded when it
+   * was sent, so a later change to a default never rewrites what a reader got.
+   * Null for a message archived before values were recorded, and for a signup
+   * form's confirmation, which belongs to no mailing.
+   */
+  values: MessageValues.nullable().default(null),
   created_at: Timestamp
 });
-var Message = MessageSummary.extend({ html: z7.string() });
-var MailingLanguageStatus = z7.enum(["main", "ready", "draft", "not_a_workspace_language"]);
-var MailingLanguage = z7.object({
+var Message = MessageSummary.extend({ html: z8.string() });
+var MailingLanguageStatus = z8.enum(["main", "ready", "draft", "not_a_workspace_language"]);
+var MailingLanguage = z8.object({
   locale: LocaleTag,
   status: MailingLanguageStatus,
   /** Queued recipients who will get this version. */
-  planned: z7.number().int().min(0),
+  planned: z8.number().int().min(0),
   /** Messages already sent in this language (tests excluded). */
-  sent: z7.number().int().min(0)
+  sent: z8.number().int().min(0)
 });
-var MailingLanguageReport = z7.object({
+var MailingLanguageReport = z8.object({
   main_locale: LocaleTag,
   send_locale: LocaleTag.nullable(),
-  languages: z7.array(MailingLanguage),
-  fallback: z7.array(z7.object({ wanted: z7.string(), planned: z7.number().int().min(1) })),
-  no_language: z7.number().int().min(0),
+  languages: z8.array(MailingLanguage),
+  fallback: z8.array(z8.object({ wanted: z8.string(), planned: z8.number().int().min(1) })),
+  no_language: z8.number().int().min(0),
   /**
    * Values that no choice of an insertion takes, so the "otherwise" text goes
    * out (docs/plans/2026-09-25-translated-insertions.md, decision 3): per
@@ -1175,41 +1365,56 @@ var MailingLanguageReport = z7.object({
    * template's keys never produces one; a non-empty list means the client and
    * the template have drifted apart.
    */
-  insertion_misses: z7.array(
-    z7.object({
-      insertion: z7.string(),
-      value: z7.string(),
-      planned: z7.number().int().min(0),
-      sent: z7.number().int().min(0)
+  insertion_misses: z8.array(
+    z8.object({
+      insertion: z8.string(),
+      value: z8.string(),
+      planned: z8.number().int().min(0),
+      sent: z8.number().int().min(0)
     })
   )
 });
+var MailingResolveRequest = z8.object({
+  recipients: z8.array(RecipientInput).max(MAX_RECIPIENTS_PER_BATCH).optional()
+});
+var MailingResolveResult = z8.object({
+  /** Every value the mailing's content can read, in order of first appearance, without `email` and `unsubscribe_url`. */
+  names: z8.array(z8.string()),
+  /** The values and insertions placed inside a link's address: one of them empty for anybody refuses the send. */
+  link_values: z8.array(z8.string()),
+  /** One entry per resolved recipient, in the request's order; a single entry with `index: null` when none were given. */
+  recipients: z8.array(ResolvedRecipient),
+  /** Items not resolved, by their index in the request, for the reasons `mailings.addRecipients` rejects one. */
+  rejected: z8.array(z8.object({ index: z8.number().int().min(0), reason: z8.enum(RESOLVE_REJECTIONS) })),
+  /** What would refuse `mailings.send` for these recipients, as its `unfilled_link` refusal lists it; empty means none. */
+  blocking: z8.array(UnfilledLink)
+});
 var MessageListQuery = PageQuery.extend({
   mailing_id: Id.optional(),
   outcome: MessageOutcome.optional()
 });
 
 // src/platform.ts
-var Tag = z8.object({
+var Tag = z9.object({
   id: Id,
   slug: Slug,
-  name: z8.string().min(1).max(120),
-  contact_count: z8.number().int().min(0),
+  name: z9.string().min(1).max(120),
+  contact_count: z9.number().int().min(0),
   created_at: Timestamp
 });
-var TagCreate = z8.object({ slug: Slug, name: z8.string().min(1).max(120) });
-var TagAssignment = z8.object({
-  contact_ids: z8.array(Id).min(1).max(1e3)
+var TagCreate = z9.object({ slug: Slug, name: z9.string().min(1).max(120) });
+var TagAssignment = z9.object({
+  contact_ids: z9.array(Id).min(1).max(1e3)
 });
 var CONTACT_PROPERTY_TYPES = ["string", "number", "boolean", "date"];
-var ContactPropertyType = z8.enum(CONTACT_PROPERTY_TYPES);
-var ContactPropertyKey = z8.string().regex(/^[A-Za-z0-9_.-]{1,64}$/, "letters, digits, dot, underscore and hyphen, 1 to 64");
-var ContactPropertyDefinition = z8.object({
+var ContactPropertyType = z9.enum(CONTACT_PROPERTY_TYPES);
+var ContactPropertyKey = z9.string().regex(/^[A-Za-z0-9_.-]{1,64}$/, "letters, digits, dot, underscore and hyphen, 1 to 64");
+var ContactPropertyDefinition = z9.object({
   key: ContactPropertyKey,
-  label: z8.string().min(1).max(120),
+  label: z9.string().min(1).max(120),
   type: ContactPropertyType
 });
-var ContactPropertyParams = z8.object({ key: ContactPropertyKey });
+var ContactPropertyParams = z9.object({ key: ContactPropertyKey });
 var FILTER_OPERATORS = [
   "eq",
   "neq",
@@ -1225,8 +1430,8 @@ var FILTER_OPERATORS = [
   "in",
   "not_in"
 ];
-var FilterOperator = z8.enum(FILTER_OPERATORS);
-var FilterField = z8.string().regex(
+var FilterOperator = z9.enum(FILTER_OPERATORS);
+var FilterField = z9.string().regex(
   /^(email|first_name|last_name|locale|created_at|tag|topic|engagement:(opened|clicked)|property:[A-Za-z0-9_.-]{1,64})$/,
   "unknown filter field"
 );
@@ -1242,18 +1447,18 @@ var FILTER_FIELD_OPERATORS = {
   property: FILTER_OPERATORS
 };
 var MAX_FILTER_DEPTH = 5;
-var FilterCondition = z8.object({ field: FilterField, op: FilterOperator, value: JsonValue.optional() }).strict().refine((c) => (c.op === "exists" || c.op === "not_exists") === (c.value === void 0), {
+var FilterCondition = z9.object({ field: FilterField, op: FilterOperator, value: JsonValue.optional() }).strict().refine((c) => (c.op === "exists" || c.op === "not_exists") === (c.value === void 0), {
   message: "exists and not_exists take no value; every other operator needs one",
   path: ["value"]
 }).refine((c) => c.op !== "in" && c.op !== "not_in" || Array.isArray(c.value), {
   message: "in and not_in take an array",
   path: ["value"]
 });
-var SegmentFilter = z8.lazy(
-  () => z8.union([
-    z8.object({ and: z8.array(SegmentFilter).min(1).max(50) }).strict(),
-    z8.object({ or: z8.array(SegmentFilter).min(1).max(50) }).strict(),
-    z8.object({ not: SegmentFilter }).strict(),
+var SegmentFilter = z9.lazy(
+  () => z9.union([
+    z9.object({ and: z9.array(SegmentFilter).min(1).max(50) }).strict(),
+    z9.object({ or: z9.array(SegmentFilter).min(1).max(50) }).strict(),
+    z9.object({ not: SegmentFilter }).strict(),
     FilterCondition
   ])
 );
@@ -1341,42 +1546,42 @@ function untypedValueProblem(c, every) {
   if (orderOp) return every(isFilterNumber, "numbers (define the property to compare dates)");
   return every((v) => isScalar(v) || v === null, "strings, numbers, booleans or null");
 }
-var Segment = z8.object({
+var Segment = z9.object({
   id: Id,
-  name: z8.string().min(1).max(120),
+  name: z9.string().min(1).max(120),
   filter: SegmentFilter,
   /** Computed on read. */
-  contact_count: z8.number().int().min(0),
+  contact_count: z9.number().int().min(0),
   created_at: Timestamp,
   updated_at: Timestamp
 });
-var SegmentCreate = z8.object({ name: z8.string().min(1).max(120), filter: BoundedSegmentFilter });
-var SegmentPreviewRequest = z8.object({ filter: BoundedSegmentFilter });
-var SegmentPreview = z8.object({
-  contact_count: z8.number().int().min(0),
+var SegmentCreate = z9.object({ name: z9.string().min(1).max(120), filter: BoundedSegmentFilter });
+var SegmentPreviewRequest = z9.object({ filter: BoundedSegmentFilter });
+var SegmentPreview = z9.object({
+  contact_count: z9.number().int().min(0),
   /** Up to five matching contacts, for a human to sanity-check the filter. */
-  sample: z8.array(z8.object({ id: Id, email: Email })).max(5)
+  sample: z9.array(z9.object({ id: Id, email: Email })).max(5)
 });
-var MailingAudienceFromSegment = z8.object({ segment_id: Id });
+var MailingAudienceFromSegment = z9.object({ segment_id: Id });
 var SIGNUP_FORM_FIELDS = ["first_name", "last_name"];
 var HOSTED_PAGE_LOCALES = ["en", "de", "it", "fr", "es"];
-var SignupFormTranslation = z8.object({
-  title: z8.string().min(1).max(120),
-  consent_text: z8.string().min(1).max(2e3)
+var SignupFormTranslation = z9.object({
+  title: z9.string().min(1).max(120),
+  consent_text: z9.string().min(1).max(2e3)
 });
-var SignupForm = z8.object({
+var SignupForm = z9.object({
   id: Id,
-  name: z8.string().min(1).max(120),
+  name: z9.string().min(1).max(120),
   /** The heading of the hosted page. */
-  title: z8.string().min(1).max(120),
+  title: z9.string().min(1).max(120),
   /** What the person agrees to, shown above the button and recorded with the confirmation. */
-  consent_text: z8.string().min(1).max(2e3),
-  translations: z8.record(SignupFormTranslation),
-  topics: z8.array(Slug).min(1),
-  tags: z8.array(Slug),
+  consent_text: z9.string().min(1).max(2e3),
+  translations: z9.record(SignupFormTranslation),
+  topics: z9.array(Slug).min(1),
+  tags: z9.array(Slug),
   /** Fields shown besides email. */
-  fields: z8.array(z8.enum(SIGNUP_FORM_FIELDS)),
-  double_opt_in: z8.literal(true),
+  fields: z9.array(z9.enum(SIGNUP_FORM_FIELDS)),
+  double_opt_in: z9.literal(true),
   /** The provider the confirmation mail is sent through. */
   provider_id: Id,
   /**
@@ -1385,11 +1590,11 @@ var SignupForm = z8.object({
    */
   confirmation_template_id: Id.nullable(),
   /** Where the person lands after confirming. Null shows the hosted confirmation page. */
-  redirect_url: z8.string().url().nullable(),
+  redirect_url: z9.string().url().nullable(),
   /** Origins allowed to embed the form and call the submission route from a browser. */
-  allowed_origins: z8.array(z8.string().url()).max(20),
+  allowed_origins: z9.array(z9.string().url()).max(20),
   /** Bumped on every change; recorded with each confirmation. */
-  version: z8.number().int().min(1),
+  version: z9.number().int().min(1),
   created_at: Timestamp,
   updated_at: Timestamp
 });
@@ -1404,56 +1609,56 @@ var SignupFormCreate = SignupForm.omit({
   tags: SignupForm.shape.tags.optional(),
   fields: SignupForm.shape.fields.optional(),
   confirmation_template_id: Id.nullable().optional(),
-  redirect_url: z8.string().url().nullable().optional(),
+  redirect_url: z9.string().url().nullable().optional(),
   allowed_origins: SignupForm.shape.allowed_origins.optional()
 });
-var SignupFormEmbed = z8.object({
-  hosted_url: z8.string().url(),
+var SignupFormEmbed = z9.object({
+  hosted_url: z9.string().url(),
   /** A plain HTML form posting to the hosted page; works without JavaScript. */
-  html: z8.string(),
+  html: z9.string(),
   /** A small optional script that adds the time check and submits in place. */
-  script_url: z8.string().url(),
+  script_url: z9.string().url(),
   /** Where a browser fetches a fresh `form_token` from (GET, public, CORS for `allowed_origins`). */
-  token_url: z8.string().url()
+  token_url: z9.string().url()
 });
-var SignupSubmission = z8.object({
+var SignupSubmission = z9.object({
   email: Email,
-  first_name: z8.string().max(200).optional(),
-  last_name: z8.string().max(200).optional(),
-  locale: z8.string().min(2).max(35).optional(),
+  first_name: z9.string().max(200).optional(),
+  last_name: z9.string().max(200).optional(),
+  locale: z9.string().min(2).max(35).optional(),
   /** Honeypot: must be empty. */
-  website: z8.string().max(0).optional(),
+  website: z9.string().max(0).optional(),
   /**
    * The signed render time from the form's token URL: a submission sooner than a
    * human could fill the form, or long after, is refused.
    */
-  form_token: z8.string().min(1).max(512)
+  form_token: z9.string().min(1).max(512)
 });
 var IMPORT_STATUSES = ["uploaded", "validating", "validated", "committing", "completed", "failed", "cancelled"];
-var ImportStatus = z8.enum(IMPORT_STATUSES);
+var ImportStatus = z9.enum(IMPORT_STATUSES);
 var IMPORT_TERMINAL_STATUSES = ["completed", "failed", "cancelled"];
-var ImportColumnMapping = z8.record(
-  z8.string().regex(/^(email|external_id|first_name|last_name|locale|property:[A-Za-z0-9_.-]{1,64}|ignore)$/)
+var ImportColumnMapping = z9.record(
+  z9.string().regex(/^(email|external_id|first_name|last_name|locale|property:[A-Za-z0-9_.-]{1,64}|ignore)$/)
 );
 var IMPORT_FILE_FIELD = "file";
 var MAX_IMPORT_BYTES = 50 * 1024 * 1024;
 var MAX_IMPORT_ROWS = 2e5;
-var ImportMappingRequest = z8.object({
+var ImportMappingRequest = z9.object({
   /** CSV header -> contact field. Exactly one column maps to `email`. */
   mapping: ImportColumnMapping.refine(
     (m) => Object.values(m).filter((v) => v === "email").length === 1,
     "exactly one column maps to email"
   ),
-  topics: z8.array(Slug).max(100),
-  tags: z8.array(Slug).max(100),
+  topics: z9.array(Slug).max(100),
+  tags: z9.array(Slug).max(100),
   /** Existing contacts get the mapped fields overwritten; false only adds topics, tags and missing fields. */
-  update_existing: z8.boolean().optional(),
+  update_existing: z9.boolean().optional(),
   /** The importer states the people consented; the service records who said so and when. */
-  consent_confirmed: z8.literal(true)
+  consent_confirmed: z9.literal(true)
 });
-var ImportCommitRequest = z8.object({ mapping_version: z8.number().int().min(1) });
+var ImportCommitRequest = z9.object({ mapping_version: z9.number().int().min(1) });
 var IMPORT_ROW_OUTCOMES = ["created", "updated", "unchanged", "suppressed", "skipped"];
-var ImportRowOutcome = z8.enum(IMPORT_ROW_OUTCOMES);
+var ImportRowOutcome = z9.enum(IMPORT_ROW_OUTCOMES);
 var IMPORT_SKIP_REASONS = [
   "missing_email",
   "invalid_email",
@@ -1462,90 +1667,90 @@ var IMPORT_SKIP_REASONS = [
   "external_id_conflict",
   "wrong_column_count"
 ];
-var ImportSkipReason = z8.enum(IMPORT_SKIP_REASONS);
-var ImportReport = z8.object({
-  created: z8.number().int().min(0),
-  updated: z8.number().int().min(0),
-  unchanged: z8.number().int().min(0),
-  suppressed: z8.number().int().min(0),
-  skipped: z8.number().int().min(0),
-  skipped_by_reason: z8.record(ImportSkipReason, z8.number().int().min(0)),
+var ImportSkipReason = z9.enum(IMPORT_SKIP_REASONS);
+var ImportReport = z9.object({
+  created: z9.number().int().min(0),
+  updated: z9.number().int().min(0),
+  unchanged: z9.number().int().min(0),
+  suppressed: z9.number().int().min(0),
+  skipped: z9.number().int().min(0),
+  skipped_by_reason: z9.record(ImportSkipReason, z9.number().int().min(0)),
   /** Rows whose contact was subscribed without some topic, because the address is blocked for it. */
-  topics_withheld: z8.number().int().min(0)
+  topics_withheld: z9.number().int().min(0)
 });
-var ImportJob = z8.object({
+var ImportJob = z9.object({
   id: Id,
   status: ImportStatus,
-  file_name: z8.string().max(255).nullable(),
-  file_bytes: z8.number().int().min(0),
-  total_rows: z8.number().int().min(0),
+  file_name: z9.string().max(255).nullable(),
+  file_bytes: z9.number().int().min(0),
+  total_rows: z9.number().int().min(0),
   /** The header row, as in the file. */
-  columns: z8.array(z8.string()),
+  columns: z9.array(z9.string()),
   /** The first rows, for the mapping screen. */
-  sample: z8.array(z8.array(z8.string())).max(5),
+  sample: z9.array(z9.array(z9.string())).max(5),
   /** A mapping guessed from the headers, for the mapping screen to start from. */
   suggested_mapping: ImportColumnMapping,
   mapping: ImportColumnMapping.nullable(),
-  mapping_version: z8.number().int().min(0),
-  topics: z8.array(Slug),
-  tags: z8.array(Slug),
-  update_existing: z8.boolean(),
+  mapping_version: z9.number().int().min(0),
+  topics: z9.array(Slug),
+  tags: z9.array(Slug),
+  update_existing: z9.boolean(),
   /** The dry run of the current mapping; null before one finished. */
   dry_run: ImportReport.nullable(),
   /** What the commit has written so far; null before it started. */
   result: ImportReport.nullable(),
   /** Rows the current phase (dry run or commit) has processed. */
-  processed_rows: z8.number().int().min(0),
+  processed_rows: z9.number().int().min(0),
   /** Why a `failed` import failed. */
-  error: z8.string().nullable(),
+  error: z9.string().nullable(),
   created_at: Timestamp,
   updated_at: Timestamp,
   finished_at: Timestamp.nullable()
 });
-var ImportRow = z8.object({
+var ImportRow = z9.object({
   /** The line in the file, 1 being the first line after the header. */
-  row: z8.number().int().min(1),
-  email: z8.string().nullable(),
+  row: z9.number().int().min(1),
+  email: z9.string().nullable(),
   outcome: ImportRowOutcome,
   reason: ImportSkipReason.nullable(),
   /** A human explanation for a skipped row (which value, which column). */
-  message: z8.string().nullable(),
+  message: z9.string().nullable(),
   contact_id: Id.nullable()
 });
 var ImportRowListQuery = PageQuery.extend({ outcome: ImportRowOutcome.optional() });
-var MailingScheduleRequest = z8.object({ send_at: Timestamp });
-var TrackingSettings = z8.object({ opens: z8.boolean(), clicks: z8.boolean() });
-var VariantAnalytics = z8.object({
-  key: z8.string(),
-  sent: z8.number().int().min(0),
-  unique_opens: z8.number().int().min(0).nullable(),
-  unique_clicks: z8.number().int().min(0).nullable()
-});
-var MailingAnalytics = z8.object({
+var MailingScheduleRequest = z9.object({ send_at: Timestamp });
+var TrackingSettings = z9.object({ opens: z9.boolean(), clicks: z9.boolean() });
+var VariantAnalytics = z9.object({
+  key: z9.string(),
+  sent: z9.number().int().min(0),
+  unique_opens: z9.number().int().min(0).nullable(),
+  unique_clicks: z9.number().int().min(0).nullable()
+});
+var MailingAnalytics = z9.object({
   mailing_id: Id,
   counts: MailingCounts,
   /** What was tracked for this mailing, fixed when it started; null before it started. */
   tracking: TrackingSettings.nullable(),
   /** Unique recipients with a human open. Null when opens were not tracked. */
-  unique_opens: z8.number().int().min(0).nullable(),
+  unique_opens: z9.number().int().min(0).nullable(),
   /**
    * Recipients whose only opens came from Apple Mail Privacy Protection, which
    * loads every image on delivery: counted apart, never as human opens.
    */
-  apple_mpp_opens: z8.number().int().min(0).nullable(),
+  apple_mpp_opens: z9.number().int().min(0).nullable(),
   /** Opens and clicks from security scanners and prefetchers, filtered out of the unique counts. */
-  machine_events: z8.number().int().min(0).nullable(),
-  unique_clicks: z8.number().int().min(0).nullable(),
-  unsubscribes: z8.number().int().min(0),
-  bounces: z8.number().int().min(0),
-  complaints: z8.number().int().min(0),
-  links: z8.array(z8.object({ url: z8.string(), unique_clicks: z8.number().int().min(0) })).nullable(),
-  variants: z8.array(VariantAnalytics).nullable()
+  machine_events: z9.number().int().min(0).nullable(),
+  unique_clicks: z9.number().int().min(0).nullable(),
+  unsubscribes: z9.number().int().min(0),
+  bounces: z9.number().int().min(0),
+  complaints: z9.number().int().min(0),
+  links: z9.array(z9.object({ url: z9.string(), unique_clicks: z9.number().int().min(0) })).nullable(),
+  variants: z9.array(VariantAnalytics).nullable()
 });
 
 // src/automations.ts
 var AUTOMATION_FILTER_FIELD_PATTERN = /^(email|first_name|last_name|locale|created_at|tag|topic|segment|engagement:(opened|clicked)|step:(opened|clicked)|property:[A-Za-z0-9_.-]{1,64}|event:[A-Za-z0-9_.-]{1,64})$/;
-var AutomationFilterField = z9.string().regex(AUTOMATION_FILTER_FIELD_PATTERN, "unknown filter field");
+var AutomationFilterField = z10.string().regex(AUTOMATION_FILTER_FIELD_PATTERN, "unknown filter field");
 var AUTOMATION_FILTER_FIELD_OPERATORS = {
   ...FILTER_FIELD_OPERATORS,
   segment: ["eq", "neq", "in", "not_in"],
@@ -1555,18 +1760,18 @@ var AUTOMATION_FILTER_FIELD_OPERATORS = {
   step: ["eq", "neq"]
 };
 var automationFilterFamily = filterFieldFamily;
-var AutomationFilterCondition = z9.object({ field: AutomationFilterField, op: FilterOperator, value: JsonValue.optional() }).strict().refine((c) => (c.op === "exists" || c.op === "not_exists") === (c.value === void 0), {
+var AutomationFilterCondition = z10.object({ field: AutomationFilterField, op: FilterOperator, value: JsonValue.optional() }).strict().refine((c) => (c.op === "exists" || c.op === "not_exists") === (c.value === void 0), {
   message: "exists and not_exists take no value; every other operator needs one",
   path: ["value"]
 }).refine((c) => c.op !== "in" && c.op !== "not_in" || Array.isArray(c.value), {
   message: "in and not_in take an array",
   path: ["value"]
 });
-var AutomationFilter = z9.lazy(
-  () => z9.union([
-    z9.object({ and: z9.array(AutomationFilter).min(1).max(50) }).strict(),
-    z9.object({ or: z9.array(AutomationFilter).min(1).max(50) }).strict(),
-    z9.object({ not: AutomationFilter }).strict(),
+var AutomationFilter = z10.lazy(
+  () => z10.union([
+    z10.object({ and: z10.array(AutomationFilter).min(1).max(50) }).strict(),
+    z10.object({ or: z10.array(AutomationFilter).min(1).max(50) }).strict(),
+    z10.object({ not: AutomationFilter }).strict(),
     AutomationFilterCondition
   ])
 );
@@ -1579,20 +1784,20 @@ function filterConditions(filter) {
   if ("not" in filter) return filterConditions(filter.not);
   return [filter];
 }
-var StepId = z9.string().regex(/^[A-Za-z0-9_-]{1,64}$/, "letters, digits, underscore and hyphen, 1 to 64");
-var TimeOfDay = z9.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "HH:MM in 24 hours");
-var Weekday = z9.number().int().min(0).max(6);
-var TimezoneName = z9.string().min(1).max(64).regex(/^(UTC|[A-Za-z][A-Za-z0-9_+-]*(?:\/[A-Za-z0-9_+-]+)+)$/, "an IANA time zone name such as Europe/Berlin");
+var StepId = z10.string().regex(/^[A-Za-z0-9_-]{1,64}$/, "letters, digits, underscore and hyphen, 1 to 64");
+var TimeOfDay = z10.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "HH:MM in 24 hours");
+var Weekday = z10.number().int().min(0).max(6);
+var TimezoneName = z10.string().min(1).max(64).regex(/^(UTC|[A-Za-z][A-Za-z0-9_+-]*(?:\/[A-Za-z0-9_+-]+)+)$/, "an IANA time zone name such as Europe/Berlin");
 var MAX_DELAY_SECONDS = 365 * 24 * 60 * 60;
-var DateOnly = z9.string().regex(/^\d{4}-\d{2}-\d{2}$/, "a calendar date such as 2026-09-20").refine((v) => {
+var DateOnly = z10.string().regex(/^\d{4}-\d{2}-\d{2}$/, "a calendar date such as 2026-09-20").refine((v) => {
   const [y, m, d] = v.split("-").map(Number);
   const t = new Date(Date.UTC(y, m - 1, d));
   return t.getUTCFullYear() === y && t.getUTCMonth() + 1 === m && t.getUTCDate() === d;
 }, "a real calendar date");
-var OffsetDays = z9.number().int().min(-365).max(365);
+var OffsetDays = z10.number().int().min(-365).max(365);
 var DATE_PASSED_ANSWERS = ["skip", "stop", "continue"];
-var DatePassedAnswer = z9.enum(DATE_PASSED_ANSWERS);
-var EventName = z9.string().regex(/^[A-Za-z0-9][A-Za-z0-9_.:-]{0,79}$/, "letters, digits, dot, colon, underscore and hyphen, 1 to 80");
+var DatePassedAnswer = z10.enum(DATE_PASSED_ANSWERS);
+var EventName = z10.string().regex(/^[A-Za-z0-9][A-Za-z0-9_.:-]{0,79}$/, "letters, digits, dot, colon, underscore and hyphen, 1 to 80");
 var AUTOMATION_TRIGGER_KINDS = [
   "topic_subscribed",
   "form_confirmed",
@@ -1605,17 +1810,17 @@ var AUTOMATION_TRIGGER_KINDS = [
   "segment_entered",
   "link_clicked"
 ];
-var AutomationTriggerKind = z9.enum(AUTOMATION_TRIGGER_KINDS);
+var AutomationTriggerKind = z10.enum(AUTOMATION_TRIGGER_KINDS);
 var exclude = { exclude: BoundedAutomationFilter.nullish() };
-var AutomationTrigger = z9.discriminatedUnion("kind", [
-  z9.object({ kind: z9.literal("topic_subscribed"), topic: Slug, ...exclude }).strict(),
-  z9.object({ kind: z9.literal("form_confirmed"), form_id: Id, ...exclude }).strict(),
-  z9.object({ kind: z9.literal("tag_added"), tag: Slug, ...exclude }).strict(),
+var AutomationTrigger = z10.discriminatedUnion("kind", [
+  z10.object({ kind: z10.literal("topic_subscribed"), topic: Slug, ...exclude }).strict(),
+  z10.object({ kind: z10.literal("form_confirmed"), form_id: Id, ...exclude }).strict(),
+  z10.object({ kind: z10.literal("tag_added"), tag: Slug, ...exclude }).strict(),
   /** `to` given: only a change that lands on this value fires. Absent: any change of the key. */
-  z9.object({ kind: z9.literal("property_changed"), key: ContactPropertyKey, to: JsonValue.optional(), ...exclude }).strict(),
+  z10.object({ kind: z10.literal("property_changed"), key: ContactPropertyKey, to: JsonValue.optional(), ...exclude }).strict(),
   /** `where` filters the event's own data, so only `event:<key>` leaves belong in it. */
-  z9.object({ kind: z9.literal("event"), name: EventName, where: BoundedAutomationFilter.nullish(), ...exclude }).strict(),
-  z9.object({ kind: z9.literal("manual"), ...exclude }).strict(),
+  z10.object({ kind: z10.literal("event"), name: EventName, where: BoundedAutomationFilter.nullish(), ...exclude }).strict(),
+  z10.object({ kind: z10.literal("manual"), ...exclude }).strict(),
   /**
    * Every year on a date the contact carries: a birthday, a joining date, a
    * renewal. `offset_days` moves it ("three days before"), `at` is the wall
@@ -1625,8 +1830,8 @@ var AutomationTrigger = z9.discriminatedUnion("kind", [
    * A 29 February date fires on 1 March in a year that has no 29 February, so
    * nobody is skipped every fourth year.
    */
-  z9.object({
-    kind: z9.literal("date_anniversary"),
+  z10.object({
+    kind: z10.literal("date_anniversary"),
     key: ContactPropertyKey,
     offset_days: OffsetDays,
     at: TimeOfDay,
@@ -1638,8 +1843,8 @@ var AutomationTrigger = z9.discriminatedUnion("kind", [
    * not ask about a segment or about an event's data: there is no event, and a
    * segment is its own trigger kind.
    */
-  z9.object({
-    kind: z9.literal("exact_date"),
+  z10.object({
+    kind: z10.literal("exact_date"),
     on: DateOnly,
     at: TimeOfDay,
     where: BoundedAutomationFilter.nullish(),
@@ -1658,7 +1863,7 @@ var AutomationTrigger = z9.discriminatedUnion("kind", [
    * already exists. Entering those people as well is the publish dialog's
    * backfill question, answered by a person rather than by the sweep.
    */
-  z9.object({ kind: z9.literal("segment_entered"), segment_id: Id, ...exclude }).strict(),
+  z10.object({ kind: z10.literal("segment_entered"), segment_id: Id, ...exclude }).strict(),
   /**
    * S4. When somebody clicks a link in a mailing that has already gone out.
    *
@@ -1668,7 +1873,7 @@ var AutomationTrigger = z9.discriminatedUnion("kind", [
    * tracking off there is no click to hear about, so the validator refuses it
    * rather than leaving an automation that can never fire.
    */
-  z9.object({ kind: z9.literal("link_clicked"), mailing_id: Id, url: z9.string().min(1).max(2048).optional(), ...exclude }).strict()
+  z10.object({ kind: z10.literal("link_clicked"), mailing_id: Id, url: z10.string().min(1).max(2048).optional(), ...exclude }).strict()
 ]);
 var AUTOMATION_DATE_TRIGGER_KINDS = ["date_anniversary", "exact_date"];
 var MAX_TRIGGERS = 10;
@@ -1687,45 +1892,45 @@ var AUTOMATION_STEP_KINDS = [
   "webhook",
   "notify"
 ];
-var AutomationStepKind = z9.enum(AUTOMATION_STEP_KINDS);
+var AutomationStepKind = z10.enum(AUTOMATION_STEP_KINDS);
 var next = { next: StepId.nullable() };
-var Unchosen = z9.literal("");
-var DraftSlug = z9.union([Slug, Unchosen]);
-var DraftPropertyKey = z9.union([ContactPropertyKey, Unchosen]);
-var label2 = { label: z9.string().max(120).nullish() };
-var EmailStepLanguage = z9.object({
-  subject: z9.string().min(1).max(998),
-  preheader: z9.string().max(500).nullable(),
+var Unchosen = z10.literal("");
+var DraftSlug = z10.union([Slug, Unchosen]);
+var DraftPropertyKey = z10.union([ContactPropertyKey, Unchosen]);
+var label2 = { label: z10.string().max(120).nullish() };
+var EmailStepLanguage = z10.object({
+  subject: z10.string().min(1).max(998),
+  preheader: z10.string().max(500).nullable(),
   document: TemplateDocument,
   /** This language's insertions, its texts over the template's structure (every text present). */
   insertions: Insertions.nullish()
 }).strict();
-var EmailStep = z9.object({
-  kind: z9.literal("email"),
+var EmailStep = z10.object({
+  kind: z10.literal("email"),
   ...label2,
   ...next,
   template_id: Id.nullish(),
   document: TemplateDocument.nullish(),
   /** Empty while the step is being written, or when its template has a subject; else `not_chosen` refuses to publish it. */
-  subject: z9.string().max(998),
-  preheader: z9.string().max(500).nullish(),
+  subject: z10.string().max(998),
+  preheader: z10.string().max(500).nullish(),
   locale: LocaleTag.nullish(),
-  languages: z9.record(LocaleTag, EmailStepLanguage).nullish(),
+  languages: z10.record(LocaleTag, EmailStepLanguage).nullish(),
   /** The main language's insertions, snapshot from the template when the automation is published. */
   insertions: Insertions.nullish()
 }).strict();
-var DelayStep = z9.object({
-  kind: z9.literal("delay"),
+var DelayStep = z10.object({
+  kind: z10.literal("delay"),
   ...label2,
   ...next,
-  wait: z9.discriminatedUnion("mode", [
-    z9.object({ mode: z9.literal("duration"), seconds: z9.number().int().min(1).max(MAX_DELAY_SECONDS) }).strict(),
-    z9.object({ mode: z9.literal("time_of_day"), at: TimeOfDay }).strict(),
-    z9.object({ mode: z9.literal("weekday"), weekday: Weekday, at: TimeOfDay }).strict(),
+  wait: z10.discriminatedUnion("mode", [
+    z10.object({ mode: z10.literal("duration"), seconds: z10.number().int().min(1).max(MAX_DELAY_SECONDS) }).strict(),
+    z10.object({ mode: z10.literal("time_of_day"), at: TimeOfDay }).strict(),
+    z10.object({ mode: z10.literal("weekday"), weekday: Weekday, at: TimeOfDay }).strict(),
     /** A fixed day has no next occurrence, so `continue` is not one of its answers. */
-    z9.object({ mode: z9.literal("date"), on: DateOnly, at: TimeOfDay, passed: z9.enum(["skip", "stop"]) }).strict(),
-    z9.object({
-      mode: z9.literal("date_property"),
+    z10.object({ mode: z10.literal("date"), on: DateOnly, at: TimeOfDay, passed: z10.enum(["skip", "stop"]) }).strict(),
+    z10.object({
+      mode: z10.literal("date_property"),
       key: ContactPropertyKey,
       offset_days: OffsetDays,
       at: TimeOfDay,
@@ -1733,8 +1938,8 @@ var DelayStep = z9.object({
     }).strict()
   ])
 }).strict();
-var ConditionStep = z9.object({
-  kind: z9.literal("condition"),
+var ConditionStep = z10.object({
+  kind: z10.literal("condition"),
   ...label2,
   filter: BoundedAutomationFilter,
   yes: StepId.nullable(),
@@ -1745,49 +1950,49 @@ var ConditionStep = z9.object({
    * neither half means anything without the other: a window with no answer
    * for the end of it would be a silent decision.
    */
-  wait_for: z9.object({ up_to_s: z9.number().int().min(1).max(MAX_DELAY_SECONDS), on_timeout: z9.enum(["yes", "no"]) }).strict().nullish()
+  wait_for: z10.object({ up_to_s: z10.number().int().min(1).max(MAX_DELAY_SECONDS), on_timeout: z10.enum(["yes", "no"]) }).strict().nullish()
 }).strict();
-var SplitBranchKey = z9.string().regex(/^[A-Za-z0-9_-]{1,32}$/, "letters, digits, underscore and hyphen, 1 to 32");
+var SplitBranchKey = z10.string().regex(/^[A-Za-z0-9_-]{1,32}$/, "letters, digits, underscore and hyphen, 1 to 32");
 var MIN_SPLIT_BRANCHES = 2;
 var MAX_SPLIT_BRANCHES = 4;
-var SplitStep = z9.object({
-  kind: z9.literal("split"),
+var SplitStep = z10.object({
+  kind: z10.literal("split"),
   ...label2,
-  branches: z9.array(
-    z9.object({
+  branches: z10.array(
+    z10.object({
       key: SplitBranchKey,
       /** A whole percentage. Zero is allowed: a branch kept in the flow but switched off. */
-      weight: z9.number().int().min(0).max(100),
+      weight: z10.number().int().min(0).max(100),
       next: StepId.nullable()
     }).strict()
   ).min(MIN_SPLIT_BRANCHES).max(MAX_SPLIT_BRANCHES).refine((bs) => new Set(bs.map((b) => b.key)).size === bs.length, "each branch needs its own key").refine((bs) => bs.reduce((sum, b) => sum + b.weight, 0) === 100, "the weights have to come to 100")
 }).strict();
-var GotoStep = z9.object({ kind: z9.literal("goto"), ...label2, target: StepId.nullable() }).strict();
+var GotoStep = z10.object({ kind: z10.literal("goto"), ...label2, target: StepId.nullable() }).strict();
 var MAX_STEP_VISITS = 20;
-var WebhookStep = z9.object({ kind: z9.literal("webhook"), ...label2, ...next, endpoint_id: Id.nullable(), payload: JsonValue.nullish() }).strict();
-var NotifyRecipients = z9.union([z9.literal("owner"), z9.literal("admins"), z9.object({ member_id: Id }).strict()]);
-var NotifyStep = z9.object({
-  kind: z9.literal("notify"),
+var WebhookStep = z10.object({ kind: z10.literal("webhook"), ...label2, ...next, endpoint_id: Id.nullable(), payload: JsonValue.nullish() }).strict();
+var NotifyRecipients = z10.union([z10.literal("owner"), z10.literal("admins"), z10.object({ member_id: Id }).strict()]);
+var NotifyStep = z10.object({
+  kind: z10.literal("notify"),
   ...label2,
   ...next,
   to: NotifyRecipients,
   /** Empty while the step is being written; `not_chosen` refuses to publish it. */
-  subject: z9.string().max(998),
-  body: z9.string().max(1e4)
+  subject: z10.string().max(998),
+  body: z10.string().max(1e4)
 }).strict();
-var AutomationStep = z9.discriminatedUnion("kind", [
+var AutomationStep = z10.discriminatedUnion("kind", [
   EmailStep,
   DelayStep,
   ConditionStep,
-  z9.object({ kind: z9.literal("add_tag"), ...label2, ...next, tag: DraftSlug }).strict(),
-  z9.object({ kind: z9.literal("remove_tag"), ...label2, ...next, tag: DraftSlug }).strict(),
+  z10.object({ kind: z10.literal("add_tag"), ...label2, ...next, tag: DraftSlug }).strict(),
+  z10.object({ kind: z10.literal("remove_tag"), ...label2, ...next, tag: DraftSlug }).strict(),
   /** `value` null clears the property, as a contact upsert does. */
-  z9.object({ kind: z9.literal("set_property"), ...label2, ...next, key: DraftPropertyKey, value: JsonValue }).strict(),
+  z10.object({ kind: z10.literal("set_property"), ...label2, ...next, key: DraftPropertyKey, value: JsonValue }).strict(),
   /** Subscribing never lifts a suppression: the service checks that, not the flow. */
-  z9.object({ kind: z9.literal("subscribe_topic"), ...label2, ...next, topic: DraftSlug }).strict(),
+  z10.object({ kind: z10.literal("subscribe_topic"), ...label2, ...next, topic: DraftSlug }).strict(),
   /** `topic` unsubscribes from the automation's own topic, `all` from every topic. */
-  z9.object({ kind: z9.literal("unsubscribe"), ...label2, ...next, scope: z9.enum(["topic", "all"]) }).strict(),
-  z9.object({ kind: z9.literal("exit"), ...label2 }).strict(),
+  z10.object({ kind: z10.literal("unsubscribe"), ...label2, ...next, scope: z10.enum(["topic", "all"]) }).strict(),
+  z10.object({ kind: z10.literal("exit"), ...label2 }).strict(),
   SplitStep,
   GotoStep,
   WebhookStep,
@@ -1811,25 +2016,25 @@ function stepTargets(step) {
   }
 }
 var MAX_STEPS = 200;
-var AutomationFlow = z9.object({
-  triggers: z9.array(AutomationTrigger).max(MAX_TRIGGERS),
+var AutomationFlow = z10.object({
+  triggers: z10.array(AutomationTrigger).max(MAX_TRIGGERS),
   /** The first step. `null` is an empty flow. */
   entry: StepId.nullable(),
-  steps: z9.record(StepId, AutomationStep)
+  steps: z10.record(StepId, AutomationStep)
 }).strict();
 var emptyFlow = () => ({ triggers: [], entry: null, steps: {} });
-var QuietHours = z9.object({
+var QuietHours = z10.object({
   start: TimeOfDay,
   end: TimeOfDay,
-  weekdays: z9.array(Weekday).min(1).max(7).nullish()
+  weekdays: z10.array(Weekday).min(1).max(7).nullish()
 }).strict();
 var RE_ENTRY_MODES = ["off", "after_exit"];
-var ReEntryMode = z9.enum(RE_ENTRY_MODES);
+var ReEntryMode = z10.enum(RE_ENTRY_MODES);
 var MAX_RE_ENTRY_COOLDOWN_SECONDS = 365 * 24 * 60 * 60;
-var AutomationSettings = z9.object({
+var AutomationSettings = z10.object({
   re_entry: ReEntryMode,
   /** Seconds a person must wait after leaving before entering again. Only with `after_exit`. */
-  re_entry_cooldown_s: z9.number().int().min(0).max(MAX_RE_ENTRY_COOLDOWN_SECONDS).nullish(),
+  re_entry_cooldown_s: z10.number().int().min(0).max(MAX_RE_ENTRY_COOLDOWN_SECONDS).nullish(),
   quiet_hours: QuietHours.nullish(),
   /** Checked before every step; when it matches, the run ends. */
   exit_filter: BoundedAutomationFilter.nullish()
@@ -1887,18 +2092,18 @@ var AUTOMATION_ISSUE_CODES = [
   /** A one-off date that is already over everywhere on earth, so it would fire for nobody. */
   "date_in_the_past"
 ];
-var AutomationIssueCode = z9.enum(AUTOMATION_ISSUE_CODES);
-var AutomationIssue = z9.object({
+var AutomationIssueCode = z10.enum(AUTOMATION_ISSUE_CODES);
+var AutomationIssue = z10.object({
   code: AutomationIssueCode,
   /** The step the issue is about, when it is about one. */
   step_id: StepId.nullable(),
   /** Where inside the document, for the canvas to point at a field. */
-  path: z9.array(z9.union([z9.string(), z9.number()])),
-  message: z9.string()
+  path: z10.array(z10.union([z10.string(), z10.number()])),
+  message: z10.string()
 });
-var AutomationValidation = z9.object({
-  ok: z9.boolean(),
-  issues: z9.array(AutomationIssue)
+var AutomationValidation = z10.object({
+  ok: z10.boolean(),
+  issues: z10.array(AutomationIssue)
 });
 function validateAutomation(flow, settings, ctx) {
   const issues = [];
@@ -2289,7 +2494,7 @@ function cycles(flow) {
   return out.sort();
 }
 var AUTOMATION_STATUSES = ["draft", "active", "paused", "archived"];
-var AutomationStatus = z9.enum(AUTOMATION_STATUSES);
+var AutomationStatus = z10.enum(AUTOMATION_STATUSES);
 var AUTOMATION_END_REASONS = [
   "completed",
   "exit_filter",
@@ -2308,9 +2513,9 @@ var AUTOMATION_END_REASONS = [
   "ended_by_hand",
   "failed"
 ];
-var AutomationEndReason = z9.enum(AUTOMATION_END_REASONS);
+var AutomationEndReason = z10.enum(AUTOMATION_END_REASONS);
 var AUTOMATION_WAIT_REASONS = ["delay", "quiet_hours", "plan_limit", "sending", "condition"];
-var AutomationWaitReason = z9.enum(AUTOMATION_WAIT_REASONS);
+var AutomationWaitReason = z10.enum(AUTOMATION_WAIT_REASONS);
 var AUTOMATION_ENTRY_REFUSALS = [
   "already_inside",
   "re_entry_off",
@@ -2321,26 +2526,26 @@ var AUTOMATION_ENTRY_REFUSALS = [
   "not_active",
   "unknown_contact"
 ];
-var AutomationEntryRefusal = z9.enum(AUTOMATION_ENTRY_REFUSALS);
-var AutomationCounts = z9.object({
-  started: z9.number().int().min(0),
-  in_progress: z9.number().int().min(0),
-  completed: z9.number().int().min(0),
-  exited: z9.number().int().min(0),
-  failed: z9.number().int().min(0)
-});
-var Automation = z9.object({
+var AutomationEntryRefusal = z10.enum(AUTOMATION_ENTRY_REFUSALS);
+var AutomationCounts = z10.object({
+  started: z10.number().int().min(0),
+  in_progress: z10.number().int().min(0),
+  completed: z10.number().int().min(0),
+  exited: z10.number().int().min(0),
+  failed: z10.number().int().min(0)
+});
+var Automation = z10.object({
   id: Id,
-  name: z9.string().min(1).max(200),
+  name: z10.string().min(1).max(200),
   status: AutomationStatus,
   /** Every automation sends under one topic; there are no transactional automations. */
   topic: Slug,
   provider_id: Id.nullable(),
   settings: AutomationSettings,
   /** The flow people are running through, null while the automation has never been published. */
-  published_version: z9.number().int().min(1).nullable(),
+  published_version: z10.number().int().min(1).nullable(),
   /** The flow being edited. Increments on every save, like a template's version. */
-  draft_version: z9.number().int().min(1),
+  draft_version: z10.number().int().min(1),
   counts: AutomationCounts,
   created_at: Timestamp,
   updated_at: Timestamp,
@@ -2353,16 +2558,16 @@ var AutomationWithFlow = Automation.extend({
   published_flow: AutomationFlow.nullable()
 });
 var AutomationSummary = Automation;
-var AutomationCreate = z9.object({
-  name: z9.string().min(1).max(200),
+var AutomationCreate = z10.object({
+  name: z10.string().min(1).max(200),
   topic: Slug,
   provider_id: Id.optional(),
   flow: AutomationFlow.optional(),
   settings: AutomationSettings.partial().optional()
 });
-var AutomationUpdate = z9.object({
-  base_version: z9.number().int().min(1),
-  name: z9.string().min(1).max(200).optional(),
+var AutomationUpdate = z10.object({
+  base_version: z10.number().int().min(1),
+  name: z10.string().min(1).max(200).optional(),
   topic: Slug.optional(),
   provider_id: Id.optional(),
   flow: AutomationFlow.optional(),
@@ -2375,42 +2580,42 @@ var AutomationListQuery = PageQuery.extend({
   status: AutomationStatus.optional(),
   topic: Slug.optional()
 });
-var AutomationPublishRequest = z9.object({
+var AutomationPublishRequest = z10.object({
   /**
    * Answer what this publish would do and change nothing, whatever the flow
    * looks like. Without it a publish that has no issues and moves nobody
    * simply goes ahead, which is right for an API caller and wrong for a
    * dialog that is only showing somebody what they are about to do.
    */
-  dry_run: z9.boolean().optional(),
-  confirm: z9.boolean().optional(),
+  dry_run: z10.boolean().optional(),
+  confirm: z10.boolean().optional(),
   /** Per removed step: the step its waiting runs move to, or null to end them. */
-  moves: z9.record(StepId, StepId.nullable()).optional(),
+  moves: z10.record(StepId, StepId.nullable()).optional(),
   /** Also enter everyone who matches a trigger's condition right now. */
-  backfill: z9.boolean().optional()
+  backfill: z10.boolean().optional()
 }).strict();
-var AutomationPublishMove = z9.object({
+var AutomationPublishMove = z10.object({
   step_id: StepId,
   /** Why the step's people have to move: it is gone, or its delay changed. */
-  change: z9.enum(["removed", "delay_changed", "kind_changed"]),
-  waiting: z9.number().int().min(0),
+  change: z10.enum(["removed", "delay_changed", "kind_changed"]),
+  waiting: z10.number().int().min(0),
   /** Where they go: a step id, or null to end their runs with `step_removed`. */
   destination: StepId.nullable()
 });
-var AutomationPublishResult = z9.object({
-  published: z9.boolean(),
+var AutomationPublishResult = z10.object({
+  published: z10.boolean(),
   automation: Automation,
   /** Empty when nothing has to move; non-empty and `published` false asks for a confirmation. */
-  moves: z9.array(AutomationPublishMove),
+  moves: z10.array(AutomationPublishMove),
   /** How many people the backfill entered, or would enter when it is not confirmed. */
-  backfill: z9.number().int().min(0),
-  issues: z9.array(AutomationIssue)
-});
-var AutomationDuplicateRequest = z9.object({ name: z9.string().min(1).max(200).optional() }).strict();
-var AutomationEnrollRequest = z9.object({
-  contact_ids: z9.array(Id).min(1).max(1e3).optional(),
-  external_ids: z9.array(z9.string().min(1).max(255)).min(1).max(1e3).optional(),
-  emails: z9.array(Email).min(1).max(1e3).optional(),
+  backfill: z10.number().int().min(0),
+  issues: z10.array(AutomationIssue)
+});
+var AutomationDuplicateRequest = z10.object({ name: z10.string().min(1).max(200).optional() }).strict();
+var AutomationEnrollRequest = z10.object({
+  contact_ids: z10.array(Id).min(1).max(1e3).optional(),
+  external_ids: z10.array(z10.string().min(1).max(255)).min(1).max(1e3).optional(),
+  emails: z10.array(Email).min(1).max(1e3).optional(),
   segment_id: Id.optional(),
   /** Where to start them; the flow's entry step by default. */
   step_id: StepId.optional()
@@ -2418,34 +2623,34 @@ var AutomationEnrollRequest = z9.object({
   (v) => [v.contact_ids, v.external_ids, v.emails, v.segment_id].filter((x) => x !== void 0).length === 1,
   "name the people exactly one way: contact_ids, external_ids, emails or segment_id"
 );
-var AutomationEnrollment = z9.object({
+var AutomationEnrollment = z10.object({
   contact_id: Id.nullable(),
   email: Email.nullable(),
-  external_id: z9.string().nullable(),
-  entered: z9.boolean(),
+  external_id: z10.string().nullable(),
+  entered: z10.boolean(),
   run_id: Id.nullable(),
   reason: AutomationEntryRefusal.nullable()
 });
-var AutomationEnrollResult = z9.object({
-  entered: z9.number().int().min(0),
-  refused: z9.number().int().min(0),
-  results: z9.array(AutomationEnrollment)
+var AutomationEnrollResult = z10.object({
+  entered: z10.number().int().min(0),
+  refused: z10.number().int().min(0),
+  results: z10.array(AutomationEnrollment)
 });
-var AutomationRunStatus = z9.enum(["active", "waiting", "completed", "exited", "failed"]);
-var AutomationRun = z9.object({
+var AutomationRunStatus = z10.enum(["active", "waiting", "completed", "exited", "failed"]);
+var AutomationRun = z10.object({
   id: Id,
   automation_id: Id,
   contact_id: Id,
   email: Email,
-  external_id: z9.string().nullable(),
-  version: z9.number().int().min(1),
+  external_id: z10.string().nullable(),
+  version: z10.number().int().min(1),
   status: AutomationRunStatus,
   current_step_id: StepId.nullable(),
   next_action_at: Timestamp.nullable(),
   wait_reason: AutomationWaitReason.nullable(),
-  end_reason: z9.string().nullable(),
+  end_reason: z10.string().nullable(),
   /** What went wrong the last time this run tried to take its step, null otherwise. */
-  last_error: z9.string().nullable(),
+  last_error: z10.string().nullable(),
   entered_at: Timestamp,
   ended_at: Timestamp.nullable()
 });
@@ -2455,13 +2660,13 @@ var AutomationRunListQuery = PageQuery.extend({
   contact_id: Id.optional()
 });
 var ContactAutomationRun = AutomationRun.extend({
-  automation: z9.object({ id: Id, name: z9.string(), status: AutomationStatus })
+  automation: z10.object({ id: Id, name: z10.string(), status: AutomationStatus })
 });
 var ContactAutomationListQuery = PageQuery.extend({ status: AutomationRunStatus.optional() });
-var AutomationStepExecution = z9.object({
+var AutomationStepExecution = z10.object({
   step_id: StepId,
   step_kind: AutomationStepKind,
-  visit: z9.number().int().min(1),
+  visit: z10.number().int().min(1),
   started_at: Timestamp,
   finished_at: Timestamp.nullable(),
   /**
@@ -2473,48 +2678,48 @@ var AutomationStepExecution = z9.object({
    */
   outcome: Properties
 });
-var AutomationJourney = z9.object({
+var AutomationJourney = z10.object({
   run: AutomationRun,
-  steps: z9.array(AutomationStepExecution)
+  steps: z10.array(AutomationStepExecution)
 });
-var AutomationStepReport = z9.object({
+var AutomationStepReport = z10.object({
   step_id: StepId,
   step_kind: AutomationStepKind,
-  reached: z9.number().int().min(0),
-  waiting: z9.number().int().min(0),
-  passed: z9.number().int().min(0),
+  reached: z10.number().int().min(0),
+  waiting: z10.number().int().min(0),
+  passed: z10.number().int().min(0),
   /** Per branch, for a condition: how many took `yes` and how many `no`. */
-  branches: z9.record(z9.number().int().min(0)),
+  branches: z10.record(z10.number().int().min(0)),
   /** The step mailing's id, for an email step of the published version. */
   mailing_id: Id.nullable()
 });
-var AutomationReport = z9.object({
+var AutomationReport = z10.object({
   counts: AutomationCounts,
   /** Why the people who left did: `AutomationEndReason` to a count. */
-  end_reasons: z9.record(z9.number().int().min(0)),
+  end_reasons: z10.record(z10.number().int().min(0)),
   /**
    * Why people a trigger named did not enter: `AutomationEntryRefusal` to a
    * count. Without it a pause, an exclusion or a missing subscription would
    * turn people away invisibly.
    */
-  refusals: z9.record(z9.number().int().min(0)),
-  steps: z9.array(AutomationStepReport)
-});
-var AutomationExitRunRequest = z9.object({ reason: z9.string().max(200).optional() }).strict();
-var AutomationRunParams = z9.object({ id: Id, run_id: Id });
-var AutomationStepParams = z9.object({ id: Id, step_id: StepId });
-var AutomationTestEmailRequest = z9.object({ to: Email, merge: Properties.optional(), locale: LocaleTag.optional() }).strict();
-var AutomationValidateRequest = z9.object({ flow: AutomationFlow.optional(), settings: AutomationSettings.partial().optional() }).strict();
-var EventCreate = z9.object({
+  refusals: z10.record(z10.number().int().min(0)),
+  steps: z10.array(AutomationStepReport)
+});
+var AutomationExitRunRequest = z10.object({ reason: z10.string().max(200).optional() }).strict();
+var AutomationRunParams = z10.object({ id: Id, run_id: Id });
+var AutomationStepParams = z10.object({ id: Id, step_id: StepId });
+var AutomationTestEmailRequest = z10.object({ to: Email, merge: Properties.optional(), locale: LocaleTag.optional() }).strict();
+var AutomationValidateRequest = z10.object({ flow: AutomationFlow.optional(), settings: AutomationSettings.partial().optional() }).strict();
+var EventCreate = z10.object({
   name: EventName,
-  contact: z9.object({ external_id: z9.string().min(1).max(255).optional(), email: Email.optional(), id: Id.optional() }).refine((c) => [c.external_id, c.email, c.id].filter((x) => x !== void 0).length === 1, "name the contact exactly one way"),
+  contact: z10.object({ external_id: z10.string().min(1).max(255).optional(), email: Email.optional(), id: Id.optional() }).refine((c) => [c.external_id, c.email, c.id].filter((x) => x !== void 0).length === 1, "name the contact exactly one way"),
   data: Properties.optional(),
   occurred_at: Timestamp.optional(),
-  id: z9.string().min(1).max(128).optional()
+  id: z10.string().min(1).max(128).optional()
 }).strict();
-var Event = z9.object({
+var Event = z10.object({
   id: Id,
-  client_event_id: z9.string().nullable(),
+  client_event_id: z10.string().nullable(),
   name: EventName,
   contact_id: Id,
   data: Properties,
@@ -2525,7 +2730,7 @@ var Event = z9.object({
    * hand. Each is then admitted or refused by the runtime on its own rules
    * (consent, exclusions, re-entry), which `automations.report` counts.
    */
-  entered: z9.number().int().min(0)
+  entered: z10.number().int().min(0)
 });
 var EventListQuery = PageQuery.extend({
   name: EventName.optional(),
@@ -2533,19 +2738,15 @@ var EventListQuery = PageQuery.extend({
 });
 
 // src/workspace.ts
-var CompanyId = z10.string().min(1).max(64);
+var CompanyId = z11.string().min(1).max(64);
 var ASSET_POLICIES = ["any", "service_only"];
-var AssetPolicy = z10.enum(ASSET_POLICIES);
+var AssetPolicy = z11.enum(ASSET_POLICIES);
 var MAX_ALLOWED_ASSET_HOSTS = 20;
-var AssetHost = z10.string().trim().toLowerCase().min(1).max(253).regex(/^(?=.{1,253}(?::\d{1,5})?$)[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?(\.[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)+(:\d{1,5})?$/, "a host name such as example.com");
-var MAX_MERGE_DEFAULTS = 50;
-var MAX_MERGE_DEFAULT_LENGTH = 2e3;
-var MergeFieldName = z10.string().regex(/^[a-z][a-z0-9_]*$/, "a merge-field name: lowercase letters, digits and underscores, starting with a letter").max(64);
-var MergeDefaultValue = z10.union([z10.string().max(MAX_MERGE_DEFAULT_LENGTH), z10.number().finite(), z10.boolean()]);
-var MergeDefaults = z10.record(MergeFieldName, MergeDefaultValue).refine((m) => Object.keys(m).length <= MAX_MERGE_DEFAULTS, `at most ${MAX_MERGE_DEFAULTS} merge defaults`).refine((m) => !Object.keys(m).some((k) => k in RESERVED_MERGE_FIELDS), {
+var AssetHost = z11.string().trim().toLowerCase().min(1).max(253).regex(/^(?=.{1,253}(?::\d{1,5})?$)[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?(\.[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)+(:\d{1,5})?$/, "a host name such as example.com");
+var MergeDefaults = z11.record(MergeFieldName, MergeDefaultValue).refine((m) => Object.keys(m).length <= MAX_MERGE_DEFAULTS, `at most ${MAX_MERGE_DEFAULTS} merge defaults`).refine((m) => !Object.keys(m).some((k) => k in RESERVED_MERGE_FIELDS), {
   message: `a reserved merge field (${Object.keys(RESERVED_MERGE_FIELDS).join(", ")}) cannot have a workspace default`
 });
-var WorkspaceSettings = z10.object({
+var WorkspaceSettings = z11.object({
   /**
    * The workspace's main language (a {@link LocaleTag}, e.g. "de"): the main
    * language of a new template, and of the hosted pages when nothing else
@@ -2558,9 +2759,9 @@ var WorkspaceSettings = z10.object({
    * each; the hosted pages are offered in those of them they support (English,
    * German, French, Italian, Spanish). The service stores canonical casing.
    */
-  locales: z10.array(LocaleTag).min(1).max(20).refine((l) => new Set(l.map((t) => t.toLowerCase())).size === l.length, "a language appears twice"),
+  locales: z11.array(LocaleTag).min(1).max(20).refine((l) => new Set(l.map((t) => t.toLowerCase())).size === l.length, "a language appears twice"),
   /** Open and click tracking. Off by default, opt-in per workspace. */
-  tracking_enabled: z10.boolean(),
+  tracking_enabled: z11.boolean(),
   /** Where images, stylesheets and fonts in a mail may load from. `any` by default. */
   asset_policy: AssetPolicy,
   /**
@@ -2568,7 +2769,7 @@ var WorkspaceSettings = z10.object({
    * the workspace's website, typically. Empty by default. Ignored under `any`,
    * which allows everything already.
    */
-  allowed_asset_hosts: z10.array(AssetHost).max(MAX_ALLOWED_ASSET_HOSTS),
+  allowed_asset_hosts: z11.array(AssetHost).max(MAX_ALLOWED_ASSET_HOSTS),
   /** Merge values every mail of the workspace can use (see `MergeDefaults`). Empty by default. */
   merge_defaults: MergeDefaults,
   /**
@@ -2577,10 +2778,10 @@ var WorkspaceSettings = z10.object({
    */
   default_timezone: TimezoneName.nullable()
 });
-var Workspace = z10.object({
+var Workspace = z11.object({
   id: Id,
   slug: Slug,
-  name: z10.string().min(1).max(120),
+  name: z11.string().min(1).max(120),
   settings: WorkspaceSettings,
   /**
    * The auth-brain company (tenant) the workspace was created for, or null for
@@ -2591,13 +2792,13 @@ var Workspace = z10.object({
   created_at: Timestamp,
   updated_at: Timestamp
 });
-var WorkspaceCreate = z10.object({
+var WorkspaceCreate = z11.object({
   slug: Slug,
-  name: z10.string().min(1).max(120),
+  name: z11.string().min(1).max(120),
   settings: WorkspaceSettings.partial().optional(),
-  owner: z10.object({
+  owner: z11.object({
     email: Email,
-    name: z10.string().max(200).nullable().optional()
+    name: z11.string().max(200).nullable().optional()
   }),
   /**
    * The signed-in person's active auth-brain company. The dashboard always
@@ -2607,49 +2808,49 @@ var WorkspaceCreate = z10.object({
    */
   company_id: CompanyId.optional()
 });
-var WorkspaceUpdate = z10.object({
-  name: z10.string().min(1).max(120),
+var WorkspaceUpdate = z11.object({
+  name: z11.string().min(1).max(120),
   settings: WorkspaceSettings.partial()
 }).partial().refine((v) => Object.keys(v).length > 0, "at least one field");
-var WorkspaceMove = z10.object({ company_id: CompanyId });
+var WorkspaceMove = z11.object({ company_id: CompanyId });
 var MEMBER_ROLES = ["owner", "admin", "editor", "viewer"];
-var MemberRole = z10.enum(MEMBER_ROLES);
+var MemberRole = z11.enum(MEMBER_ROLES);
 var WorkspaceMembership = Workspace.extend({ role: MemberRole });
-var Member = z10.object({
+var Member = z11.object({
   id: Id,
   /** The person's auth-brain subject. */
-  subject: z10.string().min(1).max(255),
+  subject: z11.string().min(1).max(255),
   email: Email,
-  name: z10.string().max(200).nullable(),
+  name: z11.string().max(200).nullable(),
   role: MemberRole,
   created_at: Timestamp
 });
-var MemberCreate = z10.object({
-  subject: z10.string().min(1).max(255),
+var MemberCreate = z11.object({
+  subject: z11.string().min(1).max(255),
   email: Email,
-  name: z10.string().max(200).nullable().optional(),
+  name: z11.string().max(200).nullable().optional(),
   role: MemberRole
 });
-var MemberUpdate = z10.object({ role: MemberRole });
+var MemberUpdate = z11.object({ role: MemberRole });
 var API_KEY_SCOPES = ["full", "read", "send"];
-var ApiKeyScope = z10.enum(API_KEY_SCOPES);
-var ApiKey = z10.object({
+var ApiKeyScope = z11.enum(API_KEY_SCOPES);
+var ApiKey = z11.object({
   id: Id,
-  name: z10.string().min(1).max(120),
+  name: z11.string().min(1).max(120),
   /** The first characters of the key, for recognising it in a list. */
-  prefix: z10.string().min(4).max(32),
+  prefix: z11.string().min(4).max(32),
   scope: ApiKeyScope,
   last_used_at: Timestamp.nullable(),
   revoked_at: Timestamp.nullable(),
   created_at: Timestamp
 });
-var ApiKeyCreate = z10.object({
-  name: z10.string().min(1).max(120),
+var ApiKeyCreate = z11.object({
+  name: z11.string().min(1).max(120),
   /** Omitted means `full`. */
   scope: ApiKeyScope.optional()
 });
-var ApiKeyCreated = z10.object({
-  key: z10.string().min(20),
+var ApiKeyCreated = z11.object({
+  key: z11.string().min(20),
   api_key: ApiKey
 });
 var AUDIT_ACTIONS = [
@@ -2738,29 +2939,29 @@ var AUDIT_ACTIONS = [
   "automation.run_ended",
   "event.recorded"
 ];
-var AuditAction = z10.enum(AUDIT_ACTIONS);
-var AuditActor = z10.discriminatedUnion("type", [
-  z10.object({ type: z10.literal("member"), member_id: Id, subject: z10.string().min(1) }),
-  z10.object({
-    type: z10.literal("api_key"),
+var AuditAction = z11.enum(AUDIT_ACTIONS);
+var AuditActor = z11.discriminatedUnion("type", [
+  z11.object({ type: z11.literal("member"), member_id: Id, subject: z11.string().min(1) }),
+  z11.object({
+    type: z11.literal("api_key"),
     api_key_id: Id,
     /**
      * Who the client's application said it was acting for, from
      * `ON_BEHALF_OF_HEADER`: reported by that application, never verified.
      * Absent when the call carried no label.
      */
-    on_behalf_of: z10.string().min(1).max(ON_BEHALF_OF_MAX_LENGTH).optional()
+    on_behalf_of: z11.string().min(1).max(ON_BEHALF_OF_MAX_LENGTH).optional()
   }),
   /** The service itself (the worker, a bounce, the hosted unsubscribe page). */
-  z10.object({ type: z10.literal("system"), reason: z10.string().min(1).max(200) })
+  z11.object({ type: z11.literal("system"), reason: z11.string().min(1).max(200) })
 ]);
-var AuditEntry = z10.object({
+var AuditEntry = z11.object({
   id: Id,
   action: AuditAction,
   actor: AuditActor,
-  target_type: z10.string().min(1).max(64),
+  target_type: z11.string().min(1).max(64),
   target_id: Id.nullable(),
-  details: z10.record(z10.unknown()),
+  details: z11.record(z11.unknown()),
   created_at: Timestamp
 });
 var AuditQuery = PageQuery.extend({
@@ -2769,12 +2970,12 @@ var AuditQuery = PageQuery.extend({
 });
 
 // src/invites.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var INVITE_STATUSES = ["pending", "accepted", "revoked", "expired"];
-var InviteStatus = z11.enum(INVITE_STATUSES);
+var InviteStatus = z12.enum(INVITE_STATUSES);
 var DEFAULT_INVITE_TTL_DAYS = 7;
 var MAX_INVITE_TTL_DAYS = 30;
-var Invite = z11.object({
+var Invite = z12.object({
   id: Id,
   /** Stored lowercased; only a person signed in with this address can accept. */
   email: Email,
@@ -2782,32 +2983,32 @@ var Invite = z11.object({
   /** Derived from the timestamps below, never stored. */
   status: InviteStatus,
   /** The member who invited, while they are still one (null after they left). */
-  invited_by: z11.object({ member_id: Id.nullable(), email: Email.nullable() }),
+  invited_by: z12.object({ member_id: Id.nullable(), email: Email.nullable() }),
   expires_at: Timestamp,
   accepted_at: Timestamp.nullable(),
   revoked_at: Timestamp.nullable(),
   created_at: Timestamp
 });
-var InviteCreate = z11.object({
+var InviteCreate = z12.object({
   email: Email,
   role: MemberRole,
-  expires_in_days: z11.number().int().min(1).max(MAX_INVITE_TTL_DAYS).optional()
+  expires_in_days: z12.number().int().min(1).max(MAX_INVITE_TTL_DAYS).optional()
 });
-var InviteCreated = z11.object({
+var InviteCreated = z12.object({
   invite: Invite,
-  token: z11.string().min(32).max(128)
+  token: z12.string().min(32).max(128)
 });
 var InviteListQuery = PageQuery.extend({
   status: InviteStatus.optional()
 });
-var InviteAccept = z11.object({
-  token: z11.string().min(32).max(128),
+var InviteAccept = z12.object({
+  token: z12.string().min(32).max(128),
   email: Email,
-  name: z11.string().max(200).nullable().optional()
+  name: z12.string().max(200).nullable().optional()
 });
-var InviteAccepted = z11.object({
+var InviteAccepted = z12.object({
   workspace: WorkspaceMembership,
-  already_member: z11.boolean()
+  already_member: z12.boolean()
 });
 var INVITE_REFUSAL_REASONS = ["email_mismatch", "inviter_lacks_role", "expired", "revoked", "accepted"];
 
@@ -3437,13 +3638,13 @@ function renameInsertionEverywhere(drafts, from, rawTo) {
 }
 
 // src/providers.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 var PROVIDER_KINDS = ["smtp", "resend"];
-var ProviderKind = z12.enum(PROVIDER_KINDS);
-var ProviderPolicy = z12.object({
-  daily_recipient_budget: z12.number().int().min(1).max(1e7),
-  min_interval_ms: z12.number().int().min(0).max(36e5),
-  max_recipients_per_message: z12.number().int().min(1).max(1e3)
+var ProviderKind = z13.enum(PROVIDER_KINDS);
+var ProviderPolicy = z13.object({
+  daily_recipient_budget: z13.number().int().min(1).max(1e7),
+  min_interval_ms: z13.number().int().min(0).max(36e5),
+  max_recipients_per_message: z13.number().int().min(1).max(1e3)
 });
 var ICLOUD_SMTP_POLICY = {
   daily_recipient_budget: 800,
@@ -3451,17 +3652,17 @@ var ICLOUD_SMTP_POLICY = {
   max_recipients_per_message: 1
 };
 var SMTP_SECURITY = ["tls", "starttls"];
-var SmtpConfigBase = z12.object({
-  host: z12.string().min(1).max(255),
-  port: z12.number().int().min(1).max(65535),
+var SmtpConfigBase = z13.object({
+  host: z13.string().min(1).max(255),
+  port: z13.number().int().min(1).max(65535),
   /** `tls` connects encrypted (465), `starttls` upgrades (587). Never plaintext. */
-  security: z12.enum(SMTP_SECURITY),
-  username: z12.string().min(1).max(255)
+  security: z13.enum(SMTP_SECURITY),
+  username: z13.string().min(1).max(255)
 });
-var ResendConfigBase = z12.object({});
-var ProviderRejections = z12.object({
-  count: z12.number().int().min(0),
-  last_error: z12.string().nullable(),
+var ResendConfigBase = z13.object({});
+var ProviderRejections = z13.object({
+  count: z13.number().int().min(0),
+  last_error: z13.string().nullable(),
   last_at: Timestamp.nullable(),
   /**
    * The last time the bounce circuit breaker tripped on one of this provider's
@@ -3471,59 +3672,59 @@ var ProviderRejections = z12.object({
    * run's bounce blocks were undone and the mailing paused. `sample` is the
    * reply that tripped it.
    */
-  anomaly: z12.object({
+  anomaly: z13.object({
     at: Timestamp,
     /** `mailing`: one mailing was paused. `provider`: 5 refusals in a row with the same reply across the provider's sends (test sends and one-recipient mailings included) within 24 hours. */
-    scope: z12.enum(["mailing", "provider"]),
+    scope: z13.enum(["mailing", "provider"]),
     /**
      * True while the provider-wide breaker is open: no bounce blocks through
      * this provider, test sends refused and mailings not started or resumed
      * (`provider_anomaly`), until an admin clears it (`providers.clearAnomaly`).
      */
-    blocking: z12.boolean(),
+    blocking: z13.boolean(),
     mailing_id: Id.nullable(),
-    reason: z12.string(),
-    sample: z12.string()
+    reason: z13.string(),
+    sample: z13.string()
   }).nullable()
 });
-var ProviderEvents = z12.object({
-  status: z12.enum(["active", "needs_secret"]),
-  source: z12.enum(["automatic", "manual"]).nullable(),
-  url: z12.string().url(),
-  error: z12.string().nullable(),
+var ProviderEvents = z13.object({
+  status: z13.enum(["active", "needs_secret"]),
+  source: z13.enum(["automatic", "manual"]).nullable(),
+  url: z13.string().url(),
+  error: z13.string().nullable(),
   /**
    * Events that named an email this provider never sent through the service
    * (another workspace or system sharing the Resend account): counted, never
    * acted on.
    */
-  unmatched: z12.number().int().min(0)
+  unmatched: z13.number().int().min(0)
 });
 var RESEND_EVENT_TYPES = ["email.bounced", "email.complained", "email.delivery_delayed"];
-var ResendSigningSecret = z12.string().max(200).regex(/^whsec_[A-Za-z0-9+/]{16,}={0,2}$/, "must be the signing secret Resend shows, starting with whsec_");
-var ProviderEventsSecret = z12.object({ signing_secret: ResendSigningSecret });
+var ResendSigningSecret = z13.string().max(200).regex(/^whsec_[A-Za-z0-9+/]{16,}={0,2}$/, "must be the signing secret Resend shows, starting with whsec_");
+var ProviderEventsSecret = z13.object({ signing_secret: ResendSigningSecret });
 var ProviderFields = {
-  name: z12.string().min(1).max(120),
-  from_name: z12.string().min(1).max(120),
+  name: z13.string().min(1).max(120),
+  from_name: z13.string().min(1).max(120),
   from_email: Email,
   reply_to: Email.nullable(),
   policy: ProviderPolicy
 };
-var Provider = z12.discriminatedUnion("kind", [
-  z12.object({
+var Provider = z13.discriminatedUnion("kind", [
+  z13.object({
     id: Id,
-    kind: z12.literal("smtp"),
+    kind: z13.literal("smtp"),
     config: SmtpConfigBase,
-    has_secret: z12.boolean(),
+    has_secret: z13.boolean(),
     ...ProviderFields,
     rejections: ProviderRejections,
     created_at: Timestamp,
     updated_at: Timestamp
   }),
-  z12.object({
+  z13.object({
     id: Id,
-    kind: z12.literal("resend"),
+    kind: z13.literal("resend"),
     config: ResendConfigBase,
-    has_secret: z12.boolean(),
+    has_secret: z13.boolean(),
     ...ProviderFields,
     rejections: ProviderRejections,
     events: ProviderEvents,
@@ -3531,31 +3732,31 @@ var Provider = z12.discriminatedUnion("kind", [
     updated_at: Timestamp
   })
 ]);
-var ProviderCreate = z12.discriminatedUnion("kind", [
-  z12.object({
-    kind: z12.literal("smtp"),
-    config: SmtpConfigBase.extend({ password: z12.string().min(1).max(1024) }),
+var ProviderCreate = z13.discriminatedUnion("kind", [
+  z13.object({
+    kind: z13.literal("smtp"),
+    config: SmtpConfigBase.extend({ password: z13.string().min(1).max(1024) }),
     ...ProviderFields
   }),
-  z12.object({
-    kind: z12.literal("resend"),
-    config: ResendConfigBase.extend({ api_key: z12.string().min(1).max(1024) }),
+  z13.object({
+    kind: z13.literal("resend"),
+    config: ResendConfigBase.extend({ api_key: z13.string().min(1).max(1024) }),
     ...ProviderFields
   })
 ]);
-var ProviderUpdate = z12.discriminatedUnion("kind", [
-  z12.object({
-    kind: z12.literal("smtp"),
-    config: SmtpConfigBase.extend({ password: z12.string().min(1).max(1024).optional() }).partial().optional(),
+var ProviderUpdate = z13.discriminatedUnion("kind", [
+  z13.object({
+    kind: z13.literal("smtp"),
+    config: SmtpConfigBase.extend({ password: z13.string().min(1).max(1024).optional() }).partial().optional(),
     name: ProviderFields.name.optional(),
     from_name: ProviderFields.from_name.optional(),
     from_email: ProviderFields.from_email.optional(),
     reply_to: ProviderFields.reply_to.optional(),
     policy: ProviderPolicy.partial().optional()
   }),
-  z12.object({
-    kind: z12.literal("resend"),
-    config: ResendConfigBase.extend({ api_key: z12.string().min(1).max(1024).optional() }).optional(),
+  z13.object({
+    kind: z13.literal("resend"),
+    config: ResendConfigBase.extend({ api_key: z13.string().min(1).max(1024).optional() }).optional(),
     name: ProviderFields.name.optional(),
     from_name: ProviderFields.from_name.optional(),
     from_email: ProviderFields.from_email.optional(),
@@ -3563,48 +3764,48 @@ var ProviderUpdate = z12.discriminatedUnion("kind", [
     policy: ProviderPolicy.partial().optional()
   })
 ]);
-var ProviderUsage = z12.object({
+var ProviderUsage = z13.object({
   provider_id: Id,
-  recipients_last_24h: z12.number().int().min(0),
-  remaining_budget: z12.number().int().min(0),
+  recipients_last_24h: z13.number().int().min(0),
+  remaining_budget: z13.number().int().min(0),
   /** When enough of the rolling window frees up to send again, if exhausted. */
   next_capacity_at: Timestamp.nullable()
 });
-var ProviderVerifyResult = z12.object({
-  ok: z12.boolean(),
-  error: z12.string().nullable()
+var ProviderVerifyResult = z13.object({
+  ok: z13.boolean(),
+  error: z13.string().nullable()
 });
 
 // src/contacts.ts
-import { z as z13 } from "zod";
-var Topic = z13.object({
+import { z as z14 } from "zod";
+var Topic = z14.object({
   id: Id,
   slug: Slug,
-  name: z13.string().min(1).max(120),
+  name: z14.string().min(1).max(120),
   /** Shown on the hosted preference page. */
-  description: z13.string().max(1e3).nullable(),
+  description: z14.string().max(1e3).nullable(),
   /** Translations of `name` and `description` per locale, for the hosted page. */
-  translations: z13.record(
-    z13.object({ name: z13.string().min(1).max(120), description: z13.string().max(1e3).nullable() })
+  translations: z14.record(
+    z14.object({ name: z14.string().min(1).max(120), description: z14.string().max(1e3).nullable() })
   ),
   created_at: Timestamp,
   updated_at: Timestamp
 });
-var TopicCreate = z13.object({
+var TopicCreate = z14.object({
   slug: Slug,
-  name: z13.string().min(1).max(120),
-  description: z13.string().max(1e3).optional(),
+  name: z14.string().min(1).max(120),
+  description: z14.string().max(1e3).optional(),
   translations: Topic.shape.translations.optional()
 });
 var TopicUpdate = TopicCreate.omit({ slug: true }).partial().refine((v) => Object.keys(v).length > 0, "at least one field");
-var Contact = z13.object({
+var Contact = z14.object({
   id: Id,
-  external_id: z13.string().min(1).max(255).nullable(),
+  external_id: z14.string().min(1).max(255).nullable(),
   /** Stored lowercased, unique per workspace. */
   email: Email,
-  first_name: z13.string().max(200).nullable(),
-  last_name: z13.string().max(200).nullable(),
-  locale: z13.string().min(2).max(35).nullable(),
+  first_name: z14.string().max(200).nullable(),
+  last_name: z14.string().max(200).nullable(),
+  locale: z14.string().min(2).max(35).nullable(),
   /**
    * The person's own time zone, an IANA name such as `Europe/Berlin` (A1).
    * Every wall clock an automation waits for is read in it, falling back to the
@@ -3612,65 +3813,65 @@ var Contact = z13.object({
    */
   timezone: TimezoneName.nullable(),
   properties: Properties,
-  topics: z13.array(Slug),
+  topics: z14.array(Slug),
   /** The slugs of the contact's tags (S4). */
-  tags: z13.array(Slug),
+  tags: z14.array(Slug),
   created_at: Timestamp,
   updated_at: Timestamp
 });
-var ContactUpsert = z13.object({
-  external_id: z13.string().min(1).max(255).optional(),
+var ContactUpsert = z14.object({
+  external_id: z14.string().min(1).max(255).optional(),
   email: Email.optional(),
-  first_name: z13.string().max(200).nullable().optional(),
-  last_name: z13.string().max(200).nullable().optional(),
-  locale: z13.string().min(2).max(35).nullable().optional(),
+  first_name: z14.string().max(200).nullable().optional(),
+  last_name: z14.string().max(200).nullable().optional(),
+  locale: z14.string().min(2).max(35).nullable().optional(),
   timezone: TimezoneName.nullable().optional(),
   properties: Properties.optional(),
-  topics: z13.array(Slug).max(100).optional()
+  topics: z14.array(Slug).max(100).optional()
 }).refine((v) => v.external_id !== void 0 || v.email !== void 0, {
   message: "external_id or email is required",
   path: ["email"]
 });
-var ContactUpsertResult = z13.object({
+var ContactUpsertResult = z14.object({
   contact: Contact,
-  created: z13.boolean()
+  created: z14.boolean()
 });
 var ContactListQuery = PageQuery.extend({
-  email: z13.string().min(1).max(254).optional(),
-  external_id: z13.string().min(1).max(255).optional(),
+  email: z14.string().min(1).max(254).optional(),
+  external_id: z14.string().min(1).max(255).optional(),
   topic: Slug.optional()
 });
-var ContactErased = z13.object({
-  ok: z13.literal(true),
-  erased_messages: z13.number().int().min(0),
-  erased_recipients: z13.number().int().min(0),
-  suppressions_kept: z13.number().int().min(0)
+var ContactErased = z14.object({
+  ok: z14.literal(true),
+  erased_messages: z14.number().int().min(0),
+  erased_recipients: z14.number().int().min(0),
+  suppressions_kept: z14.number().int().min(0)
 });
 var SUPPRESSION_REASONS = ["unsubscribed", "bounced", "complained", "manual"];
-var SuppressionReason = z13.enum(SUPPRESSION_REASONS);
-var Suppression = z13.object({
+var SuppressionReason = z14.enum(SUPPRESSION_REASONS);
+var Suppression = z14.object({
   id: Id,
   email: Email,
   reason: SuppressionReason,
   topic: Slug.nullable(),
   source_message_id: Id.nullable(),
-  note: z13.string().max(1e3).nullable(),
+  note: z14.string().max(1e3).nullable(),
   created_at: Timestamp
 });
-var SuppressionCreate = z13.object({
+var SuppressionCreate = z14.object({
   email: Email,
-  reason: z13.enum(["manual", "unsubscribed"]),
+  reason: z14.enum(["manual", "unsubscribed"]),
   topic: Slug.nullable().optional(),
-  note: z13.string().max(1e3).optional()
+  note: z14.string().max(1e3).optional()
 });
 var SuppressionListQuery = PageQuery.extend({
-  email: z13.string().min(1).max(254).optional(),
+  email: z14.string().min(1).max(254).optional(),
   reason: SuppressionReason.optional(),
   topic: Slug.optional()
 });
 
 // src/webhooks.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 var WEBHOOK_EVENT_TYPES = [
   "message.sent",
   "message.failed",
@@ -3714,23 +3915,23 @@ var WEBHOOK_EVENT_TYPES = [
   "template.updated",
   "template.deleted"
 ];
-var WebhookEventType = z14.enum(WEBHOOK_EVENT_TYPES);
-var MessageEventBase = z14.object({
+var WebhookEventType = z15.enum(WEBHOOK_EVENT_TYPES);
+var MessageEventBase = z15.object({
   message_id: Id,
   mailing_id: Id.nullable(),
   mailing_metadata: MailingMetadata.nullable(),
   recipient_id: Id.nullable(),
   contact_id: Id.nullable(),
-  external_id: z14.string().nullable(),
+  external_id: z15.string().nullable(),
   email: Email,
-  subject: z14.string(),
+  subject: z15.string(),
   topic: Slug.nullable(),
-  provider_message_id: z14.string().nullable(),
-  is_test: z14.boolean()
+  provider_message_id: z15.string().nullable(),
+  is_test: z15.boolean()
 });
 var MessageSentData = MessageEventBase.extend({
   /** The final HTML as sent, so the client can archive it beside its own records. */
-  html: z14.string(),
+  html: z15.string(),
   sent_at: Timestamp,
   /**
    * The choice each insertion made (see `Message.insertions`); absent or null
@@ -3741,20 +3942,20 @@ var MessageSentData = MessageEventBase.extend({
   insertions: InsertionChoices.nullish()
 });
 var MessageFailedData = MessageEventBase.extend({
-  error: z14.string(),
+  error: z15.string(),
   /** False when the provider rejected permanently; the recipient will not be retried. */
-  retryable: z14.boolean(),
+  retryable: z15.boolean(),
   failed_at: Timestamp
 });
 var UNSUBSCRIBE_SOURCES = ["hosted_page", "one_click", "api", "dashboard", "signup_form"];
-var ContactUnsubscribedData = z14.object({
+var ContactUnsubscribedData = z15.object({
   contact_id: Id.nullable(),
-  external_id: z14.string().nullable(),
+  external_id: z15.string().nullable(),
   email: Email,
   /** The topic unsubscribed from; null means every topic. */
   topic: Slug.nullable(),
   mailing_id: Id.nullable(),
-  source: z14.enum(UNSUBSCRIBE_SOURCES),
+  source: z15.enum(UNSUBSCRIBE_SOURCES),
   unsubscribed_at: Timestamp
 });
 var ContactResubscribedData = ContactUnsubscribedData.omit({ unsubscribed_at: true }).extend({
@@ -3763,142 +3964,142 @@ var ContactResubscribedData = ContactUnsubscribedData.omit({ unsubscribed_at: tr
    * breaker undid a `bounced` block it judged false (a `contact.bounced` for the
    * same address and mailing went out before); `topic` is null.
    */
-  source: z14.enum([...UNSUBSCRIBE_SOURCES, "bounce_reverted"]),
+  source: z15.enum([...UNSUBSCRIBE_SOURCES, "bounce_reverted"]),
   resubscribed_at: Timestamp
 });
-var ContactBouncedData = z14.object({
+var ContactBouncedData = z15.object({
   contact_id: Id.nullable(),
-  external_id: z14.string().nullable(),
+  external_id: z15.string().nullable(),
   email: Email,
   /** `bounced` for a hard bounce, `complained` for a spam complaint. */
-  reason: z14.enum(["bounced", "complained"]),
+  reason: z15.enum(["bounced", "complained"]),
   message_id: Id.nullable(),
-  diagnostic: z14.string().nullable(),
+  diagnostic: z15.string().nullable(),
   bounced_at: Timestamp
 });
-var MailingFinishedData = z14.object({
+var MailingFinishedData = z15.object({
   mailing_id: Id,
   mailing_metadata: MailingMetadata,
-  status: z14.enum(["sent", "partially_failed", "cancelled"]),
+  status: z15.enum(["sent", "partially_failed", "cancelled"]),
   counts: MailingCounts,
   finished_at: Timestamp
 });
-var ContactSubscribedData = z14.object({
+var ContactSubscribedData = z15.object({
   contact_id: Id,
-  external_id: z14.string().nullable(),
+  external_id: z15.string().nullable(),
   email: Email,
-  topics: z14.array(Slug),
-  source: z14.enum(["signup_form", "api", "dashboard", "automation"]),
+  topics: z15.array(Slug),
+  source: z15.enum(["signup_form", "api", "dashboard", "automation"]),
   signup_form_id: Id.nullable(),
-  signup_form_version: z14.number().int().min(1).nullable(),
+  signup_form_version: z15.number().int().min(1).nullable(),
   subscribed_at: Timestamp
 });
-var ImportFinishedData = z14.object({
+var ImportFinishedData = z15.object({
   import_id: Id,
-  status: z14.enum(["completed", "cancelled", "failed"]),
+  status: z15.enum(["completed", "cancelled", "failed"]),
   result: ImportReport.nullable(),
-  error: z14.string().nullable(),
+  error: z15.string().nullable(),
   finished_at: Timestamp
 });
-var MailingScheduledData = z14.object({
+var MailingScheduledData = z15.object({
   mailing_id: Id,
   mailing_metadata: MailingMetadata,
   scheduled_at: Timestamp.nullable()
 });
-var MailingStartedData = z14.object({
+var MailingStartedData = z15.object({
   mailing_id: Id,
   mailing_metadata: MailingMetadata,
-  trigger: z14.enum(["send", "schedule"]),
-  recipients: z14.number().int().min(0),
+  trigger: z15.enum(["send", "schedule"]),
+  recipients: z15.number().int().min(0),
   started_at: Timestamp
 });
-var MailingScheduleFailedData = z14.object({
+var MailingScheduleFailedData = z15.object({
   mailing_id: Id,
   mailing_metadata: MailingMetadata,
-  code: z14.string(),
-  message: z14.string(),
+  code: z15.string(),
+  message: z15.string(),
   failed_at: Timestamp
 });
-var MailingAbWinnerSelectedData = z14.object({
+var MailingAbWinnerSelectedData = z15.object({
   mailing_id: Id,
   mailing_metadata: MailingMetadata,
-  winner: z14.string(),
-  decided_by: z14.enum(["metric", "manual"]),
-  variants: z14.array(VariantAnalytics),
+  winner: z15.string(),
+  decided_by: z15.enum(["metric", "manual"]),
+  variants: z15.array(VariantAnalytics),
   decided_at: Timestamp
 });
-var ContactTaggedData = z14.object({
+var ContactTaggedData = z15.object({
   contact_id: Id,
-  external_id: z14.string().nullable(),
+  external_id: z15.string().nullable(),
   email: Email,
   /** Only the tags the contact did not already have. */
-  tags: z14.array(Slug).min(1),
-  source: z14.enum(["api", "dashboard", "signup_form", "import", "automation"]),
+  tags: z15.array(Slug).min(1),
+  source: z15.enum(["api", "dashboard", "signup_form", "import", "automation"]),
   tagged_at: Timestamp
 });
-var ContactUpdatedData = z14.object({
+var ContactUpdatedData = z15.object({
   contact_id: Id,
-  external_id: z14.string().nullable(),
+  external_id: z15.string().nullable(),
   email: Email,
-  changed: z14.array(z14.string()).min(1),
+  changed: z15.array(z15.string()).min(1),
   properties: Properties,
-  source: z14.enum(["api", "dashboard", "signup_form", "import", "automation"]),
+  source: z15.enum(["api", "dashboard", "signup_form", "import", "automation"]),
   updated_at: Timestamp
 });
-var AutomationRunEventBase = z14.object({
+var AutomationRunEventBase = z15.object({
   automation_id: Id,
-  automation_name: z14.string(),
+  automation_name: z15.string(),
   run_id: Id,
-  version: z14.number().int().min(1),
+  version: z15.number().int().min(1),
   contact_id: Id,
-  external_id: z14.string().nullable(),
+  external_id: z15.string().nullable(),
   email: Email
 });
 var AutomationRunStartedData = AutomationRunEventBase.extend({
   /** What let them in: a trigger kind, or `manual` for an explicit enrolment. */
-  trigger_kind: z14.string(),
+  trigger_kind: z15.string(),
   entered_at: Timestamp
 });
 var AutomationRunCompletedData = AutomationRunEventBase.extend({
-  last_step_id: z14.string().nullable(),
+  last_step_id: z15.string().nullable(),
   completed_at: Timestamp
 });
 var AutomationRunExitedData = AutomationRunEventBase.extend({
   reason: AutomationEndReason,
-  step_id: z14.string().nullable(),
+  step_id: z15.string().nullable(),
   exited_at: Timestamp
 });
 var AutomationRunFailedData = AutomationRunEventBase.extend({
-  reason: z14.string(),
-  step_id: z14.string().nullable(),
+  reason: z15.string(),
+  step_id: z15.string().nullable(),
   failed_at: Timestamp
 });
 var AutomationWebhookData = AutomationRunEventBase.extend({
-  step_id: z14.string(),
+  step_id: z15.string(),
   /** The step's own label, when it was given one, so a receiver can branch on a name. */
-  step_label: z14.string().nullable(),
+  step_label: z15.string().nullable(),
   /** Whatever the step carries, verbatim. Null when it carries nothing. */
   payload: JsonValue.nullable(),
   fired_at: Timestamp
 });
-var TemplateEventBase = z14.object({
+var TemplateEventBase = z15.object({
   template_id: Id,
-  name: z14.string().min(1).max(200),
-  version: z14.number().int().min(1),
-  source: z14.enum(["api", "dashboard", "mjml_import"])
+  name: z15.string().min(1).max(200),
+  version: z15.number().int().min(1),
+  source: z15.enum(["api", "dashboard", "mjml_import"])
 });
 var TemplateCreatedData = TemplateEventBase.extend({ created_at: Timestamp });
-var TemplateUpdatedData = TemplateEventBase.extend({ archived: z14.boolean(), updated_at: Timestamp });
+var TemplateUpdatedData = TemplateEventBase.extend({ archived: z15.boolean(), updated_at: Timestamp });
 var TemplateDeletedData = TemplateEventBase.extend({ deleted_at: Timestamp });
-var envelope = (type, data) => z14.object({
+var envelope = (type, data) => z15.object({
   /** Unique per event: a receiver deduplicates on it (deliveries may repeat). */
   id: Id,
-  type: z14.literal(type),
+  type: z15.literal(type),
   created_at: Timestamp,
   workspace_id: Id,
   data
 });
-var WebhookEvent = z14.discriminatedUnion("type", [
+var WebhookEvent = z15.discriminatedUnion("type", [
   envelope("message.sent", MessageSentData),
   envelope("message.failed", MessageFailedData),
   envelope("contact.unsubscribed", ContactUnsubscribedData),
@@ -3922,16 +4123,16 @@ var WebhookEvent = z14.discriminatedUnion("type", [
   envelope("template.updated", TemplateUpdatedData),
   envelope("template.deleted", TemplateDeletedData)
 ]);
-var WebhookEndpoint = z14.object({
+var WebhookEndpoint = z15.object({
   id: Id,
-  url: z14.string().url(),
-  description: z14.string().max(500).nullable(),
-  events: z14.array(WebhookEventType).min(1),
-  enabled: z14.boolean(),
+  url: z15.string().url(),
+  description: z15.string().max(500).nullable(),
+  events: z15.array(WebhookEventType).min(1),
+  enabled: z15.boolean(),
   created_at: Timestamp,
   updated_at: Timestamp
 });
-var WebhookUrl = z14.string().url().refine((u) => {
+var WebhookUrl = z15.string().url().refine((u) => {
   try {
     const url = new URL(u);
     if (url.protocol === "https:") return true;
@@ -3940,35 +4141,35 @@ var WebhookUrl = z14.string().url().refine((u) => {
     return false;
   }
 }, "must be https (http only for localhost)");
-var WebhookEndpointCreate = z14.object({
+var WebhookEndpointCreate = z15.object({
   url: WebhookUrl,
-  description: z14.string().max(500).optional(),
-  events: z14.array(WebhookEventType).min(1),
-  enabled: z14.boolean().optional()
+  description: z15.string().max(500).optional(),
+  events: z15.array(WebhookEventType).min(1),
+  enabled: z15.boolean().optional()
 });
-var WebhookEndpointUpdate = z14.object({
+var WebhookEndpointUpdate = z15.object({
   url: WebhookUrl,
-  description: z14.string().max(500).nullable(),
-  events: z14.array(WebhookEventType).min(1),
-  enabled: z14.boolean()
+  description: z15.string().max(500).nullable(),
+  events: z15.array(WebhookEventType).min(1),
+  enabled: z15.boolean()
 }).partial().refine((v) => Object.keys(v).length > 0, "at least one field");
-var WebhookEndpointWithSecret = z14.object({
+var WebhookEndpointWithSecret = z15.object({
   endpoint: WebhookEndpoint,
-  secret: z14.string().min(32)
+  secret: z15.string().min(32)
 });
 var WEBHOOK_DELIVERY_STATUSES = ["pending", "succeeded", "failed"];
-var WebhookDeliveryStatus = z14.enum(WEBHOOK_DELIVERY_STATUSES);
+var WebhookDeliveryStatus = z15.enum(WEBHOOK_DELIVERY_STATUSES);
 var WEBHOOK_MAX_ATTEMPTS = 8;
 var WEBHOOK_RETRY_DELAYS_SECONDS = [30, 120, 600, 1800, 3600, 7200, 21600];
-var WebhookDelivery = z14.object({
+var WebhookDelivery = z15.object({
   id: Id,
   endpoint_id: Id,
   event_id: Id,
   event_type: WebhookEventType,
   status: WebhookDeliveryStatus,
-  attempts: z14.number().int().min(0),
-  last_status_code: z14.number().int().min(100).max(599).nullable(),
-  last_error: z14.string().nullable(),
+  attempts: z15.number().int().min(0),
+  last_status_code: z15.number().int().min(100).max(599).nullable(),
+  last_error: z15.string().nullable(),
   next_attempt_at: Timestamp.nullable(),
   delivered_at: Timestamp.nullable(),
   created_at: Timestamp
@@ -3977,7 +4178,7 @@ var WebhookDeliveryListQuery = PageQuery.extend({
   status: WebhookDeliveryStatus.optional(),
   event_type: WebhookEventType.optional()
 });
-var WebhookDeliveryParams = z14.object({ id: Id, delivery_id: Id });
+var WebhookDeliveryParams = z15.object({ id: Id, delivery_id: Id });
 
 // src/webhook-signing.ts
 var WEBHOOK_SIGNATURE_HEADER = "x-mail-signature";
@@ -4044,79 +4245,79 @@ async function verifyWebhook(input) {
 }
 
 // src/billing.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 var PLAN_IDS = ["free", "starter", "growth", "design_partner"];
-var PlanId = z15.enum(PLAN_IDS);
-var PlanLimits = z15.object({
-  monthly_messages: z15.number().int().min(0).nullable(),
-  contacts: z15.number().int().min(0).nullable(),
-  members: z15.number().int().min(1).nullable(),
-  providers: z15.number().int().min(1).nullable(),
-  webhook_endpoints: z15.number().int().min(0).nullable(),
+var PlanId = z16.enum(PLAN_IDS);
+var PlanLimits = z16.object({
+  monthly_messages: z16.number().int().min(0).nullable(),
+  contacts: z16.number().int().min(0).nullable(),
+  members: z16.number().int().min(1).nullable(),
+  providers: z16.number().int().min(1).nullable(),
+  webhook_endpoints: z16.number().int().min(0).nullable(),
   /** Automations that may be live (active or paused) at once (A1). */
-  active_automations: z15.number().int().min(0).nullable(),
+  active_automations: z16.number().int().min(0).nullable(),
   /** Steps one automation may hold. Null is the flow's own cap, not unlimited. */
-  automation_steps: z15.number().int().min(1).nullable()
+  automation_steps: z16.number().int().min(1).nullable()
 });
-var PlanFeatures = z15.object({
+var PlanFeatures = z16.object({
   /** A/B tests of subject and content on a mailing (S4). */
-  ab_testing: z15.boolean(),
+  ab_testing: z16.boolean(),
   /** Open and click tracking, still off until a workspace turns it on (`settings.tracking_enabled`). */
-  tracking: z15.boolean(),
+  tracking: z16.boolean(),
   /** Sending and hosting pages on the workspace's own domain (a later phase). */
-  custom_domains: z15.boolean(),
+  custom_domains: z16.boolean(),
   /** Automations: flows a person walks through step by step (A1). */
-  automations: z15.boolean()
+  automations: z16.boolean()
 });
 var PLAN_FEATURES = ["ab_testing", "tracking", "custom_domains", "automations"];
-var Plan = z15.object({
+var Plan = z16.object({
   id: PlanId,
-  name: z15.string().min(1),
+  name: z16.string().min(1),
   /** Price in the smallest currency unit per month; null for plans not sold. */
-  monthly_price_cents: z15.number().int().min(0).nullable(),
-  currency: z15.string().length(3),
+  monthly_price_cents: z16.number().int().min(0).nullable(),
+  currency: z16.string().length(3),
   limits: PlanLimits,
   features: PlanFeatures
 });
-var CatalogPlan = Plan.extend({ sellable: z15.boolean() });
-var Subscription = z15.object({
+var CatalogPlan = Plan.extend({ sellable: z16.boolean() });
+var Subscription = z16.object({
   workspace_id: Id,
   plan: PlanId,
-  status: z15.enum(["active", "trialing", "past_due", "cancelled"]),
+  status: z16.enum(["active", "trialing", "past_due", "cancelled"]),
   current_period_start: Timestamp,
   current_period_end: Timestamp,
-  cancel_at_period_end: z15.boolean(),
+  cancel_at_period_end: z16.boolean(),
   /**
    * A design partner outside billing (plan `design_partner`, no limits, no
    * checkout). Set only by an operator, never through the API.
    */
-  billing_exempt: z15.boolean()
+  billing_exempt: z16.boolean()
 });
 var USAGE_METRICS = ["messages", "contacts", "members", "providers", "webhook_endpoints", "active_automations"];
-var UsageMetric = z15.enum(USAGE_METRICS);
+var UsageMetric = z16.enum(USAGE_METRICS);
 var USAGE_WARNING_RATIO = 0.8;
-var UsageWarning = z15.object({
+var UsageWarning = z16.object({
   metric: UsageMetric,
-  used: z15.number().int().min(0),
-  limit: z15.number().int().min(0),
+  used: z16.number().int().min(0),
+  limit: z16.number().int().min(0),
   /** `approaching`: at or above USAGE_WARNING_RATIO of the limit; `reached`: at or above the limit. */
-  level: z15.enum(["approaching", "reached"])
+  level: z16.enum(["approaching", "reached"])
 });
-var Usage = z15.object({
+var Usage = z16.object({
   plan: PlanId,
   period_start: Timestamp,
   period_end: Timestamp,
-  metrics: z15.record(UsageMetric, z15.object({ used: z15.number().int().min(0), limit: z15.number().int().min(0).nullable() })),
-  warnings: z15.array(UsageWarning)
+  metrics: z16.record(UsageMetric, z16.object({ used: z16.number().int().min(0), limit: z16.number().int().min(0).nullable() })),
+  warnings: z16.array(UsageWarning)
 });
-var CheckoutRequest = z15.object({
-  plan: z15.enum(["starter", "growth"]),
-  success_url: z15.string().url(),
-  cancel_url: z15.string().url()
+var CheckoutRequest = z16.object({
+  plan: z16.enum(["starter", "growth"]),
+  success_url: z16.string().url(),
+  cancel_url: z16.string().url()
 });
-var CheckoutSession = z15.object({ url: z15.string().url() });
-var PortalRequest = z15.object({ return_url: z15.string().url() });
-var PortalSession = z15.object({ url: z15.string().url() });
+var CheckoutSession = z16.object({ url: z16.string().url() });
+var PortalRequest = z16.object({ return_url: z16.string().url() });
+var PortalSession = z16.object({ url: z16.string().url() });
 var USAGE_WARNING_HEADER = "x-mail-usage-warning";
 function formatUsageWarningHeader(warnings) {
   if (warnings.length === 0) return null;
@@ -4136,7 +4337,7 @@ function parseUsageWarningHeader(value) {
 }
 
 // src/routes.ts
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 var list = (item) => page(item);
 var foundationRoutes = {
   "workspaces.create": {
@@ -4364,7 +4565,7 @@ var templateRoutes = {
     path: "/v1/templates/:id/export",
     params: IdParams,
     query: TemplateExportQuery,
-    response: z16.string(),
+    response: z17.string(),
     responseType: "text",
     status: 200,
     access: "read",
@@ -4688,7 +4889,7 @@ var sendingRoutes = {
     path: "/v1/mailings/:id/export",
     params: IdParams,
     query: MailingExportQuery,
-    response: z16.string(),
+    response: z17.string(),
     responseType: "text",
     status: 200,
     access: "read",
@@ -4734,6 +4935,21 @@ var sendingRoutes = {
     access: "write",
     phase: "S2"
   },
+  /**
+   * A dry run: what each given recipient would be sent (every value's text and
+   * the layer it comes from, each insertion's choice, the problems found),
+   * without adding anybody. Reads only, in any state of the mailing.
+   */
+  "mailings.resolve": {
+    method: "POST",
+    path: "/v1/mailings/:id/resolve",
+    params: IdParams,
+    body: MailingResolveRequest,
+    response: MailingResolveResult,
+    status: 200,
+    access: "read",
+    phase: "S2"
+  },
   "mailings.send": {
     method: "POST",
     path: "/v1/mailings/:id/send",
@@ -4921,7 +5137,7 @@ var platformRoutes = {
   "contactProperties.list": {
     method: "GET",
     path: "/v1/contact-properties",
-    response: z16.object({ data: z16.array(ContactPropertyDefinition) }),
+    response: z17.object({ data: z17.array(ContactPropertyDefinition) }),
     status: 200,
     access: "read",
     phase: "S4"
@@ -5220,7 +5436,7 @@ var billingRoutes = {
   "billing.plans": {
     method: "GET",
     path: "/v1/billing/plans",
-    response: z16.object({ data: z16.array(CatalogPlan) }),
+    response: z17.object({ data: z17.array(CatalogPlan) }),
     status: 200,
     access: "read",
     phase: "S5"
@@ -5362,7 +5578,7 @@ var automationRoutes = {
     method: "POST",
     path: "/v1/automations/:id/pause",
     params: IdParams,
-    body: z16.object({}).strict(),
+    body: z17.object({}).strict(),
     response: Automation,
     status: 200,
     access: "write",
@@ -5372,7 +5588,7 @@ var automationRoutes = {
     method: "POST",
     path: "/v1/automations/:id/resume",
     params: IdParams,
-    body: z16.object({}).strict(),
+    body: z17.object({}).strict(),
     response: Automation,
     status: 200,
     access: "write",
@@ -5382,7 +5598,7 @@ var automationRoutes = {
     method: "POST",
     path: "/v1/automations/:id/archive",
     params: IdParams,
-    body: z16.object({}).strict(),
+    body: z17.object({}).strict(),
     response: Automation,
     status: 200,
     access: "write",
@@ -5516,13 +5732,13 @@ function matchRoute(method, pathname) {
   for (const [id, route] of Object.entries(routes)) {
     if (route.method !== method) continue;
     const names = [];
-    const pattern2 = new RegExp(
+    const pattern3 = new RegExp(
       "^" + route.path.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/:([a-z_]+)/g, (_, name) => {
         names.push(name);
         return "([^/]+)";
       }) + "$"
     );
-    const match = pattern2.exec(pathname);
+    const match = pattern3.exec(pathname);
     if (!match) continue;
     const params = {};
     names.forEach((name, i) => {
@@ -5722,6 +5938,7 @@ export {
   InviteListQuery,
   InviteStatus,
   JsonValue,
+  LETTER_ONLY_MERGE_FIELDS,
   LETTER_RECIPIENT_REFUSAL,
   LIST_UNSUBSCRIBE_POST_VALUE,
   LOCALE_TAG_PATTERN,
@@ -5790,7 +6007,10 @@ export {
   MailingLanguageReport,
   MailingLanguageStatus,
   MailingListQuery,
+  MailingMerge,
   MailingMetadata,
+  MailingResolveRequest,
+  MailingResolveResult,
   MailingRetryFailedRequest,
   MailingScheduleFailedData,
   MailingScheduleRequest,
@@ -5815,6 +6035,8 @@ export {
   MessageOutcome,
   MessageSentData,
   MessageSummary,
+  MessageValues,
+  NAME_ON_BROADCAST_REFUSAL,
   NotifyRecipients,
   NotifyStep,
   ON_BEHALF_OF_HEADER,
@@ -5850,6 +6072,8 @@ export {
   REQUEST_ID_HEADER,
   RESEND_EVENT_TYPES,
   RESERVED_MERGE_FIELDS,
+  RESOLVE_PROBLEMS,
+  RESOLVE_REJECTIONS,
   RETRYABLE_ERRORS,
   RETRY_AFTER_HEADER,
   RE_ENTRY_MODES,
@@ -5862,6 +6086,9 @@ export {
   RecipientStatus,
   RemoteImage,
   ResendSigningSecret,
+  ResolveProblem,
+  ResolvedRecipient,
+  ResolvedValue,
   SERVICE_FILLED_MERGE_FIELDS,
   SIGNUP_FORM_FIELDS,
   SKIP_REASONS,
@@ -5948,10 +6175,13 @@ export {
   USAGE_METRICS,
   USAGE_WARNING_HEADER,
   USAGE_WARNING_RATIO,
+  UnfilledLink,
   Usage,
   UsageMetric,
   UsageWarning,
+  VALUE_LAYERS,
   ValidationIssue,
+  ValueLayer,
   VariantAnalytics,
   WEBHOOK_DELIVERY_STATUSES,
   WEBHOOK_EVENT_ID_HEADER,
@@ -6015,6 +6245,7 @@ export {
   editMainInsertions,
   effectivePreviewPicks,
   emptyFlow,
+  emptyLinkValues,
   errorBody,
   escapeMergeHtml,
   exportFilename,
@@ -6045,6 +6276,8 @@ export {
   languageInsertions,
   languageName,
   languageTabs,
+  letterOnlyValues,
+  linkTokens,
   mainInsertionText,
   matchLocale,
   matchRoute,
@@ -6065,6 +6298,8 @@ export {
   previewInsertions,
   previewPersonalization,
   primaryLanguage,
+  printedFields,
+  rawMergeValue,
   reachable,
   readyWithoutInsertions,
   readyWithoutSubject,
@@ -6081,6 +6316,7 @@ export {
   renameTokenInDocument,
   renameTokenInText,
   resolveInsertions,
+  resolveValue,
   restorePatch,
   routes,
   sameJson,
@@ -6107,5 +6343,7 @@ export {
   unknownRefusedInsertions,
   unplacedInsertions,
   validateAutomation,
+  valueNames,
+  valuesRead,
   verifyWebhook
 };