@marlinjai/mail-contract 0.4.0 → 0.6.0

package/dist/index.mjs

@@ -22,6 +22,29 @@ function page(item) {
 }
 var IdParams = z.object({ id: Id });
 var Ok = z.object({ ok: z.literal(true) });
+var LOCALE_TAG_PATTERN = /^[A-Za-z]{2,3}(?:-[A-Za-z]{4})?(?:-(?:[A-Za-z]{2}|[0-9]{3}))?$/;
+var LocaleTag = z.string().min(2).max(35).regex(LOCALE_TAG_PATTERN, "a language tag such as en, fr or pt-BR");
+function canonicalLocale(tag) {
+  if (typeof tag !== "string") return null;
+  const trimmed = tag.trim().replace(/_/g, "-");
+  if (!LOCALE_TAG_PATTERN.test(trimmed)) return null;
+  return trimmed.split("-").map((part, i) => {
+    if (i === 0) return part.toLowerCase();
+    if (part.length === 4) return part[0].toUpperCase() + part.slice(1).toLowerCase();
+    return part.toUpperCase();
+  }).join("-");
+}
+function primaryLanguage(tag) {
+  return canonicalLocale(tag)?.split("-")[0] ?? null;
+}
+function matchLocale(wanted, available) {
+  const canonical = canonicalLocale(wanted);
+  if (!canonical) return null;
+  const exact = available.find((a) => canonicalLocale(a) === canonical);
+  if (exact !== void 0) return exact;
+  const primary = canonical.split("-")[0];
+  return available.find((a) => primaryLanguage(a) === primary) ?? null;
+}
 
 // src/errors.ts
 import { z as z2 } from "zod";
@@ -122,119 +145,483 @@ var API_VERSION_PREFIX = "/v1";
 var HEALTH_PATH = "/healthz";
 
 // src/workspace.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // src/automations.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 
 // src/templates.ts
+import { z as z4 } from "zod";
+
+// src/insertions.ts
 import { z as z3 } from "zod";
+
+// src/unsubscribe.ts
+var UNSUBSCRIBE_PATH_PREFIX = "/u/";
+var LIST_UNSUBSCRIBE_POST_VALUE = "List-Unsubscribe=One-Click";
+var RESERVED_MERGE_FIELDS = {
+  /** From the recipient's merge values, else the contact. Supports a fallback. */
+  first_name: { source: "contact", fallback: true, required_for_broadcast: false },
+  last_name: { source: "contact", fallback: true, required_for_broadcast: false },
+  email: { source: "contact", fallback: false, required_for_broadcast: false },
+  /** The hosted unsubscribe page for this recipient. A broadcast without it is refused. */
+  unsubscribe_url: { source: "service", fallback: false, required_for_broadcast: true }
+};
+var MERGE_FIELD_PATTERN = /\{\{\s*([a-z][a-z0-9_]*)\s*(?:\|([^}]*))?\}\}/g;
+function findMergeFields(html) {
+  const uses = [];
+  for (const match of html.matchAll(MERGE_FIELD_PATTERN)) {
+    uses.push({ name: match[1], fallback: match[2] === void 0 ? null : match[2].trim() });
+  }
+  return uses;
+}
+function missingRequiredMergeFields(html) {
+  const used = new Set(findMergeFields(html).map((u) => u.name));
+  return Object.keys(RESERVED_MERGE_FIELDS).filter(
+    (name) => RESERVED_MERGE_FIELDS[name].required_for_broadcast && !used.has(name)
+  );
+}
+
+// src/insertions.ts
+function ownEntry(record, key) {
+  return record != null && Object.prototype.hasOwnProperty.call(record, key) ? record[key] : void 0;
+}
+var MAX_INSERTIONS = 20;
+var MAX_INSERTION_CHOICES = 30;
+var MAX_INSERTION_TEXT_LENGTH = 2e3;
+var NAME = /^[a-z][a-z0-9_]*$/;
+var InsertionName = z3.string().max(64).regex(NAME, "a merge-field name: lowercase letters, digits and underscores, starting with a letter");
+var INSERTION_TEXT_SLOTS = ["filled", "otherwise"];
+var InsertionChoiceKey = z3.string().regex(/^[a-z0-9][a-z0-9_-]{0,63}$/, "lowercase letters, digits, hyphens and underscores, up to 64").refine((key) => !INSERTION_TEXT_SLOTS.includes(key), "filled and otherwise name the other two texts, not a choice");
+var InsertionText = z3.string().max(MAX_INSERTION_TEXT_LENGTH);
+var Insertion = z3.object({
+  by: InsertionName,
+  choices: z3.record(InsertionChoiceKey, InsertionText).refine((c) => Object.keys(c).length <= MAX_INSERTION_CHOICES, `at most ${MAX_INSERTION_CHOICES} choices`),
+  filled: InsertionText.nullable(),
+  otherwise: InsertionText
+});
+var Insertions = z3.record(InsertionName, Insertion).refine((m) => Object.keys(m).length <= MAX_INSERTIONS, `at most ${MAX_INSERTIONS} insertions`);
+var TranslationInsertion = z3.object({
+  choices: z3.record(InsertionChoiceKey, InsertionText.nullable()),
+  filled: InsertionText.nullable(),
+  otherwise: InsertionText.nullable()
+});
+var TranslationInsertions = z3.record(InsertionName, TranslationInsertion);
+var INSERTION_PROBLEM_REASONS = [
+  /** A reserved merge field (`first_name`, `email`, ...) cannot be an insertion's name. */
+  "insertion_name",
+  /** `by` is `unsubscribe_url` or another insertion's name. */
+  "insertion_by",
+  /** A text places an insertion: texts hold merge fields only, one level. */
+  "insertion_text",
+  /** `{{opening|...}}`: an insertion's `otherwise` is its fallback, in every language. */
+  "insertion_with_fallback",
+  /** A language version names an insertion or a choice the main language does not have. */
+  "unknown_translation_insertion"
+];
+function insertionTokens(text, insertions) {
+  const out = [];
+  for (const match of text.matchAll(MERGE_FIELD_PATTERN)) {
+    const name = match[1];
+    if (Object.prototype.hasOwnProperty.call(insertions, name)) {
+      out.push({ name, fallback: match[2] === void 0 ? null : match[2] });
+    }
+  }
+  return out;
+}
+function eachText(ins) {
+  const texts = [];
+  for (const [key, text] of Object.entries(ins.choices)) if (text !== null) texts.push([`choices.${key}`, text]);
+  if (ins.filled !== null) texts.push(["filled", ins.filled]);
+  if (ins.otherwise !== null) texts.push(["otherwise", ins.otherwise]);
+  return texts;
+}
+function insertionProblems(insertions) {
+  const problems = [];
+  for (const [name, ins] of Object.entries(insertions)) {
+    if (Object.prototype.hasOwnProperty.call(RESERVED_MERGE_FIELDS, name)) {
+      problems.push({ reason: "insertion_name", path: name, message: `"${name}" is a merge field the service fills; name the insertion something else` });
+    }
+    if (ins.by === "unsubscribe_url" || Object.prototype.hasOwnProperty.call(insertions, ins.by)) {
+      problems.push({ reason: "insertion_by", path: `${name}.by`, message: `"${ins.by}" cannot choose an insertion: use a value the client or the contact provides` });
+    }
+    for (const [where, text] of eachText(ins)) {
+      if (insertionTokens(text, insertions).length > 0) {
+        problems.push({ reason: "insertion_text", path: `${name}.${where}`, message: "an insertion text can hold merge fields, not other insertions" });
+      }
+    }
+  }
+  return problems;
+}
+function translationInsertionProblems(main, translation) {
+  const problems = [];
+  for (const [name, ins] of Object.entries(translation)) {
+    const def = ownEntry(main, name);
+    if (!def) {
+      problems.push({ reason: "unknown_translation_insertion", path: name, message: `the main language has no insertion "${name}"` });
+      continue;
+    }
+    for (const key of Object.keys(ins.choices)) {
+      if (!Object.prototype.hasOwnProperty.call(def.choices, key)) {
+        problems.push({ reason: "unknown_translation_insertion", path: `${name}.choices.${key}`, message: `"${name}" has no choice "${key}" in the main language` });
+      }
+    }
+    for (const [where, text] of eachText(ins)) {
+      if (insertionTokens(text, main).length > 0) {
+        problems.push({ reason: "insertion_text", path: `${name}.${where}`, message: "an insertion text can hold merge fields, not other insertions" });
+      }
+    }
+  }
+  return problems;
+}
+function placementProblems(texts, insertions) {
+  const problems = [];
+  for (const [where, text] of Object.entries(texts)) {
+    if (!text) continue;
+    for (const use of insertionTokens(text, insertions)) {
+      if (use.fallback !== null) {
+        problems.push({
+          reason: "insertion_with_fallback",
+          path: where,
+          message: `{{${use.name}|...}}: an insertion takes no fallback, its "otherwise" text is the fallback`
+        });
+      }
+    }
+  }
+  return problems;
+}
+function unplacedInsertions(texts, insertions) {
+  const placed = /* @__PURE__ */ new Set();
+  for (const text of texts) if (text) for (const use of insertionTokens(text, insertions)) placed.add(use.name);
+  return Object.keys(insertions).filter((name) => !placed.has(name));
+}
+function insertionCoverage(main, translation) {
+  const missing = [];
+  for (const [name, def] of Object.entries(main)) {
+    const t = ownEntry(translation, name);
+    for (const key of Object.keys(def.choices)) {
+      const text = ownEntry(t?.choices, key);
+      if (typeof text !== "string") missing.push({ insertion: name, choice: key });
+    }
+    if (def.filled !== null && typeof t?.filled !== "string") missing.push({ insertion: name, choice: "filled" });
+    if (typeof t?.otherwise !== "string") missing.push({ insertion: name, choice: "otherwise" });
+  }
+  return missing;
+}
+function alignTranslationInsertions(main, translation) {
+  const out = {};
+  for (const [name, def] of Object.entries(main)) {
+    const t = ownEntry(translation, name);
+    const choices = {};
+    for (const key of Object.keys(def.choices)) choices[key] = ownEntry(t?.choices, key) ?? null;
+    out[name] = { choices, filled: def.filled === null ? null : t?.filled ?? null, otherwise: t?.otherwise ?? null };
+  }
+  return out;
+}
+function languageInsertions(main, translation) {
+  if (insertionCoverage(main, translation).length > 0) return null;
+  const out = {};
+  for (const [name, def] of Object.entries(main)) {
+    const t = ownEntry(translation, name);
+    const choices = {};
+    for (const key of Object.keys(def.choices)) choices[key] = ownEntry(t.choices, key);
+    out[name] = { by: def.by, choices, filled: def.filled === null ? null : t.filled, otherwise: t.otherwise };
+  }
+  return out;
+}
+function insertionInputs(insertions) {
+  const out = {};
+  for (const [name, def] of Object.entries(insertions)) {
+    const entry = ownEntry(out, def.by) ?? (out[def.by] = { insertions: [], keys: [], filled: false });
+    entry.insertions.push(name);
+    for (const key of Object.keys(def.choices)) if (!entry.keys.includes(key)) entry.keys.push(key);
+    if (def.filled !== null) entry.filled = true;
+  }
+  return out;
+}
+function insertionValue(raw) {
+  if (typeof raw === "string") return raw.trim() === "" ? null : raw.trim();
+  if (typeof raw === "number" && Number.isFinite(raw)) return String(raw);
+  if (raw === true) return "true";
+  return null;
+}
+var InsertionChoice = z3.object({
+  value: z3.string().nullable(),
+  chosen: z3.string(),
+  matched: z3.boolean()
+});
+var InsertionChoices = z3.record(InsertionName, InsertionChoice);
+function chooseInsertion(insertion, raw) {
+  const value = insertionValue(raw);
+  if (value !== null) {
+    const key = value.toLowerCase();
+    if (Object.prototype.hasOwnProperty.call(insertion.choices, key)) {
+      return { value, chosen: key, matched: true, text: insertion.choices[key] };
+    }
+    if (insertion.filled !== null) return { value, chosen: "filled", matched: true, text: insertion.filled };
+    return { value, chosen: "otherwise", matched: false, text: insertion.otherwise };
+  }
+  return { value: null, chosen: "otherwise", matched: true, text: insertion.otherwise };
+}
+function resolveInsertions(insertions, raw) {
+  const out = {};
+  for (const [name, def] of Object.entries(insertions)) out[name] = chooseInsertion(def, raw(def.by));
+  return out;
+}
+function insertionChoices(resolved) {
+  const out = {};
+  for (const [name, r] of Object.entries(resolved)) out[name] = { value: r.value, chosen: r.chosen, matched: r.matched };
+  return out;
+}
+var ESCAPES = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" };
+function escapeMergeHtml(value) {
+  return value.replace(/[&<>"']/g, (ch) => ESCAPES[ch]);
+}
+function pattern() {
+  return new RegExp(MERGE_FIELD_PATTERN.source, "g");
+}
+function insertionHtml(text, p) {
+  let out = "";
+  let last = 0;
+  for (const match of text.matchAll(pattern())) {
+    out += escapeMergeHtml(text.slice(last, match.index));
+    out += escapeMergeHtml(p.value(match[1], match[2]));
+    last = match.index + match[0].length;
+  }
+  out += escapeMergeHtml(text.slice(last));
+  return out.trim() === "" ? "" : out.replace(/\r\n|\r|\n/g, "<br>");
+}
+function insertionPlain(text, p) {
+  return text.replace(pattern(), (_m, name, fallback) => p.value(name, fallback));
+}
+function tokenHtml(name, fallback, p) {
+  const ins = ownEntry(p.insertions, name);
+  if (ins) return insertionHtml(ins.text, p);
+  return escapeMergeHtml(p.value(name, fallback));
+}
+var FIELD_ONLY_PARAGRAPH = new RegExp(
+  String.raw`<(p|div|li|h[1-6])(\s[^>]*)?>((?:\s|&nbsp;|&#160;|<br\s*\/?>|<\/?(?:strong|b|em|i|u|span|font|a)(?:\s[^>]*)?>|\{\{\s*[a-z][a-z0-9_]*\s*(?:\|[^}]*)?\}\})*)<\/\1>`,
+  "g"
+);
+var TEXT_BLOCK_ROW = /<tr>\s*<td\b[^>]*\bclass="[^"]*\bel-text\b[^"]*"[^>]*>([\s\S]*?)<\/td>\s*<\/tr>/g;
+function hasVisibleContent(html) {
+  if (/<(img|hr|video|svg|input|iframe|table)\b/i.test(html)) return true;
+  const text = html.replace(/<!--[\s\S]*?-->/g, "").replace(/<[^>]*>/g, "").replace(/&nbsp;|&#160;| /g, "").trim();
+  return text !== "";
+}
+function dropEmptyParagraphs(html, p) {
+  return html.replace(FIELD_ONLY_PARAGRAPH, (whole, _tag, _attrs, content) => {
+    const tokens = [...content.matchAll(pattern())];
+    if (tokens.length === 0) return whole;
+    return tokens.every((m) => tokenHtml(m[1], m[2], p).trim() === "") ? "" : whole;
+  });
+}
+function personalizeHtml(html, p) {
+  let out = html.replace(TEXT_BLOCK_ROW, (whole, inner) => {
+    if (!pattern().test(inner)) return whole;
+    const kept = dropEmptyParagraphs(inner, p);
+    const filled = kept.replace(pattern(), (_m, name, fallback) => tokenHtml(name, fallback, p));
+    return hasVisibleContent(filled) ? whole : "";
+  });
+  out = dropEmptyParagraphs(out, p);
+  return out.replace(pattern(), (_m, name, fallback) => tokenHtml(name, fallback, p));
+}
+var CONTROL = new RegExp("[\\u0000-\\u001f\\u007f]+", "g");
+function personalizeText(text, p) {
+  return text.replace(pattern(), (_m, name, fallback) => {
+    const ins = ownEntry(p.insertions, name);
+    return ins ? insertionPlain(ins.text, p) : p.value(name, fallback);
+  }).replace(CONTROL, " ").replace(/ {2,}/g, " ").trim();
+}
+function sampleMergeValue(values) {
+  return (name, fallback) => {
+    const v = ownEntry(values, name);
+    const text = typeof v === "string" ? v : typeof v === "number" && Number.isFinite(v) ? String(v) : typeof v === "boolean" ? String(v) : null;
+    if (text === null || text.trim() === "") return fallback?.trim() ?? "";
+    return text;
+  };
+}
+
+// src/templates.ts
 var DOCUMENT_SCHEMA_VERSIONS = ["1.0", "1.1"];
-var DocumentSchemaVersion = z3.enum(DOCUMENT_SCHEMA_VERSIONS);
-var TemplateDocument = z3.object({
+var DocumentSchemaVersion = z4.enum(DOCUMENT_SCHEMA_VERSIONS);
+var TemplateDocument = z4.object({
   version: DocumentSchemaVersion,
-  metadata: z3.record(z3.unknown()),
-  sections: z3.array(z3.record(z3.unknown()))
+  metadata: z4.record(z4.unknown()),
+  sections: z4.array(z4.record(z4.unknown()))
 }).passthrough();
 var MAX_DOCUMENT_BYTES = 1e6;
-var Template = z3.object({
+var MAX_SUBJECT_LENGTH = 998;
+var MAX_PREHEADER_LENGTH = 500;
+var TemplateSubject = z4.string().max(MAX_SUBJECT_LENGTH).regex(/^[^\x00-\x1f\x7f]*$/, "one line, without control characters");
+var TemplatePreheader = z4.string().max(MAX_PREHEADER_LENGTH).regex(/^[^\x00-\x1f\x7f]*$/, "one line, without control characters");
+var TEMPLATE_LANGUAGE_STATUSES = ["draft", "ready"];
+var TemplateLanguageStatus = z4.enum(TEMPLATE_LANGUAGE_STATUSES);
+var TemplateTranslation = z4.object({
+  subject: TemplateSubject.nullable(),
+  preheader: TemplatePreheader.nullable(),
+  document: TemplateDocument,
+  status: TemplateLanguageStatus,
+  /**
+   * This language's texts for the main language's insertions
+   * (docs/plans/2026-09-25-translated-insertions.md). The service always
+   * returns it, aligned to the main language's structure (a text not written
+   * yet is null). In a save, leaving it out keeps the stored texts, so a
+   * client that does not know insertions never erases them. A `ready` version
+   * needs every text: marking one ready without is `ready_needs_insertions`,
+   * and a save that leaves a ready version without one (the main language
+   * added a choice) sets it back to `draft`.
+   */
+  insertions: TranslationInsertions.optional()
+});
+var MAX_TEMPLATE_TRANSLATIONS = 19;
+var TemplateTranslations = z4.record(LocaleTag, TemplateTranslation).refine((t) => Object.keys(t).length <= MAX_TEMPLATE_TRANSLATIONS, `at most ${MAX_TEMPLATE_TRANSLATIONS} language versions`);
+var Template = z4.object({
   id: Id,
-  name: z3.string().min(1).max(200),
-  description: z3.string().max(2e3).nullable(),
+  name: z4.string().min(1).max(200),
+  description: z4.string().max(2e3).nullable(),
+  /**
+   * The main language: what `subject`, `preheader` and `document` are written
+   * in, and what every recipient without a ready version of their own gets.
+   * Set from the workspace's `default_locale` when the template is created
+   * unless given, and never changed by a later change of that setting.
+   */
+  locale: LocaleTag,
+  /** The main language's subject line; null when the mailing that uses the template gives one. */
+  subject: TemplateSubject.nullable(),
+  preheader: TemplatePreheader.nullable(),
   document: TemplateDocument,
-  /** Increments on every saved change. */
-  version: z3.number().int().min(1),
-  thumbnail_url: z3.string().url().nullable(),
+  /**
+   * The other languages. A version whose language the workspace no longer
+   * lists is kept, but no send uses it until the language is listed again.
+   */
+  translations: TemplateTranslations,
+  /**
+   * The main language's insertions: named sentences chosen per recipient by
+   * one merge value, placed as `{{name}}` (see `insertions.ts`). Their
+   * structure is the main language's; every other language holds its own
+   * texts in `translations[tag].insertions`.
+   */
+  insertions: Insertions,
+  /** Increments on every saved change, of any language. */
+  version: z4.number().int().min(1),
+  thumbnail_url: z4.string().url().nullable(),
   archived_at: Timestamp.nullable(),
   created_at: Timestamp,
   updated_at: Timestamp
 });
-var TemplateSummary = Template.omit({ document: true });
-var TemplateCreate = z3.object({
-  name: z3.string().min(1).max(200),
-  description: z3.string().max(2e3).optional(),
-  document: TemplateDocument
-});
-var TemplateUpdate = z3.object({
-  base_version: z3.number().int().min(1),
-  name: z3.string().min(1).max(200).optional(),
-  description: z3.string().max(2e3).nullable().optional(),
+var TemplateSummary = Template.omit({ document: true, translations: true, insertions: true }).extend({
+  languages: z4.record(LocaleTag, TemplateLanguageStatus),
+  /** The names of the template's insertions, sorted alphabetically. */
+  insertion_names: z4.array(z4.string())
+});
+var TemplateCreate = z4.object({
+  name: z4.string().min(1).max(200),
+  description: z4.string().max(2e3).optional(),
+  locale: LocaleTag.optional(),
+  subject: TemplateSubject.nullable().optional(),
+  preheader: TemplatePreheader.nullable().optional(),
+  document: TemplateDocument,
+  translations: TemplateTranslations.optional(),
+  insertions: Insertions.optional()
+});
+var TemplateUpdate = z4.object({
+  base_version: z4.number().int().min(1),
+  name: z4.string().min(1).max(200).optional(),
+  description: z4.string().max(2e3).nullable().optional(),
+  locale: LocaleTag.optional(),
+  subject: TemplateSubject.nullable().optional(),
+  preheader: TemplatePreheader.nullable().optional(),
   document: TemplateDocument.optional(),
-  archived: z3.boolean().optional()
+  translations: z4.record(LocaleTag, TemplateTranslation.nullable()).optional(),
+  /**
+   * The main language's insertions, whole: what is left out is removed, from
+   * every language in the same save. A rename is a removal and an addition,
+   * so an editor carries each language's texts to the new name in the same
+   * save (it sends those languages in `translations`).
+   */
+  insertions: Insertions.optional(),
+  archived: z4.boolean().optional()
 }).refine(
-  (v) => v.name !== void 0 || v.description !== void 0 || v.document !== void 0 || v.archived !== void 0,
+  (v) => v.name !== void 0 || v.description !== void 0 || v.locale !== void 0 || v.subject !== void 0 || v.preheader !== void 0 || v.document !== void 0 || v.translations !== void 0 || v.insertions !== void 0 || v.archived !== void 0,
   "at least one field besides base_version"
 );
-var SavedSectionBody = z3.record(z3.unknown());
+var SavedSectionBody = z4.record(z4.unknown());
 var MAX_SAVED_SECTIONS = 50;
-var SavedSection = z3.object({
+var SavedSection = z4.object({
   id: Id,
-  name: z3.string().min(1).max(200),
-  description: z3.string().max(2e3).nullable(),
+  name: z4.string().min(1).max(200),
+  description: z4.string().max(2e3).nullable(),
   section: SavedSectionBody,
-  created_by: z3.string().nullable(),
+  created_by: z4.string().nullable(),
   created_at: Timestamp,
   updated_at: Timestamp
 });
-var SavedSectionCreate = z3.object({
-  name: z3.string().min(1).max(200),
-  description: z3.string().max(2e3).optional(),
+var SavedSectionCreate = z4.object({
+  name: z4.string().min(1).max(200),
+  description: z4.string().max(2e3).optional(),
   section: SavedSectionBody
 });
-var SavedSectionUpdate = z3.object({
-  name: z3.string().min(1).max(200).optional(),
-  description: z3.string().max(2e3).nullable().optional(),
+var SavedSectionUpdate = z4.object({
+  name: z4.string().min(1).max(200).optional(),
+  description: z4.string().max(2e3).nullable().optional(),
   section: SavedSectionBody.optional()
 }).refine((v) => v.name !== void 0 || v.description !== void 0 || v.section !== void 0, "at least one field");
 var TemplateListQuery = PageQuery.extend({
-  archived: z3.enum(["true", "false"]).optional()
+  archived: z4.enum(["true", "false"]).optional()
 });
-var TemplateVersion = z3.object({
+var TemplateVersion = z4.object({
   template_id: Id,
-  version: z3.number().int().min(1),
+  version: z4.number().int().min(1),
+  locale: LocaleTag,
+  subject: TemplateSubject.nullable(),
+  preheader: TemplatePreheader.nullable(),
   document: TemplateDocument,
-  created_by: z3.string().nullable(),
+  translations: TemplateTranslations,
+  insertions: Insertions,
+  created_by: z4.string().nullable(),
   created_at: Timestamp
 });
-var TemplateVersionParams = z3.object({
+var TemplateVersionParams = z4.object({
   id: Id,
-  version: z3.coerce.number().int().min(1)
+  version: z4.coerce.number().int().min(1)
 });
-var CompileMessage = z3.object({
-  message: z3.string().min(1),
+var CompileMessage = z4.object({
+  message: z4.string().min(1),
   /** Where in the document or the MJML the message points, when known. */
-  path: z3.string().optional(),
-  line: z3.number().int().min(1).optional()
+  path: z4.string().optional(),
+  line: z4.number().int().min(1).optional()
 });
-var CompileResult = z3.object({
-  mjml: z3.string(),
-  html: z3.string(),
-  warnings: z3.array(CompileMessage),
-  errors: z3.array(CompileMessage)
+var CompileResult = z4.object({
+  mjml: z4.string(),
+  html: z4.string(),
+  warnings: z4.array(CompileMessage),
+  errors: z4.array(CompileMessage)
 });
-var TemplateCompileRequest = z3.object({
-  version: z3.number().int().min(1).optional()
+var TemplateCompileRequest = z4.object({
+  version: z4.number().int().min(1).optional(),
+  locale: LocaleTag.optional()
 });
-var CompileRequest = z3.object({
+var CompileRequest = z4.object({
   document: TemplateDocument
 });
 var ASSET_CONTENT_TYPES = ["image/png", "image/jpeg", "image/gif", "image/webp"];
-var AssetContentType = z3.enum(ASSET_CONTENT_TYPES);
+var AssetContentType = z4.enum(ASSET_CONTENT_TYPES);
 var MAX_ASSET_BYTES = 10 * 1024 * 1024;
-var Asset = z3.object({
+var Asset = z4.object({
   id: Id,
-  url: z3.string().url(),
+  url: z4.string().url(),
   content_type: AssetContentType,
-  size_bytes: z3.number().int().min(1).max(MAX_ASSET_BYTES),
-  width: z3.number().int().min(1).nullable(),
-  height: z3.number().int().min(1).nullable(),
-  filename: z3.string().min(1).max(255),
+  size_bytes: z4.number().int().min(1).max(MAX_ASSET_BYTES),
+  width: z4.number().int().min(1).nullable(),
+  height: z4.number().int().min(1).nullable(),
+  filename: z4.string().min(1).max(255),
   created_at: Timestamp
 });
 var ASSET_UPLOAD_FIELD = "file";
 var MAX_IMPORT_URL_LENGTH = 2048;
-var AssetImport = z3.object({
-  url: z3.string().max(MAX_IMPORT_URL_LENGTH).url().refine((u) => {
+var AssetImport = z4.object({
+  url: z4.string().max(MAX_IMPORT_URL_LENGTH).url().refine((u) => {
     try {
       const url = new URL(u);
       if (url.protocol === "https:") return true;
@@ -244,7 +631,7 @@ var AssetImport = z3.object({
     }
   }, "must be https (http only for localhost)"),
   /** The stored file name; derived from the address when omitted. */
-  filename: z3.string().min(1).max(255).optional()
+  filename: z4.string().min(1).max(255).optional()
 });
 var MAX_MJML_IMPORT_BYTES = 512 * 1024;
 var MAX_MJML_DEPTH = 32;
@@ -259,55 +646,56 @@ var MJML_IMPORT_REFUSALS = [
   "too_complex",
   "invalid_document"
 ];
-var ImportWarning = z3.object({
-  severity: z3.enum(["info", "warning"]),
+var ImportWarning = z4.object({
+  severity: z4.enum(["info", "warning"]),
   /** Stable kind, e.g. `kept_as_html`, `unknown_component`, `remote_image_not_imported`. */
-  code: z3.string().min(1).max(64),
+  code: z4.string().min(1).max(64),
   /** Where in the source, e.g. `mj-body > mj-section[2] > mj-column[1] > mj-social[1]`. */
-  path: z3.string(),
-  line: z3.number().int().min(1).optional(),
-  message: z3.string().min(1),
-  fragment: z3.string().optional()
+  path: z4.string(),
+  line: z4.number().int().min(1).optional(),
+  message: z4.string().min(1),
+  fragment: z4.string().optional()
 });
-var RemoteImage = z3.object({
-  url: z3.string().min(1),
+var RemoteImage = z4.object({
+  url: z4.string().min(1),
   /** The element and attribute it is loaded from, e.g. `<img src>`. */
-  where: z3.string()
+  where: z4.string()
 });
-var ImportedAsset = z3.object({
-  source_url: z3.string().min(1),
+var ImportedAsset = z4.object({
+  source_url: z4.string().min(1),
   asset_id: Id,
-  url: z3.string().url()
+  url: z4.string().url()
 });
-var mjmlSource = z3.string().min(1, "paste or upload the MJML");
-var TemplateImportPreviewRequest = z3.object({ mjml: mjmlSource });
-var TemplateImportPreview = z3.object({
+var mjmlSource = z4.string().min(1, "paste or upload the MJML");
+var TemplateImportPreviewRequest = z4.object({ mjml: mjmlSource });
+var TemplateImportPreview = z4.object({
   document: TemplateDocument,
-  warnings: z3.array(ImportWarning),
+  warnings: z4.array(ImportWarning),
   /** The document compiled under the workspace's asset policy, exactly as a send would. */
   compiled: CompileResult,
   /** Images loaded from outside the service; under `service_only` each is also a compile error. */
-  remote_images: z3.array(RemoteImage),
-  asset_policy: z3.enum(["any", "service_only"])
+  remote_images: z4.array(RemoteImage),
+  asset_policy: z4.enum(["any", "service_only"])
 });
-var TemplateImport = z3.object({
-  name: z3.string().min(1).max(200),
-  description: z3.string().max(2e3).optional(),
+var TemplateImport = z4.object({
+  name: z4.string().min(1).max(200),
+  description: z4.string().max(2e3).optional(),
   mjml: mjmlSource,
-  import_remote_assets: z3.boolean().optional()
+  import_remote_assets: z4.boolean().optional()
 });
-var TemplateImportResult = z3.object({
+var TemplateImportResult = z4.object({
   template: Template,
-  warnings: z3.array(ImportWarning),
-  imported_assets: z3.array(ImportedAsset)
+  warnings: z4.array(ImportWarning),
+  imported_assets: z4.array(ImportedAsset)
 });
 var EXPORT_FORMATS = ["mjml", "html"];
-var ExportFormat = z3.enum(EXPORT_FORMATS);
-var TemplateExportQuery = z3.object({
+var ExportFormat = z4.enum(EXPORT_FORMATS);
+var TemplateExportQuery = z4.object({
   format: ExportFormat,
-  version: z3.coerce.number().int().min(1).optional()
+  version: z4.coerce.number().int().min(1).optional(),
+  locale: LocaleTag.optional()
 });
-var MailingExportQuery = z3.object({ format: ExportFormat });
+var MailingExportQuery = z4.object({ format: ExportFormat });
 var EXPORT_CONTENT_TYPES = {
   mjml: "text/plain; charset=utf-8",
   html: "text/html; charset=utf-8"
@@ -326,7 +714,7 @@ function formatExportWarningsHeader(messages) {
 function parseExportWarningsHeader(value) {
   if (!value) return [];
   try {
-    const parsed = z3.array(CompileMessage).safeParse(JSON.parse(decodeURIComponent(value)));
+    const parsed = z4.array(CompileMessage).safeParse(JSON.parse(decodeURIComponent(value)));
     return parsed.success ? parsed.data : [];
   } catch {
     return [];
@@ -338,32 +726,32 @@ function exportFilename(name, format) {
 }
 
 // src/platform.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 
 // src/mailings.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 
 // src/ab-test.ts
-import { z as z4 } from "zod";
-var AbVariant = z4.object({
-  key: z4.string().regex(/^[a-z]$/, "a single lowercase letter"),
-  subject: z4.string().min(1).max(998).optional(),
+import { z as z5 } from "zod";
+var AbVariant = z5.object({
+  key: z5.string().regex(/^[a-z]$/, "a single lowercase letter"),
+  subject: z5.string().min(1).max(998).optional(),
   /** Replaces the mailing's document for this variant. */
-  document: z4.record(z4.unknown()).optional(),
+  document: z5.record(z5.unknown()).optional(),
   /**
    * Keeps the document this variant key already has in the mailing's current
    * test, so a test can be changed without sending every document again. The
    * service refuses it (`validation_failed`) when that variant has none.
    */
-  keep_document: z4.literal(true).optional()
+  keep_document: z5.literal(true).optional()
 });
 var AB_WINNER_METRICS = ["opens", "clicks", "manual"];
-var AbTestConfig = z4.object({
-  variants: z4.array(AbVariant).min(2).max(5),
+var AbTestConfig = z5.object({
+  variants: z5.array(AbVariant).min(2).max(5),
   /** Share of recipients in the test group, split evenly across variants; the rest get the winner. */
-  test_fraction: z4.number().gt(0).lte(1),
-  winner_metric: z4.enum(AB_WINNER_METRICS),
-  decide_after_minutes: z4.number().int().min(15).max(10080).optional()
+  test_fraction: z5.number().gt(0).lte(1),
+  winner_metric: z5.enum(AB_WINNER_METRICS),
+  decide_after_minutes: z5.number().int().min(15).max(10080).optional()
 }).refine((c) => new Set(c.variants.map((v) => v.key)).size === c.variants.length, "variant keys must be unique").refine((c) => c.variants.every((v) => v.subject !== void 0 || v.document !== void 0 || v.keep_document === true), {
   message: "every variant changes the subject, the document or both",
   path: ["variants"]
@@ -375,19 +763,19 @@ var AbTestConfig = z4.object({
   path: ["decide_after_minutes"]
 });
 var AB_TEST_STATUSES = ["pending", "testing", "awaiting_pick", "decided"];
-var AbTestState = z4.object({
-  variants: z4.array(z4.object({ key: z4.string(), subject: z4.string().nullable(), has_document: z4.boolean() })),
-  test_fraction: z4.number(),
-  winner_metric: z4.enum(AB_WINNER_METRICS),
-  decide_after_minutes: z4.number().int().nullable(),
-  status: z4.enum(AB_TEST_STATUSES),
+var AbTestState = z5.object({
+  variants: z5.array(z5.object({ key: z5.string(), subject: z5.string().nullable(), has_document: z5.boolean() })),
+  test_fraction: z5.number(),
+  winner_metric: z5.enum(AB_WINNER_METRICS),
+  decide_after_minutes: z5.number().int().nullable(),
+  status: z5.enum(AB_TEST_STATUSES),
   /** When the metric decides; null for manual or before the start. */
   decide_at: Timestamp.nullable(),
-  winner: z4.string().nullable(),
-  decided_by: z4.enum(["metric", "manual"]).nullable(),
+  winner: z5.string().nullable(),
+  decided_by: z5.enum(["metric", "manual"]).nullable(),
   decided_at: Timestamp.nullable()
 });
-var AbWinnerRequest = z4.object({ variant: z4.string().regex(/^[a-z]$/) });
+var AbWinnerRequest = z5.object({ variant: z5.string().regex(/^[a-z]$/) });
 function testGroupSize(total, fraction, variants) {
   return Math.min(total, Math.max(variants, Math.ceil(total * fraction)));
 }
@@ -402,9 +790,9 @@ var MAILING_STATUSES = [
   "partially_failed",
   "cancelled"
 ];
-var MailingStatus = z5.enum(MAILING_STATUSES);
+var MailingStatus = z6.enum(MAILING_STATUSES);
 var MAILING_ACTIONS = ["send", "schedule", "unschedule", "pause", "resume", "cancel", "retry-failed"];
-var MailingAction = z5.enum(MAILING_ACTIONS);
+var MailingAction = z6.enum(MAILING_ACTIONS);
 var MAILING_TRANSITIONS = {
   draft: ["send", "schedule", "cancel"],
   scheduled: ["send", "schedule", "unschedule", "cancel"],
@@ -419,26 +807,46 @@ function canTransition(status, action) {
 }
 var EDITABLE_MAILING_STATUSES = ["draft", "scheduled"];
 var TERMINAL_MAILING_STATUSES = ["sent", "cancelled"];
-var MailingMetadata = z5.record(z5.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 = z5.object({
-  total: z5.number().int().min(0),
-  queued: z5.number().int().min(0),
-  sending: z5.number().int().min(0),
-  sent: z5.number().int().min(0),
-  failed: z5.number().int().min(0),
-  skipped: z5.number().int().min(0)
+var MailingMetadata = z6.record(z6.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 = z6.object({
+  total: z6.number().int().min(0),
+  queued: z6.number().int().min(0),
+  sending: z6.number().int().min(0),
+  sent: z6.number().int().min(0),
+  failed: z6.number().int().min(0),
+  skipped: z6.number().int().min(0)
 });
 var MAILING_KINDS = ["broadcast", "automation", "notification"];
-var MailingKind = z5.enum(MAILING_KINDS);
-var Mailing = z5.object({
+var MailingKind = z6.enum(MAILING_KINDS);
+var Mailing = z6.object({
   id: Id,
   kind: MailingKind,
-  name: z5.string().max(200).nullable(),
-  subject: z5.string().min(1).max(998),
-  preheader: z5.string().max(500).nullable(),
-  /** The template the document was taken from, if any. The snapshot is what is sent. */
+  name: z6.string().max(200).nullable(),
+  subject: z6.string().min(1).max(998),
+  preheader: z6.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
+   * taken, the ready ones, when the mailing starts (see "Languages" in the
+   * contract's documentation).
+   */
   template_id: Id.nullable(),
   document: TemplateDocument,
+  /**
+   * The main language: what `subject`, `preheader` and `document` are written
+   * in, and what every recipient without a ready version in their own language
+   * gets. The template's main language, or the workspace's default for a
+   * mailing made from a document.
+   */
+  locale: LocaleTag,
+  /**
+   * The language every recipient is treated as reading, or null to read each
+   * recipient's own (their `merge.locale`, else their contact's language). A
+   * letter sets it to the language its one reader wrote in; a broadcast can use
+   * it to send one language version to everyone. It is matched like anyone's
+   * language: without a ready version in it, the main language goes out.
+   */
+  send_locale: LocaleTag.nullable(),
   /**
    * The topic the mailing is sent under. Null for a letter (a one-to-one
    * mailing with at most one recipient, which belongs to no topic and whose
@@ -460,15 +868,17 @@ var Mailing = z5.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: z5.string().nullable().default(null),
+  pause_reason: z6.string().nullable().default(null),
   created_at: Timestamp,
   updated_at: Timestamp
 });
 var MailingSummary = Mailing.omit({ document: true });
 var MailingContent = {
-  name: z5.string().max(200).optional(),
-  subject: z5.string().min(1).max(998),
-  preheader: z5.string().max(500).optional(),
+  name: z6.string().max(200).optional(),
+  subject: z6.string().min(1).max(998),
+  preheader: z6.string().max(500).optional(),
+  /** See `Mailing.send_locale`. */
+  send_locale: LocaleTag.nullable().optional(),
   /**
    * Omitted or null makes the mailing a letter: one recipient at most, sent to
    * anybody not blocked on every topic, with an unsubscribe link that offers
@@ -479,20 +889,25 @@ var MailingContent = {
   provider_id: Id,
   metadata: MailingMetadata.optional()
 };
-var MailingCreate = z5.object({
+var MailingCreate = z6.object({
   ...MailingContent,
+  subject: MailingContent.subject.optional(),
   document: TemplateDocument.optional(),
   template_id: Id.optional()
 }).refine((v) => v.document === void 0 !== (v.template_id === void 0), {
   message: "exactly one of document or template_id",
   path: ["document"]
+}).refine((v) => v.template_id !== void 0 || v.subject !== void 0, {
+  message: "a mailing made from a document needs a subject",
+  path: ["subject"]
 });
-var MailingUpdate = z5.object({
-  name: z5.string().max(200).nullable().optional(),
+var MailingUpdate = z6.object({
+  name: z6.string().max(200).nullable().optional(),
   subject: MailingContent.subject.optional(),
-  preheader: z5.string().max(500).nullable().optional(),
+  preheader: z6.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(),
   document: TemplateDocument.optional()
@@ -503,29 +918,30 @@ var MailingListQuery = PageQuery.extend({
   kind: MailingKind.optional(),
   automation_id: Id.optional()
 });
-var MailingSendRequest = z5.object({}).strict();
-var MailingRetryFailedRequest = z5.object({
+var MailingSendRequest = z6.object({}).strict();
+var MailingRetryFailedRequest = z6.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: z5.boolean().optional()
+  include_outcome_unknown: z6.boolean().optional()
 }).strict();
-var MailingActionRequest = z5.object({}).strict();
-var MailingTestRequest = z5.object({
+var MailingActionRequest = z6.object({}).strict();
+var MailingTestRequest = z6.object({
   to: Email,
-  merge: Properties.optional()
+  merge: Properties.optional(),
+  locale: LocaleTag.optional()
 });
-var MailingTestResult = z5.object({
+var MailingTestResult = z6.object({
   message_id: Id,
-  provider_message_id: z5.string().nullable()
+  provider_message_id: z6.string().nullable()
 });
 var RECIPIENT_STATUSES = ["queued", "sending", "sent", "failed", "skipped"];
-var RecipientStatus = z5.enum(RECIPIENT_STATUSES);
+var RecipientStatus = z6.enum(RECIPIENT_STATUSES);
 var SKIP_REASONS = ["suppressed", "not_subscribed", "contact_erased", "cancelled", "outcome_unknown"];
-var SkipReason = z5.enum(SKIP_REASONS);
-var Recipient = z5.object({
+var SkipReason = z6.enum(SKIP_REASONS);
+var Recipient = z6.object({
   id: Id,
   mailing_id: Id,
   contact_id: Id.nullable(),
@@ -533,84 +949,125 @@ var Recipient = z5.object({
   merge: Properties,
   status: RecipientStatus,
   skip_reason: SkipReason.nullable(),
-  attempts: z5.number().int().min(0),
+  attempts: z6.number().int().min(0),
   message_id: Id.nullable(),
-  last_error: z5.string().nullable(),
+  last_error: z6.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 = z5.object({
+var RecipientInput = z6.object({
   contact_id: Id.optional(),
-  external_id: z5.string().min(1).max(255).optional(),
+  external_id: z6.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 = z5.object({
-  recipients: z5.array(RecipientInput).min(1).max(MAX_RECIPIENTS_PER_BATCH)
+var RecipientBatch = z6.object({
+  recipients: z6.array(RecipientInput).min(1).max(MAX_RECIPIENTS_PER_BATCH)
 });
 var RECIPIENT_REJECTIONS = ["unknown_contact", "duplicate_in_batch"];
-var RecipientBatchResult = z5.object({
+var RecipientBatchResult = z6.object({
   /** Newly queued. */
-  added: z5.number().int().min(0),
+  added: z6.number().int().min(0),
   /** Already on the mailing from an earlier batch: left unchanged. */
-  already_present: z5.number().int().min(0),
+  already_present: z6.number().int().min(0),
   /** Items not added, by their index in the request. */
-  rejected: z5.array(z5.object({ index: z5.number().int().min(0), reason: z5.enum(RECIPIENT_REJECTIONS) }))
+  rejected: z6.array(z6.object({ index: z6.number().int().min(0), reason: z6.enum(RECIPIENT_REJECTIONS) }))
 });
 var RecipientListQuery = PageQuery.extend({
   status: RecipientStatus.optional(),
   skip_reason: SkipReason.optional()
 });
 var MESSAGE_OUTCOMES = ["sent", "failed"];
-var MessageOutcome = z5.enum(MESSAGE_OUTCOMES);
-var MessageSummary = z5.object({
+var MessageOutcome = z6.enum(MESSAGE_OUTCOMES);
+var MessageSummary = z6.object({
   id: Id,
   mailing_id: Id.nullable(),
   recipient_id: Id.nullable(),
   contact_id: Id.nullable(),
   to: Email,
-  subject: z5.string(),
+  subject: z6.string(),
   provider_id: Id,
-  provider_message_id: z5.string().nullable(),
+  provider_message_id: z6.string().nullable(),
   outcome: MessageOutcome,
-  error: z5.string().nullable(),
-  is_test: z5.boolean(),
-  recipient_count: z5.number().int().min(1),
+  error: z6.string().nullable(),
+  is_test: z6.boolean(),
+  recipient_count: z6.number().int().min(1),
+  /** The language version the message was sent in; null for messages archived before languages existed. */
+  locale: LocaleTag.nullable(),
+  /**
+   * The choice each of the template's insertions made for this recipient
+   * (`{ opening: { value: "venue", chosen: "venue", matched: true } }`);
+   * `matched: false` is a filled value no choice took, sent with the
+   * "otherwise" text. Null when the message had no insertions.
+   */
+  insertions: InsertionChoices.nullable(),
   created_at: Timestamp
 });
-var Message = MessageSummary.extend({ html: z5.string() });
+var Message = MessageSummary.extend({ html: z6.string() });
+var MailingLanguageStatus = z6.enum(["main", "ready", "draft", "not_a_workspace_language"]);
+var MailingLanguage = z6.object({
+  locale: LocaleTag,
+  status: MailingLanguageStatus,
+  /** Queued recipients who will get this version. */
+  planned: z6.number().int().min(0),
+  /** Messages already sent in this language (tests excluded). */
+  sent: z6.number().int().min(0)
+});
+var MailingLanguageReport = z6.object({
+  main_locale: LocaleTag,
+  send_locale: LocaleTag.nullable(),
+  languages: z6.array(MailingLanguage),
+  fallback: z6.array(z6.object({ wanted: z6.string(), planned: z6.number().int().min(1) })),
+  no_language: z6.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
+   * insertion and value, the queued recipients who send it (`planned`) and the
+   * messages that went out with it (`sent`). A client whose form offers the
+   * template's keys never produces one; a non-empty list means the client and
+   * the template have drifted apart.
+   */
+  insertion_misses: z6.array(
+    z6.object({
+      insertion: z6.string(),
+      value: z6.string(),
+      planned: z6.number().int().min(0),
+      sent: z6.number().int().min(0)
+    })
+  )
+});
 var MessageListQuery = PageQuery.extend({
   mailing_id: Id.optional(),
   outcome: MessageOutcome.optional()
 });
 
 // src/platform.ts
-var Tag = z6.object({
+var Tag = z7.object({
   id: Id,
   slug: Slug,
-  name: z6.string().min(1).max(120),
-  contact_count: z6.number().int().min(0),
+  name: z7.string().min(1).max(120),
+  contact_count: z7.number().int().min(0),
   created_at: Timestamp
 });
-var TagCreate = z6.object({ slug: Slug, name: z6.string().min(1).max(120) });
-var TagAssignment = z6.object({
-  contact_ids: z6.array(Id).min(1).max(1e3)
+var TagCreate = z7.object({ slug: Slug, name: z7.string().min(1).max(120) });
+var TagAssignment = z7.object({
+  contact_ids: z7.array(Id).min(1).max(1e3)
 });
 var CONTACT_PROPERTY_TYPES = ["string", "number", "boolean", "date"];
-var ContactPropertyType = z6.enum(CONTACT_PROPERTY_TYPES);
-var ContactPropertyKey = z6.string().regex(/^[A-Za-z0-9_.-]{1,64}$/, "letters, digits, dot, underscore and hyphen, 1 to 64");
-var ContactPropertyDefinition = z6.object({
+var ContactPropertyType = z7.enum(CONTACT_PROPERTY_TYPES);
+var ContactPropertyKey = z7.string().regex(/^[A-Za-z0-9_.-]{1,64}$/, "letters, digits, dot, underscore and hyphen, 1 to 64");
+var ContactPropertyDefinition = z7.object({
   key: ContactPropertyKey,
-  label: z6.string().min(1).max(120),
+  label: z7.string().min(1).max(120),
   type: ContactPropertyType
 });
-var ContactPropertyParams = z6.object({ key: ContactPropertyKey });
+var ContactPropertyParams = z7.object({ key: ContactPropertyKey });
 var FILTER_OPERATORS = [
   "eq",
   "neq",
@@ -626,8 +1083,8 @@ var FILTER_OPERATORS = [
   "in",
   "not_in"
 ];
-var FilterOperator = z6.enum(FILTER_OPERATORS);
-var FilterField = z6.string().regex(
+var FilterOperator = z7.enum(FILTER_OPERATORS);
+var FilterField = z7.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"
 );
@@ -643,18 +1100,18 @@ var FILTER_FIELD_OPERATORS = {
   property: FILTER_OPERATORS
 };
 var MAX_FILTER_DEPTH = 5;
-var FilterCondition = z6.object({ field: FilterField, op: FilterOperator, value: JsonValue.optional() }).strict().refine((c) => (c.op === "exists" || c.op === "not_exists") === (c.value === void 0), {
+var FilterCondition = z7.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 = z6.lazy(
-  () => z6.union([
-    z6.object({ and: z6.array(SegmentFilter).min(1).max(50) }).strict(),
-    z6.object({ or: z6.array(SegmentFilter).min(1).max(50) }).strict(),
-    z6.object({ not: SegmentFilter }).strict(),
+var SegmentFilter = z7.lazy(
+  () => z7.union([
+    z7.object({ and: z7.array(SegmentFilter).min(1).max(50) }).strict(),
+    z7.object({ or: z7.array(SegmentFilter).min(1).max(50) }).strict(),
+    z7.object({ not: SegmentFilter }).strict(),
     FilterCondition
   ])
 );
@@ -742,42 +1199,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 = z6.object({
+var Segment = z7.object({
   id: Id,
-  name: z6.string().min(1).max(120),
+  name: z7.string().min(1).max(120),
   filter: SegmentFilter,
   /** Computed on read. */
-  contact_count: z6.number().int().min(0),
+  contact_count: z7.number().int().min(0),
   created_at: Timestamp,
   updated_at: Timestamp
 });
-var SegmentCreate = z6.object({ name: z6.string().min(1).max(120), filter: BoundedSegmentFilter });
-var SegmentPreviewRequest = z6.object({ filter: BoundedSegmentFilter });
-var SegmentPreview = z6.object({
-  contact_count: z6.number().int().min(0),
+var SegmentCreate = z7.object({ name: z7.string().min(1).max(120), filter: BoundedSegmentFilter });
+var SegmentPreviewRequest = z7.object({ filter: BoundedSegmentFilter });
+var SegmentPreview = z7.object({
+  contact_count: z7.number().int().min(0),
   /** Up to five matching contacts, for a human to sanity-check the filter. */
-  sample: z6.array(z6.object({ id: Id, email: Email })).max(5)
+  sample: z7.array(z7.object({ id: Id, email: Email })).max(5)
 });
-var MailingAudienceFromSegment = z6.object({ segment_id: Id });
+var MailingAudienceFromSegment = z7.object({ segment_id: Id });
 var SIGNUP_FORM_FIELDS = ["first_name", "last_name"];
 var HOSTED_PAGE_LOCALES = ["en", "de", "it", "fr", "es"];
-var SignupFormTranslation = z6.object({
-  title: z6.string().min(1).max(120),
-  consent_text: z6.string().min(1).max(2e3)
+var SignupFormTranslation = z7.object({
+  title: z7.string().min(1).max(120),
+  consent_text: z7.string().min(1).max(2e3)
 });
-var SignupForm = z6.object({
+var SignupForm = z7.object({
   id: Id,
-  name: z6.string().min(1).max(120),
+  name: z7.string().min(1).max(120),
   /** The heading of the hosted page. */
-  title: z6.string().min(1).max(120),
+  title: z7.string().min(1).max(120),
   /** What the person agrees to, shown above the button and recorded with the confirmation. */
-  consent_text: z6.string().min(1).max(2e3),
-  translations: z6.record(SignupFormTranslation),
-  topics: z6.array(Slug).min(1),
-  tags: z6.array(Slug),
+  consent_text: z7.string().min(1).max(2e3),
+  translations: z7.record(SignupFormTranslation),
+  topics: z7.array(Slug).min(1),
+  tags: z7.array(Slug),
   /** Fields shown besides email. */
-  fields: z6.array(z6.enum(SIGNUP_FORM_FIELDS)),
-  double_opt_in: z6.literal(true),
+  fields: z7.array(z7.enum(SIGNUP_FORM_FIELDS)),
+  double_opt_in: z7.literal(true),
   /** The provider the confirmation mail is sent through. */
   provider_id: Id,
   /**
@@ -786,11 +1243,11 @@ var SignupForm = z6.object({
    */
   confirmation_template_id: Id.nullable(),
   /** Where the person lands after confirming. Null shows the hosted confirmation page. */
-  redirect_url: z6.string().url().nullable(),
+  redirect_url: z7.string().url().nullable(),
   /** Origins allowed to embed the form and call the submission route from a browser. */
-  allowed_origins: z6.array(z6.string().url()).max(20),
+  allowed_origins: z7.array(z7.string().url()).max(20),
   /** Bumped on every change; recorded with each confirmation. */
-  version: z6.number().int().min(1),
+  version: z7.number().int().min(1),
   created_at: Timestamp,
   updated_at: Timestamp
 });
@@ -805,56 +1262,56 @@ var SignupFormCreate = SignupForm.omit({
   tags: SignupForm.shape.tags.optional(),
   fields: SignupForm.shape.fields.optional(),
   confirmation_template_id: Id.nullable().optional(),
-  redirect_url: z6.string().url().nullable().optional(),
+  redirect_url: z7.string().url().nullable().optional(),
   allowed_origins: SignupForm.shape.allowed_origins.optional()
 });
-var SignupFormEmbed = z6.object({
-  hosted_url: z6.string().url(),
+var SignupFormEmbed = z7.object({
+  hosted_url: z7.string().url(),
   /** A plain HTML form posting to the hosted page; works without JavaScript. */
-  html: z6.string(),
+  html: z7.string(),
   /** A small optional script that adds the time check and submits in place. */
-  script_url: z6.string().url(),
+  script_url: z7.string().url(),
   /** Where a browser fetches a fresh `form_token` from (GET, public, CORS for `allowed_origins`). */
-  token_url: z6.string().url()
+  token_url: z7.string().url()
 });
-var SignupSubmission = z6.object({
+var SignupSubmission = z7.object({
   email: Email,
-  first_name: z6.string().max(200).optional(),
-  last_name: z6.string().max(200).optional(),
-  locale: z6.string().min(2).max(35).optional(),
+  first_name: z7.string().max(200).optional(),
+  last_name: z7.string().max(200).optional(),
+  locale: z7.string().min(2).max(35).optional(),
   /** Honeypot: must be empty. */
-  website: z6.string().max(0).optional(),
+  website: z7.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: z6.string().min(1).max(512)
+  form_token: z7.string().min(1).max(512)
 });
 var IMPORT_STATUSES = ["uploaded", "validating", "validated", "committing", "completed", "failed", "cancelled"];
-var ImportStatus = z6.enum(IMPORT_STATUSES);
+var ImportStatus = z7.enum(IMPORT_STATUSES);
 var IMPORT_TERMINAL_STATUSES = ["completed", "failed", "cancelled"];
-var ImportColumnMapping = z6.record(
-  z6.string().regex(/^(email|external_id|first_name|last_name|locale|property:[A-Za-z0-9_.-]{1,64}|ignore)$/)
+var ImportColumnMapping = z7.record(
+  z7.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 = z6.object({
+var ImportMappingRequest = z7.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: z6.array(Slug).max(100),
-  tags: z6.array(Slug).max(100),
+  topics: z7.array(Slug).max(100),
+  tags: z7.array(Slug).max(100),
   /** Existing contacts get the mapped fields overwritten; false only adds topics, tags and missing fields. */
-  update_existing: z6.boolean().optional(),
+  update_existing: z7.boolean().optional(),
   /** The importer states the people consented; the service records who said so and when. */
-  consent_confirmed: z6.literal(true)
+  consent_confirmed: z7.literal(true)
 });
-var ImportCommitRequest = z6.object({ mapping_version: z6.number().int().min(1) });
+var ImportCommitRequest = z7.object({ mapping_version: z7.number().int().min(1) });
 var IMPORT_ROW_OUTCOMES = ["created", "updated", "unchanged", "suppressed", "skipped"];
-var ImportRowOutcome = z6.enum(IMPORT_ROW_OUTCOMES);
+var ImportRowOutcome = z7.enum(IMPORT_ROW_OUTCOMES);
 var IMPORT_SKIP_REASONS = [
   "missing_email",
   "invalid_email",
@@ -863,90 +1320,90 @@ var IMPORT_SKIP_REASONS = [
   "external_id_conflict",
   "wrong_column_count"
 ];
-var ImportSkipReason = z6.enum(IMPORT_SKIP_REASONS);
-var ImportReport = z6.object({
-  created: z6.number().int().min(0),
-  updated: z6.number().int().min(0),
-  unchanged: z6.number().int().min(0),
-  suppressed: z6.number().int().min(0),
-  skipped: z6.number().int().min(0),
-  skipped_by_reason: z6.record(ImportSkipReason, z6.number().int().min(0)),
+var ImportSkipReason = z7.enum(IMPORT_SKIP_REASONS);
+var ImportReport = z7.object({
+  created: z7.number().int().min(0),
+  updated: z7.number().int().min(0),
+  unchanged: z7.number().int().min(0),
+  suppressed: z7.number().int().min(0),
+  skipped: z7.number().int().min(0),
+  skipped_by_reason: z7.record(ImportSkipReason, z7.number().int().min(0)),
   /** Rows whose contact was subscribed without some topic, because the address is blocked for it. */
-  topics_withheld: z6.number().int().min(0)
+  topics_withheld: z7.number().int().min(0)
 });
-var ImportJob = z6.object({
+var ImportJob = z7.object({
   id: Id,
   status: ImportStatus,
-  file_name: z6.string().max(255).nullable(),
-  file_bytes: z6.number().int().min(0),
-  total_rows: z6.number().int().min(0),
+  file_name: z7.string().max(255).nullable(),
+  file_bytes: z7.number().int().min(0),
+  total_rows: z7.number().int().min(0),
   /** The header row, as in the file. */
-  columns: z6.array(z6.string()),
+  columns: z7.array(z7.string()),
   /** The first rows, for the mapping screen. */
-  sample: z6.array(z6.array(z6.string())).max(5),
+  sample: z7.array(z7.array(z7.string())).max(5),
   /** A mapping guessed from the headers, for the mapping screen to start from. */
   suggested_mapping: ImportColumnMapping,
   mapping: ImportColumnMapping.nullable(),
-  mapping_version: z6.number().int().min(0),
-  topics: z6.array(Slug),
-  tags: z6.array(Slug),
-  update_existing: z6.boolean(),
+  mapping_version: z7.number().int().min(0),
+  topics: z7.array(Slug),
+  tags: z7.array(Slug),
+  update_existing: z7.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: z6.number().int().min(0),
+  processed_rows: z7.number().int().min(0),
   /** Why a `failed` import failed. */
-  error: z6.string().nullable(),
+  error: z7.string().nullable(),
   created_at: Timestamp,
   updated_at: Timestamp,
   finished_at: Timestamp.nullable()
 });
-var ImportRow = z6.object({
+var ImportRow = z7.object({
   /** The line in the file, 1 being the first line after the header. */
-  row: z6.number().int().min(1),
-  email: z6.string().nullable(),
+  row: z7.number().int().min(1),
+  email: z7.string().nullable(),
   outcome: ImportRowOutcome,
   reason: ImportSkipReason.nullable(),
   /** A human explanation for a skipped row (which value, which column). */
-  message: z6.string().nullable(),
+  message: z7.string().nullable(),
   contact_id: Id.nullable()
 });
 var ImportRowListQuery = PageQuery.extend({ outcome: ImportRowOutcome.optional() });
-var MailingScheduleRequest = z6.object({ send_at: Timestamp });
-var TrackingSettings = z6.object({ opens: z6.boolean(), clicks: z6.boolean() });
-var VariantAnalytics = z6.object({
-  key: z6.string(),
-  sent: z6.number().int().min(0),
-  unique_opens: z6.number().int().min(0).nullable(),
-  unique_clicks: z6.number().int().min(0).nullable()
-});
-var MailingAnalytics = z6.object({
+var MailingScheduleRequest = z7.object({ send_at: Timestamp });
+var TrackingSettings = z7.object({ opens: z7.boolean(), clicks: z7.boolean() });
+var VariantAnalytics = z7.object({
+  key: z7.string(),
+  sent: z7.number().int().min(0),
+  unique_opens: z7.number().int().min(0).nullable(),
+  unique_clicks: z7.number().int().min(0).nullable()
+});
+var MailingAnalytics = z7.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: z6.number().int().min(0).nullable(),
+  unique_opens: z7.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: z6.number().int().min(0).nullable(),
+  apple_mpp_opens: z7.number().int().min(0).nullable(),
   /** Opens and clicks from security scanners and prefetchers, filtered out of the unique counts. */
-  machine_events: z6.number().int().min(0).nullable(),
-  unique_clicks: z6.number().int().min(0).nullable(),
-  unsubscribes: z6.number().int().min(0),
-  bounces: z6.number().int().min(0),
-  complaints: z6.number().int().min(0),
-  links: z6.array(z6.object({ url: z6.string(), unique_clicks: z6.number().int().min(0) })).nullable(),
-  variants: z6.array(VariantAnalytics).nullable()
+  machine_events: z7.number().int().min(0).nullable(),
+  unique_clicks: z7.number().int().min(0).nullable(),
+  unsubscribes: z7.number().int().min(0),
+  bounces: z7.number().int().min(0),
+  complaints: z7.number().int().min(0),
+  links: z7.array(z7.object({ url: z7.string(), unique_clicks: z7.number().int().min(0) })).nullable(),
+  variants: z7.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 = z7.string().regex(AUTOMATION_FILTER_FIELD_PATTERN, "unknown filter field");
+var AutomationFilterField = z8.string().regex(AUTOMATION_FILTER_FIELD_PATTERN, "unknown filter field");
 var AUTOMATION_FILTER_FIELD_OPERATORS = {
   ...FILTER_FIELD_OPERATORS,
   segment: ["eq", "neq", "in", "not_in"],
@@ -956,18 +1413,18 @@ var AUTOMATION_FILTER_FIELD_OPERATORS = {
   step: ["eq", "neq"]
 };
 var automationFilterFamily = filterFieldFamily;
-var AutomationFilterCondition = z7.object({ field: AutomationFilterField, op: FilterOperator, value: JsonValue.optional() }).strict().refine((c) => (c.op === "exists" || c.op === "not_exists") === (c.value === void 0), {
+var AutomationFilterCondition = z8.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 = z7.lazy(
-  () => z7.union([
-    z7.object({ and: z7.array(AutomationFilter).min(1).max(50) }).strict(),
-    z7.object({ or: z7.array(AutomationFilter).min(1).max(50) }).strict(),
-    z7.object({ not: AutomationFilter }).strict(),
+var AutomationFilter = z8.lazy(
+  () => z8.union([
+    z8.object({ and: z8.array(AutomationFilter).min(1).max(50) }).strict(),
+    z8.object({ or: z8.array(AutomationFilter).min(1).max(50) }).strict(),
+    z8.object({ not: AutomationFilter }).strict(),
     AutomationFilterCondition
   ])
 );
@@ -980,20 +1437,20 @@ function filterConditions(filter) {
   if ("not" in filter) return filterConditions(filter.not);
   return [filter];
 }
-var StepId = z7.string().regex(/^[A-Za-z0-9_-]{1,64}$/, "letters, digits, underscore and hyphen, 1 to 64");
-var TimeOfDay = z7.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "HH:MM in 24 hours");
-var Weekday = z7.number().int().min(0).max(6);
-var TimezoneName = z7.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 = z8.string().regex(/^[A-Za-z0-9_-]{1,64}$/, "letters, digits, underscore and hyphen, 1 to 64");
+var TimeOfDay = z8.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "HH:MM in 24 hours");
+var Weekday = z8.number().int().min(0).max(6);
+var TimezoneName = z8.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 = z7.string().regex(/^\d{4}-\d{2}-\d{2}$/, "a calendar date such as 2026-09-20").refine((v) => {
+var DateOnly = z8.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 = z7.number().int().min(-365).max(365);
+var OffsetDays = z8.number().int().min(-365).max(365);
 var DATE_PASSED_ANSWERS = ["skip", "stop", "continue"];
-var DatePassedAnswer = z7.enum(DATE_PASSED_ANSWERS);
-var EventName = z7.string().regex(/^[A-Za-z0-9][A-Za-z0-9_.:-]{0,79}$/, "letters, digits, dot, colon, underscore and hyphen, 1 to 80");
+var DatePassedAnswer = z8.enum(DATE_PASSED_ANSWERS);
+var EventName = z8.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",
@@ -1006,17 +1463,17 @@ var AUTOMATION_TRIGGER_KINDS = [
   "segment_entered",
   "link_clicked"
 ];
-var AutomationTriggerKind = z7.enum(AUTOMATION_TRIGGER_KINDS);
+var AutomationTriggerKind = z8.enum(AUTOMATION_TRIGGER_KINDS);
 var exclude = { exclude: BoundedAutomationFilter.nullish() };
-var AutomationTrigger = z7.discriminatedUnion("kind", [
-  z7.object({ kind: z7.literal("topic_subscribed"), topic: Slug, ...exclude }).strict(),
-  z7.object({ kind: z7.literal("form_confirmed"), form_id: Id, ...exclude }).strict(),
-  z7.object({ kind: z7.literal("tag_added"), tag: Slug, ...exclude }).strict(),
+var AutomationTrigger = z8.discriminatedUnion("kind", [
+  z8.object({ kind: z8.literal("topic_subscribed"), topic: Slug, ...exclude }).strict(),
+  z8.object({ kind: z8.literal("form_confirmed"), form_id: Id, ...exclude }).strict(),
+  z8.object({ kind: z8.literal("tag_added"), tag: Slug, ...exclude }).strict(),
   /** `to` given: only a change that lands on this value fires. Absent: any change of the key. */
-  z7.object({ kind: z7.literal("property_changed"), key: ContactPropertyKey, to: JsonValue.optional(), ...exclude }).strict(),
+  z8.object({ kind: z8.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. */
-  z7.object({ kind: z7.literal("event"), name: EventName, where: BoundedAutomationFilter.nullish(), ...exclude }).strict(),
-  z7.object({ kind: z7.literal("manual"), ...exclude }).strict(),
+  z8.object({ kind: z8.literal("event"), name: EventName, where: BoundedAutomationFilter.nullish(), ...exclude }).strict(),
+  z8.object({ kind: z8.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
@@ -1026,8 +1483,8 @@ var AutomationTrigger = z7.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.
    */
-  z7.object({
-    kind: z7.literal("date_anniversary"),
+  z8.object({
+    kind: z8.literal("date_anniversary"),
     key: ContactPropertyKey,
     offset_days: OffsetDays,
     at: TimeOfDay,
@@ -1039,8 +1496,8 @@ var AutomationTrigger = z7.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.
    */
-  z7.object({
-    kind: z7.literal("exact_date"),
+  z8.object({
+    kind: z8.literal("exact_date"),
     on: DateOnly,
     at: TimeOfDay,
     where: BoundedAutomationFilter.nullish(),
@@ -1059,7 +1516,7 @@ var AutomationTrigger = z7.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.
    */
-  z7.object({ kind: z7.literal("segment_entered"), segment_id: Id, ...exclude }).strict(),
+  z8.object({ kind: z8.literal("segment_entered"), segment_id: Id, ...exclude }).strict(),
   /**
    * S4. When somebody clicks a link in a mailing that has already gone out.
    *
@@ -1069,7 +1526,7 @@ var AutomationTrigger = z7.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.
    */
-  z7.object({ kind: z7.literal("link_clicked"), mailing_id: Id, url: z7.string().min(1).max(2048).optional(), ...exclude }).strict()
+  z8.object({ kind: z8.literal("link_clicked"), mailing_id: Id, url: z8.string().min(1).max(2048).optional(), ...exclude }).strict()
 ]);
 var AUTOMATION_DATE_TRIGGER_KINDS = ["date_anniversary", "exact_date"];
 var MAX_TRIGGERS = 10;
@@ -1088,34 +1545,45 @@ var AUTOMATION_STEP_KINDS = [
   "webhook",
   "notify"
 ];
-var AutomationStepKind = z7.enum(AUTOMATION_STEP_KINDS);
+var AutomationStepKind = z8.enum(AUTOMATION_STEP_KINDS);
 var next = { next: StepId.nullable() };
-var Unchosen = z7.literal("");
-var DraftSlug = z7.union([Slug, Unchosen]);
-var DraftPropertyKey = z7.union([ContactPropertyKey, Unchosen]);
-var label = { label: z7.string().max(120).nullish() };
-var EmailStep = z7.object({
-  kind: z7.literal("email"),
+var Unchosen = z8.literal("");
+var DraftSlug = z8.union([Slug, Unchosen]);
+var DraftPropertyKey = z8.union([ContactPropertyKey, Unchosen]);
+var label = { label: z8.string().max(120).nullish() };
+var EmailStepLanguage = z8.object({
+  subject: z8.string().min(1).max(998),
+  preheader: z8.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 = z8.object({
+  kind: z8.literal("email"),
   ...label,
   ...next,
   template_id: Id.nullish(),
   document: TemplateDocument.nullish(),
-  /** Empty while the step is being written; `not_chosen` refuses to publish it. */
-  subject: z7.string().max(998),
-  preheader: z7.string().max(500).nullish()
+  /** Empty while the step is being written, or when its template has a subject; else `not_chosen` refuses to publish it. */
+  subject: z8.string().max(998),
+  preheader: z8.string().max(500).nullish(),
+  locale: LocaleTag.nullish(),
+  languages: z8.record(LocaleTag, EmailStepLanguage).nullish(),
+  /** The main language's insertions, snapshot from the template when the automation is published. */
+  insertions: Insertions.nullish()
 }).strict();
-var DelayStep = z7.object({
-  kind: z7.literal("delay"),
+var DelayStep = z8.object({
+  kind: z8.literal("delay"),
   ...label,
   ...next,
-  wait: z7.discriminatedUnion("mode", [
-    z7.object({ mode: z7.literal("duration"), seconds: z7.number().int().min(1).max(MAX_DELAY_SECONDS) }).strict(),
-    z7.object({ mode: z7.literal("time_of_day"), at: TimeOfDay }).strict(),
-    z7.object({ mode: z7.literal("weekday"), weekday: Weekday, at: TimeOfDay }).strict(),
+  wait: z8.discriminatedUnion("mode", [
+    z8.object({ mode: z8.literal("duration"), seconds: z8.number().int().min(1).max(MAX_DELAY_SECONDS) }).strict(),
+    z8.object({ mode: z8.literal("time_of_day"), at: TimeOfDay }).strict(),
+    z8.object({ mode: z8.literal("weekday"), weekday: Weekday, at: TimeOfDay }).strict(),
     /** A fixed day has no next occurrence, so `continue` is not one of its answers. */
-    z7.object({ mode: z7.literal("date"), on: DateOnly, at: TimeOfDay, passed: z7.enum(["skip", "stop"]) }).strict(),
-    z7.object({
-      mode: z7.literal("date_property"),
+    z8.object({ mode: z8.literal("date"), on: DateOnly, at: TimeOfDay, passed: z8.enum(["skip", "stop"]) }).strict(),
+    z8.object({
+      mode: z8.literal("date_property"),
       key: ContactPropertyKey,
       offset_days: OffsetDays,
       at: TimeOfDay,
@@ -1123,8 +1591,8 @@ var DelayStep = z7.object({
     }).strict()
   ])
 }).strict();
-var ConditionStep = z7.object({
-  kind: z7.literal("condition"),
+var ConditionStep = z8.object({
+  kind: z8.literal("condition"),
   ...label,
   filter: BoundedAutomationFilter,
   yes: StepId.nullable(),
@@ -1135,49 +1603,49 @@ var ConditionStep = z7.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: z7.object({ up_to_s: z7.number().int().min(1).max(MAX_DELAY_SECONDS), on_timeout: z7.enum(["yes", "no"]) }).strict().nullish()
+  wait_for: z8.object({ up_to_s: z8.number().int().min(1).max(MAX_DELAY_SECONDS), on_timeout: z8.enum(["yes", "no"]) }).strict().nullish()
 }).strict();
-var SplitBranchKey = z7.string().regex(/^[A-Za-z0-9_-]{1,32}$/, "letters, digits, underscore and hyphen, 1 to 32");
+var SplitBranchKey = z8.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 = z7.object({
-  kind: z7.literal("split"),
+var SplitStep = z8.object({
+  kind: z8.literal("split"),
   ...label,
-  branches: z7.array(
-    z7.object({
+  branches: z8.array(
+    z8.object({
       key: SplitBranchKey,
       /** A whole percentage. Zero is allowed: a branch kept in the flow but switched off. */
-      weight: z7.number().int().min(0).max(100),
+      weight: z8.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 = z7.object({ kind: z7.literal("goto"), ...label, target: StepId.nullable() }).strict();
+var GotoStep = z8.object({ kind: z8.literal("goto"), ...label, target: StepId.nullable() }).strict();
 var MAX_STEP_VISITS = 20;
-var WebhookStep = z7.object({ kind: z7.literal("webhook"), ...label, ...next, endpoint_id: Id.nullable(), payload: JsonValue.nullish() }).strict();
-var NotifyRecipients = z7.union([z7.literal("owner"), z7.literal("admins"), z7.object({ member_id: Id }).strict()]);
-var NotifyStep = z7.object({
-  kind: z7.literal("notify"),
+var WebhookStep = z8.object({ kind: z8.literal("webhook"), ...label, ...next, endpoint_id: Id.nullable(), payload: JsonValue.nullish() }).strict();
+var NotifyRecipients = z8.union([z8.literal("owner"), z8.literal("admins"), z8.object({ member_id: Id }).strict()]);
+var NotifyStep = z8.object({
+  kind: z8.literal("notify"),
   ...label,
   ...next,
   to: NotifyRecipients,
   /** Empty while the step is being written; `not_chosen` refuses to publish it. */
-  subject: z7.string().max(998),
-  body: z7.string().max(1e4)
+  subject: z8.string().max(998),
+  body: z8.string().max(1e4)
 }).strict();
-var AutomationStep = z7.discriminatedUnion("kind", [
+var AutomationStep = z8.discriminatedUnion("kind", [
   EmailStep,
   DelayStep,
   ConditionStep,
-  z7.object({ kind: z7.literal("add_tag"), ...label, ...next, tag: DraftSlug }).strict(),
-  z7.object({ kind: z7.literal("remove_tag"), ...label, ...next, tag: DraftSlug }).strict(),
+  z8.object({ kind: z8.literal("add_tag"), ...label, ...next, tag: DraftSlug }).strict(),
+  z8.object({ kind: z8.literal("remove_tag"), ...label, ...next, tag: DraftSlug }).strict(),
   /** `value` null clears the property, as a contact upsert does. */
-  z7.object({ kind: z7.literal("set_property"), ...label, ...next, key: DraftPropertyKey, value: JsonValue }).strict(),
+  z8.object({ kind: z8.literal("set_property"), ...label, ...next, key: DraftPropertyKey, value: JsonValue }).strict(),
   /** Subscribing never lifts a suppression: the service checks that, not the flow. */
-  z7.object({ kind: z7.literal("subscribe_topic"), ...label, ...next, topic: DraftSlug }).strict(),
+  z8.object({ kind: z8.literal("subscribe_topic"), ...label, ...next, topic: DraftSlug }).strict(),
   /** `topic` unsubscribes from the automation's own topic, `all` from every topic. */
-  z7.object({ kind: z7.literal("unsubscribe"), ...label, ...next, scope: z7.enum(["topic", "all"]) }).strict(),
-  z7.object({ kind: z7.literal("exit"), ...label }).strict(),
+  z8.object({ kind: z8.literal("unsubscribe"), ...label, ...next, scope: z8.enum(["topic", "all"]) }).strict(),
+  z8.object({ kind: z8.literal("exit"), ...label }).strict(),
   SplitStep,
   GotoStep,
   WebhookStep,
@@ -1201,25 +1669,25 @@ function stepTargets(step) {
   }
 }
 var MAX_STEPS = 200;
-var AutomationFlow = z7.object({
-  triggers: z7.array(AutomationTrigger).max(MAX_TRIGGERS),
+var AutomationFlow = z8.object({
+  triggers: z8.array(AutomationTrigger).max(MAX_TRIGGERS),
   /** The first step. `null` is an empty flow. */
   entry: StepId.nullable(),
-  steps: z7.record(StepId, AutomationStep)
+  steps: z8.record(StepId, AutomationStep)
 }).strict();
 var emptyFlow = () => ({ triggers: [], entry: null, steps: {} });
-var QuietHours = z7.object({
+var QuietHours = z8.object({
   start: TimeOfDay,
   end: TimeOfDay,
-  weekdays: z7.array(Weekday).min(1).max(7).nullish()
+  weekdays: z8.array(Weekday).min(1).max(7).nullish()
 }).strict();
 var RE_ENTRY_MODES = ["off", "after_exit"];
-var ReEntryMode = z7.enum(RE_ENTRY_MODES);
+var ReEntryMode = z8.enum(RE_ENTRY_MODES);
 var MAX_RE_ENTRY_COOLDOWN_SECONDS = 365 * 24 * 60 * 60;
-var AutomationSettings = z7.object({
+var AutomationSettings = z8.object({
   re_entry: ReEntryMode,
   /** Seconds a person must wait after leaving before entering again. Only with `after_exit`. */
-  re_entry_cooldown_s: z7.number().int().min(0).max(MAX_RE_ENTRY_COOLDOWN_SECONDS).nullish(),
+  re_entry_cooldown_s: z8.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()
@@ -1277,18 +1745,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 = z7.enum(AUTOMATION_ISSUE_CODES);
-var AutomationIssue = z7.object({
+var AutomationIssueCode = z8.enum(AUTOMATION_ISSUE_CODES);
+var AutomationIssue = z8.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: z7.array(z7.union([z7.string(), z7.number()])),
-  message: z7.string()
+  path: z8.array(z8.union([z8.string(), z8.number()])),
+  message: z8.string()
 });
-var AutomationValidation = z7.object({
-  ok: z7.boolean(),
-  issues: z7.array(AutomationIssue)
+var AutomationValidation = z8.object({
+  ok: z8.boolean(),
+  issues: z8.array(AutomationIssue)
 });
 function validateAutomation(flow, settings, ctx) {
   const issues = [];
@@ -1408,7 +1876,7 @@ function validateAutomation(flow, settings, ctx) {
         if (!step.template_id && !step.document) {
           add({ code: "empty_email", step_id: id, path: [...path, "template_id"], message: "This email has neither a template nor content." });
         }
-        if (step.subject.trim() === "") {
+        if (step.subject.trim() === "" && !(step.template_id && known.templates_with_subject?.has(step.template_id))) {
           add({ code: "not_chosen", step_id: id, path: [...path, "subject"], message: "This email has no subject line." });
         }
         if (step.template_id) checkRef(known.templates, step.template_id, "template", [...path, "template_id"], add, id);
@@ -1679,7 +2147,7 @@ function cycles(flow) {
   return out.sort();
 }
 var AUTOMATION_STATUSES = ["draft", "active", "paused", "archived"];
-var AutomationStatus = z7.enum(AUTOMATION_STATUSES);
+var AutomationStatus = z8.enum(AUTOMATION_STATUSES);
 var AUTOMATION_END_REASONS = [
   "completed",
   "exit_filter",
@@ -1698,9 +2166,9 @@ var AUTOMATION_END_REASONS = [
   "ended_by_hand",
   "failed"
 ];
-var AutomationEndReason = z7.enum(AUTOMATION_END_REASONS);
+var AutomationEndReason = z8.enum(AUTOMATION_END_REASONS);
 var AUTOMATION_WAIT_REASONS = ["delay", "quiet_hours", "plan_limit", "sending", "condition"];
-var AutomationWaitReason = z7.enum(AUTOMATION_WAIT_REASONS);
+var AutomationWaitReason = z8.enum(AUTOMATION_WAIT_REASONS);
 var AUTOMATION_ENTRY_REFUSALS = [
   "already_inside",
   "re_entry_off",
@@ -1711,26 +2179,26 @@ var AUTOMATION_ENTRY_REFUSALS = [
   "not_active",
   "unknown_contact"
 ];
-var AutomationEntryRefusal = z7.enum(AUTOMATION_ENTRY_REFUSALS);
-var AutomationCounts = z7.object({
-  started: z7.number().int().min(0),
-  in_progress: z7.number().int().min(0),
-  completed: z7.number().int().min(0),
-  exited: z7.number().int().min(0),
-  failed: z7.number().int().min(0)
-});
-var Automation = z7.object({
+var AutomationEntryRefusal = z8.enum(AUTOMATION_ENTRY_REFUSALS);
+var AutomationCounts = z8.object({
+  started: z8.number().int().min(0),
+  in_progress: z8.number().int().min(0),
+  completed: z8.number().int().min(0),
+  exited: z8.number().int().min(0),
+  failed: z8.number().int().min(0)
+});
+var Automation = z8.object({
   id: Id,
-  name: z7.string().min(1).max(200),
+  name: z8.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: z7.number().int().min(1).nullable(),
+  published_version: z8.number().int().min(1).nullable(),
   /** The flow being edited. Increments on every save, like a template's version. */
-  draft_version: z7.number().int().min(1),
+  draft_version: z8.number().int().min(1),
   counts: AutomationCounts,
   created_at: Timestamp,
   updated_at: Timestamp,
@@ -1743,16 +2211,16 @@ var AutomationWithFlow = Automation.extend({
   published_flow: AutomationFlow.nullable()
 });
 var AutomationSummary = Automation;
-var AutomationCreate = z7.object({
-  name: z7.string().min(1).max(200),
+var AutomationCreate = z8.object({
+  name: z8.string().min(1).max(200),
   topic: Slug,
   provider_id: Id.optional(),
   flow: AutomationFlow.optional(),
   settings: AutomationSettings.partial().optional()
 });
-var AutomationUpdate = z7.object({
-  base_version: z7.number().int().min(1),
-  name: z7.string().min(1).max(200).optional(),
+var AutomationUpdate = z8.object({
+  base_version: z8.number().int().min(1),
+  name: z8.string().min(1).max(200).optional(),
   topic: Slug.optional(),
   provider_id: Id.optional(),
   flow: AutomationFlow.optional(),
@@ -1765,42 +2233,42 @@ var AutomationListQuery = PageQuery.extend({
   status: AutomationStatus.optional(),
   topic: Slug.optional()
 });
-var AutomationPublishRequest = z7.object({
+var AutomationPublishRequest = z8.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: z7.boolean().optional(),
-  confirm: z7.boolean().optional(),
+  dry_run: z8.boolean().optional(),
+  confirm: z8.boolean().optional(),
   /** Per removed step: the step its waiting runs move to, or null to end them. */
-  moves: z7.record(StepId, StepId.nullable()).optional(),
+  moves: z8.record(StepId, StepId.nullable()).optional(),
   /** Also enter everyone who matches a trigger's condition right now. */
-  backfill: z7.boolean().optional()
+  backfill: z8.boolean().optional()
 }).strict();
-var AutomationPublishMove = z7.object({
+var AutomationPublishMove = z8.object({
   step_id: StepId,
   /** Why the step's people have to move: it is gone, or its delay changed. */
-  change: z7.enum(["removed", "delay_changed", "kind_changed"]),
-  waiting: z7.number().int().min(0),
+  change: z8.enum(["removed", "delay_changed", "kind_changed"]),
+  waiting: z8.number().int().min(0),
   /** Where they go: a step id, or null to end their runs with `step_removed`. */
   destination: StepId.nullable()
 });
-var AutomationPublishResult = z7.object({
-  published: z7.boolean(),
+var AutomationPublishResult = z8.object({
+  published: z8.boolean(),
   automation: Automation,
   /** Empty when nothing has to move; non-empty and `published` false asks for a confirmation. */
-  moves: z7.array(AutomationPublishMove),
+  moves: z8.array(AutomationPublishMove),
   /** How many people the backfill entered, or would enter when it is not confirmed. */
-  backfill: z7.number().int().min(0),
-  issues: z7.array(AutomationIssue)
-});
-var AutomationDuplicateRequest = z7.object({ name: z7.string().min(1).max(200).optional() }).strict();
-var AutomationEnrollRequest = z7.object({
-  contact_ids: z7.array(Id).min(1).max(1e3).optional(),
-  external_ids: z7.array(z7.string().min(1).max(255)).min(1).max(1e3).optional(),
-  emails: z7.array(Email).min(1).max(1e3).optional(),
+  backfill: z8.number().int().min(0),
+  issues: z8.array(AutomationIssue)
+});
+var AutomationDuplicateRequest = z8.object({ name: z8.string().min(1).max(200).optional() }).strict();
+var AutomationEnrollRequest = z8.object({
+  contact_ids: z8.array(Id).min(1).max(1e3).optional(),
+  external_ids: z8.array(z8.string().min(1).max(255)).min(1).max(1e3).optional(),
+  emails: z8.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()
@@ -1808,34 +2276,34 @@ var AutomationEnrollRequest = z7.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 = z7.object({
+var AutomationEnrollment = z8.object({
   contact_id: Id.nullable(),
   email: Email.nullable(),
-  external_id: z7.string().nullable(),
-  entered: z7.boolean(),
+  external_id: z8.string().nullable(),
+  entered: z8.boolean(),
   run_id: Id.nullable(),
   reason: AutomationEntryRefusal.nullable()
 });
-var AutomationEnrollResult = z7.object({
-  entered: z7.number().int().min(0),
-  refused: z7.number().int().min(0),
-  results: z7.array(AutomationEnrollment)
+var AutomationEnrollResult = z8.object({
+  entered: z8.number().int().min(0),
+  refused: z8.number().int().min(0),
+  results: z8.array(AutomationEnrollment)
 });
-var AutomationRunStatus = z7.enum(["active", "waiting", "completed", "exited", "failed"]);
-var AutomationRun = z7.object({
+var AutomationRunStatus = z8.enum(["active", "waiting", "completed", "exited", "failed"]);
+var AutomationRun = z8.object({
   id: Id,
   automation_id: Id,
   contact_id: Id,
   email: Email,
-  external_id: z7.string().nullable(),
-  version: z7.number().int().min(1),
+  external_id: z8.string().nullable(),
+  version: z8.number().int().min(1),
   status: AutomationRunStatus,
   current_step_id: StepId.nullable(),
   next_action_at: Timestamp.nullable(),
   wait_reason: AutomationWaitReason.nullable(),
-  end_reason: z7.string().nullable(),
+  end_reason: z8.string().nullable(),
   /** What went wrong the last time this run tried to take its step, null otherwise. */
-  last_error: z7.string().nullable(),
+  last_error: z8.string().nullable(),
   entered_at: Timestamp,
   ended_at: Timestamp.nullable()
 });
@@ -1845,13 +2313,13 @@ var AutomationRunListQuery = PageQuery.extend({
   contact_id: Id.optional()
 });
 var ContactAutomationRun = AutomationRun.extend({
-  automation: z7.object({ id: Id, name: z7.string(), status: AutomationStatus })
+  automation: z8.object({ id: Id, name: z8.string(), status: AutomationStatus })
 });
 var ContactAutomationListQuery = PageQuery.extend({ status: AutomationRunStatus.optional() });
-var AutomationStepExecution = z7.object({
+var AutomationStepExecution = z8.object({
   step_id: StepId,
   step_kind: AutomationStepKind,
-  visit: z7.number().int().min(1),
+  visit: z8.number().int().min(1),
   started_at: Timestamp,
   finished_at: Timestamp.nullable(),
   /**
@@ -1863,48 +2331,48 @@ var AutomationStepExecution = z7.object({
    */
   outcome: Properties
 });
-var AutomationJourney = z7.object({
+var AutomationJourney = z8.object({
   run: AutomationRun,
-  steps: z7.array(AutomationStepExecution)
+  steps: z8.array(AutomationStepExecution)
 });
-var AutomationStepReport = z7.object({
+var AutomationStepReport = z8.object({
   step_id: StepId,
   step_kind: AutomationStepKind,
-  reached: z7.number().int().min(0),
-  waiting: z7.number().int().min(0),
-  passed: z7.number().int().min(0),
+  reached: z8.number().int().min(0),
+  waiting: z8.number().int().min(0),
+  passed: z8.number().int().min(0),
   /** Per branch, for a condition: how many took `yes` and how many `no`. */
-  branches: z7.record(z7.number().int().min(0)),
+  branches: z8.record(z8.number().int().min(0)),
   /** The step mailing's id, for an email step of the published version. */
   mailing_id: Id.nullable()
 });
-var AutomationReport = z7.object({
+var AutomationReport = z8.object({
   counts: AutomationCounts,
   /** Why the people who left did: `AutomationEndReason` to a count. */
-  end_reasons: z7.record(z7.number().int().min(0)),
+  end_reasons: z8.record(z8.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: z7.record(z7.number().int().min(0)),
-  steps: z7.array(AutomationStepReport)
-});
-var AutomationExitRunRequest = z7.object({ reason: z7.string().max(200).optional() }).strict();
-var AutomationRunParams = z7.object({ id: Id, run_id: Id });
-var AutomationStepParams = z7.object({ id: Id, step_id: StepId });
-var AutomationTestEmailRequest = z7.object({ to: Email, merge: Properties.optional() }).strict();
-var AutomationValidateRequest = z7.object({ flow: AutomationFlow.optional(), settings: AutomationSettings.partial().optional() }).strict();
-var EventCreate = z7.object({
+  refusals: z8.record(z8.number().int().min(0)),
+  steps: z8.array(AutomationStepReport)
+});
+var AutomationExitRunRequest = z8.object({ reason: z8.string().max(200).optional() }).strict();
+var AutomationRunParams = z8.object({ id: Id, run_id: Id });
+var AutomationStepParams = z8.object({ id: Id, step_id: StepId });
+var AutomationTestEmailRequest = z8.object({ to: Email, merge: Properties.optional(), locale: LocaleTag.optional() }).strict();
+var AutomationValidateRequest = z8.object({ flow: AutomationFlow.optional(), settings: AutomationSettings.partial().optional() }).strict();
+var EventCreate = z8.object({
   name: EventName,
-  contact: z7.object({ external_id: z7.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: z8.object({ external_id: z8.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: z7.string().min(1).max(128).optional()
+  id: z8.string().min(1).max(128).optional()
 }).strict();
-var Event = z7.object({
+var Event = z8.object({
   id: Id,
-  client_event_id: z7.string().nullable(),
+  client_event_id: z8.string().nullable(),
   name: EventName,
   contact_id: Id,
   data: Properties,
@@ -1915,59 +2383,42 @@ var Event = z7.object({
    * hand. Each is then admitted or refused by the runtime on its own rules
    * (consent, exclusions, re-entry), which `automations.report` counts.
    */
-  entered: z7.number().int().min(0)
+  entered: z8.number().int().min(0)
 });
 var EventListQuery = PageQuery.extend({
   name: EventName.optional(),
   contact_id: Id.optional()
 });
 
-// src/unsubscribe.ts
-var UNSUBSCRIBE_PATH_PREFIX = "/u/";
-var LIST_UNSUBSCRIBE_POST_VALUE = "List-Unsubscribe=One-Click";
-var RESERVED_MERGE_FIELDS = {
-  /** From the recipient's merge values, else the contact. Supports a fallback. */
-  first_name: { source: "contact", fallback: true, required_for_broadcast: false },
-  last_name: { source: "contact", fallback: true, required_for_broadcast: false },
-  email: { source: "contact", fallback: false, required_for_broadcast: false },
-  /** The hosted unsubscribe page for this recipient. A broadcast without it is refused. */
-  unsubscribe_url: { source: "service", fallback: false, required_for_broadcast: true }
-};
-var MERGE_FIELD_PATTERN = /\{\{\s*([a-z][a-z0-9_]*)\s*(?:\|([^}]*))?\}\}/g;
-function findMergeFields(html) {
-  const uses = [];
-  for (const match of html.matchAll(MERGE_FIELD_PATTERN)) {
-    uses.push({ name: match[1], fallback: match[2] === void 0 ? null : match[2].trim() });
-  }
-  return uses;
-}
-function missingRequiredMergeFields(html) {
-  const used = new Set(findMergeFields(html).map((u) => u.name));
-  return Object.keys(RESERVED_MERGE_FIELDS).filter(
-    (name) => RESERVED_MERGE_FIELDS[name].required_for_broadcast && !used.has(name)
-  );
-}
-
 // src/workspace.ts
-var CompanyId = z8.string().min(1).max(64);
+var CompanyId = z9.string().min(1).max(64);
 var ASSET_POLICIES = ["any", "service_only"];
-var AssetPolicy = z8.enum(ASSET_POLICIES);
+var AssetPolicy = z9.enum(ASSET_POLICIES);
 var MAX_ALLOWED_ASSET_HOSTS = 20;
-var AssetHost = z8.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 AssetHost = z9.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 = z8.string().regex(/^[a-z][a-z0-9_]*$/, "a merge-field name: lowercase letters, digits and underscores, starting with a letter").max(64);
-var MergeDefaultValue = z8.union([z8.string().max(MAX_MERGE_DEFAULT_LENGTH), z8.number().finite(), z8.boolean()]);
-var MergeDefaults = z8.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 MergeFieldName = z9.string().regex(/^[a-z][a-z0-9_]*$/, "a merge-field name: lowercase letters, digits and underscores, starting with a letter").max(64);
+var MergeDefaultValue = z9.union([z9.string().max(MAX_MERGE_DEFAULT_LENGTH), z9.number().finite(), z9.boolean()]);
+var MergeDefaults = z9.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 = z8.object({
-  /** Default language of the hosted unsubscribe page (BCP 47 tag, e.g. "de"). */
-  default_locale: z8.string().min(2).max(35),
-  /** Languages the hosted pages are offered in. Includes `default_locale`. */
-  locales: z8.array(z8.string().min(2).max(35)).min(1).max(20),
+var WorkspaceSettings = z9.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
+   * decides.
+   */
+  default_locale: LocaleTag,
+  /**
+   * The languages the workspace writes in, including `default_locale`, none
+   * twice (compared without regard to casing). A template can have a version in
+   * each; the hosted pages are offered in those of them they support (English,
+   * German, French, Italian, Spanish). The service stores canonical casing.
+   */
+  locales: z9.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: z8.boolean(),
+  tracking_enabled: z9.boolean(),
   /** Where images, stylesheets and fonts in a mail may load from. `any` by default. */
   asset_policy: AssetPolicy,
   /**
@@ -1975,7 +2426,7 @@ var WorkspaceSettings = z8.object({
    * the workspace's website, typically. Empty by default. Ignored under `any`,
    * which allows everything already.
    */
-  allowed_asset_hosts: z8.array(AssetHost).max(MAX_ALLOWED_ASSET_HOSTS),
+  allowed_asset_hosts: z9.array(AssetHost).max(MAX_ALLOWED_ASSET_HOSTS),
   /** Merge values every mail of the workspace can use (see `MergeDefaults`). Empty by default. */
   merge_defaults: MergeDefaults,
   /**
@@ -1984,10 +2435,10 @@ var WorkspaceSettings = z8.object({
    */
   default_timezone: TimezoneName.nullable()
 });
-var Workspace = z8.object({
+var Workspace = z9.object({
   id: Id,
   slug: Slug,
-  name: z8.string().min(1).max(120),
+  name: z9.string().min(1).max(120),
   settings: WorkspaceSettings,
   /**
    * The auth-brain company (tenant) the workspace was created for, or null for
@@ -1998,13 +2449,13 @@ var Workspace = z8.object({
   created_at: Timestamp,
   updated_at: Timestamp
 });
-var WorkspaceCreate = z8.object({
+var WorkspaceCreate = z9.object({
   slug: Slug,
-  name: z8.string().min(1).max(120),
+  name: z9.string().min(1).max(120),
   settings: WorkspaceSettings.partial().optional(),
-  owner: z8.object({
+  owner: z9.object({
     email: Email,
-    name: z8.string().max(200).nullable().optional()
+    name: z9.string().max(200).nullable().optional()
   }),
   /**
    * The signed-in person's active auth-brain company. The dashboard always
@@ -2014,49 +2465,49 @@ var WorkspaceCreate = z8.object({
    */
   company_id: CompanyId.optional()
 });
-var WorkspaceUpdate = z8.object({
-  name: z8.string().min(1).max(120),
+var WorkspaceUpdate = z9.object({
+  name: z9.string().min(1).max(120),
   settings: WorkspaceSettings.partial()
 }).partial().refine((v) => Object.keys(v).length > 0, "at least one field");
-var WorkspaceMove = z8.object({ company_id: CompanyId });
+var WorkspaceMove = z9.object({ company_id: CompanyId });
 var MEMBER_ROLES = ["owner", "admin", "editor", "viewer"];
-var MemberRole = z8.enum(MEMBER_ROLES);
+var MemberRole = z9.enum(MEMBER_ROLES);
 var WorkspaceMembership = Workspace.extend({ role: MemberRole });
-var Member = z8.object({
+var Member = z9.object({
   id: Id,
   /** The person's auth-brain subject. */
-  subject: z8.string().min(1).max(255),
+  subject: z9.string().min(1).max(255),
   email: Email,
-  name: z8.string().max(200).nullable(),
+  name: z9.string().max(200).nullable(),
   role: MemberRole,
   created_at: Timestamp
 });
-var MemberCreate = z8.object({
-  subject: z8.string().min(1).max(255),
+var MemberCreate = z9.object({
+  subject: z9.string().min(1).max(255),
   email: Email,
-  name: z8.string().max(200).nullable().optional(),
+  name: z9.string().max(200).nullable().optional(),
   role: MemberRole
 });
-var MemberUpdate = z8.object({ role: MemberRole });
+var MemberUpdate = z9.object({ role: MemberRole });
 var API_KEY_SCOPES = ["full", "read", "send"];
-var ApiKeyScope = z8.enum(API_KEY_SCOPES);
-var ApiKey = z8.object({
+var ApiKeyScope = z9.enum(API_KEY_SCOPES);
+var ApiKey = z9.object({
   id: Id,
-  name: z8.string().min(1).max(120),
+  name: z9.string().min(1).max(120),
   /** The first characters of the key, for recognising it in a list. */
-  prefix: z8.string().min(4).max(32),
+  prefix: z9.string().min(4).max(32),
   scope: ApiKeyScope,
   last_used_at: Timestamp.nullable(),
   revoked_at: Timestamp.nullable(),
   created_at: Timestamp
 });
-var ApiKeyCreate = z8.object({
-  name: z8.string().min(1).max(120),
+var ApiKeyCreate = z9.object({
+  name: z9.string().min(1).max(120),
   /** Omitted means `full`. */
   scope: ApiKeyScope.optional()
 });
-var ApiKeyCreated = z8.object({
-  key: z8.string().min(20),
+var ApiKeyCreated = z9.object({
+  key: z9.string().min(20),
   api_key: ApiKey
 });
 var AUDIT_ACTIONS = [
@@ -2144,29 +2595,29 @@ var AUDIT_ACTIONS = [
   "automation.run_ended",
   "event.recorded"
 ];
-var AuditAction = z8.enum(AUDIT_ACTIONS);
-var AuditActor = z8.discriminatedUnion("type", [
-  z8.object({ type: z8.literal("member"), member_id: Id, subject: z8.string().min(1) }),
-  z8.object({
-    type: z8.literal("api_key"),
+var AuditAction = z9.enum(AUDIT_ACTIONS);
+var AuditActor = z9.discriminatedUnion("type", [
+  z9.object({ type: z9.literal("member"), member_id: Id, subject: z9.string().min(1) }),
+  z9.object({
+    type: z9.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: z8.string().min(1).max(ON_BEHALF_OF_MAX_LENGTH).optional()
+    on_behalf_of: z9.string().min(1).max(ON_BEHALF_OF_MAX_LENGTH).optional()
   }),
   /** The service itself (the worker, a bounce, the hosted unsubscribe page). */
-  z8.object({ type: z8.literal("system"), reason: z8.string().min(1).max(200) })
+  z9.object({ type: z9.literal("system"), reason: z9.string().min(1).max(200) })
 ]);
-var AuditEntry = z8.object({
+var AuditEntry = z9.object({
   id: Id,
   action: AuditAction,
   actor: AuditActor,
-  target_type: z8.string().min(1).max(64),
+  target_type: z9.string().min(1).max(64),
   target_id: Id.nullable(),
-  details: z8.record(z8.unknown()),
+  details: z9.record(z9.unknown()),
   created_at: Timestamp
 });
 var AuditQuery = PageQuery.extend({
@@ -2175,12 +2626,12 @@ var AuditQuery = PageQuery.extend({
 });
 
 // src/invites.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var INVITE_STATUSES = ["pending", "accepted", "revoked", "expired"];
-var InviteStatus = z9.enum(INVITE_STATUSES);
+var InviteStatus = z10.enum(INVITE_STATUSES);
 var DEFAULT_INVITE_TTL_DAYS = 7;
 var MAX_INVITE_TTL_DAYS = 30;
-var Invite = z9.object({
+var Invite = z10.object({
   id: Id,
   /** Stored lowercased; only a person signed in with this address can accept. */
   email: Email,
@@ -2188,43 +2639,565 @@ var Invite = z9.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: z9.object({ member_id: Id.nullable(), email: Email.nullable() }),
+  invited_by: z10.object({ member_id: Id.nullable(), email: Email.nullable() }),
   expires_at: Timestamp,
   accepted_at: Timestamp.nullable(),
   revoked_at: Timestamp.nullable(),
   created_at: Timestamp
 });
-var InviteCreate = z9.object({
+var InviteCreate = z10.object({
   email: Email,
   role: MemberRole,
-  expires_in_days: z9.number().int().min(1).max(MAX_INVITE_TTL_DAYS).optional()
+  expires_in_days: z10.number().int().min(1).max(MAX_INVITE_TTL_DAYS).optional()
 });
-var InviteCreated = z9.object({
+var InviteCreated = z10.object({
   invite: Invite,
-  token: z9.string().min(32).max(128)
+  token: z10.string().min(32).max(128)
 });
 var InviteListQuery = PageQuery.extend({
   status: InviteStatus.optional()
 });
-var InviteAccept = z9.object({
-  token: z9.string().min(32).max(128),
+var InviteAccept = z10.object({
+  token: z10.string().min(32).max(128),
   email: Email,
-  name: z9.string().max(200).nullable().optional()
+  name: z10.string().max(200).nullable().optional()
 });
-var InviteAccepted = z9.object({
+var InviteAccepted = z10.object({
   workspace: WorkspaceMembership,
-  already_member: z9.boolean()
+  already_member: z10.boolean()
 });
 var INVITE_REFUSAL_REASONS = ["email_mismatch", "inviter_lacks_role", "expired", "revoked", "accepted"];
 
+// src/template-languages.ts
+function languageTabs(mainLocale, versions, workspaceLocales) {
+  const main = canonicalLocale(mainLocale) ?? mainLocale;
+  const statuses = /* @__PURE__ */ new Map();
+  for (const [tag, status] of Object.entries(versions)) {
+    const canonical = canonicalLocale(tag) ?? tag;
+    if (canonical !== main) statuses.set(canonical, status);
+  }
+  const tabs = [{ locale: main, kind: "main", status: "ready" }];
+  const seen = /* @__PURE__ */ new Set([main]);
+  for (const tag of workspaceLocales) {
+    const canonical = canonicalLocale(tag) ?? tag;
+    if (seen.has(canonical)) continue;
+    seen.add(canonical);
+    tabs.push({ locale: canonical, kind: "translation", status: statuses.get(canonical) ?? "missing" });
+  }
+  const kept = [...statuses.keys()].filter((tag) => !seen.has(tag)).sort();
+  for (const tag of kept) tabs.push({ locale: tag, kind: "kept", status: statuses.get(tag) });
+  return tabs;
+}
+function languageName(tag) {
+  const canonical = canonicalLocale(tag) ?? tag;
+  try {
+    const names = new Intl.DisplayNames(["en"], { type: "language", fallback: "none" });
+    const name = names.of(canonical);
+    return name && name !== canonical ? name : canonical;
+  } catch {
+    return canonical;
+  }
+}
+function storedTemplateLine(value) {
+  if (value === null || value === void 0) return null;
+  const trimmed = value.trim();
+  return trimmed === "" ? null : trimmed;
+}
+function buildTemplatePatch(args) {
+  const { loaded, main, documentChanged, translations, changed, removed } = args;
+  const out = {};
+  if (args.insertions !== void 0 && !sameJson(args.insertions, loaded.insertions ?? {})) out.insertions = args.insertions;
+  const subject = storedTemplateLine(main.subject);
+  if (subject !== storedTemplateLine(loaded.subject)) out.subject = subject;
+  const preheader = storedTemplateLine(main.preheader);
+  if (preheader !== storedTemplateLine(loaded.preheader)) out.preheader = preheader;
+  if (documentChanged) out.document = main.document;
+  const patch = {};
+  for (const tag of changed) {
+    const version = translations[tag];
+    if (version && !removed.has(tag)) {
+      patch[tag] = {
+        subject: storedTemplateLine(version.subject),
+        preheader: storedTemplateLine(version.preheader),
+        document: version.document,
+        status: version.status,
+        ...version.insertions !== void 0 ? { insertions: version.insertions } : {}
+      };
+    }
+  }
+  for (const tag of removed) {
+    if (Object.prototype.hasOwnProperty.call(loaded.translations, tag)) patch[tag] = null;
+  }
+  if (Object.keys(patch).length > 0) out.translations = patch;
+  return out;
+}
+function sameJson(a, b) {
+  const norm = (v) => Array.isArray(v) ? v.map(norm) : v !== null && typeof v === "object" ? Object.fromEntries(Object.keys(v).sort().map((k) => [k, norm(v[k])])) : v;
+  return JSON.stringify(norm(a)) === JSON.stringify(norm(b));
+}
+function restorePatch(old, current, workspaceLocales) {
+  const oldMain = canonicalLocale(old.locale) ?? old.locale;
+  const listed = workspaceLocales ? new Set(workspaceLocales.map((t) => canonicalLocale(t) ?? t)) : null;
+  const patch = {};
+  const skipped = [];
+  const untouched = /* @__PURE__ */ new Set();
+  for (const [tag, version] of Object.entries(old.translations)) {
+    const canonical = canonicalLocale(tag) ?? tag;
+    if (canonical === oldMain) continue;
+    if (listed && !listed.has(canonical)) {
+      skipped.push(canonical);
+      untouched.add(canonical);
+      continue;
+    }
+    patch[canonical] = { ...version, insertions: version.insertions ?? {} };
+  }
+  for (const tag of Object.keys(current.translations)) {
+    const canonical = canonicalLocale(tag) ?? tag;
+    if (!(canonical in patch) && !untouched.has(canonical)) patch[canonical] = null;
+    if (canonical === oldMain) patch[canonical] = null;
+  }
+  const update = {
+    ...oldMain !== (canonicalLocale(current.locale) ?? current.locale) ? { locale: oldMain } : {},
+    subject: old.subject,
+    preheader: old.preheader,
+    document: old.document,
+    insertions: old.insertions ?? {},
+    ...Object.keys(patch).length > 0 ? { translations: patch } : {}
+  };
+  return { update, skipped: skipped.sort() };
+}
+function draftsFromTemplate(template) {
+  const insertions = template.insertions ?? {};
+  const translations = {};
+  for (const [tag, version] of Object.entries(template.translations)) {
+    translations[canonicalLocale(tag) ?? tag] = { ...version, insertions: alignTranslationInsertions(insertions, version.insertions) };
+  }
+  return {
+    main: { subject: template.subject ?? "", preheader: template.preheader ?? "", document: template.document },
+    insertions,
+    translations,
+    mainDocumentChanged: false,
+    changed: [],
+    removed: []
+  };
+}
+var withChanged = (list2, tag) => list2.includes(tag) ? [...list2] : [...list2, tag];
+var without = (list2, tag) => list2.filter((t) => t !== tag);
+function draftDocument(drafts, locale) {
+  if (locale === null) return drafts.main.document;
+  return drafts.translations[locale]?.document;
+}
+function addLanguageDraft(drafts, locale) {
+  const tag = canonicalLocale(locale) ?? locale;
+  if (drafts.translations[tag]) return drafts;
+  return {
+    ...drafts,
+    translations: {
+      ...drafts.translations,
+      [tag]: {
+        subject: drafts.main.subject,
+        preheader: drafts.main.preheader,
+        document: structuredClone(drafts.main.document),
+        status: "draft",
+        insertions: copyInsertionTexts(drafts.insertions)
+      }
+    },
+    changed: withChanged(drafts.changed, tag),
+    removed: without(drafts.removed, tag)
+  };
+}
+function copyInsertionTexts(insertions) {
+  const out = {};
+  for (const [name, def] of Object.entries(insertions)) out[name] = { choices: { ...def.choices }, filled: def.filled, otherwise: def.otherwise };
+  return out;
+}
+function removeLanguageDraft(drafts, locale) {
+  const tag = canonicalLocale(locale) ?? locale;
+  const { [tag]: _gone, ...rest } = drafts.translations;
+  return { ...drafts, translations: rest, changed: without(drafts.changed, tag), removed: withChanged(drafts.removed, tag) };
+}
+function editLanguageDraft(drafts, locale, edit) {
+  if (locale === null) {
+    return {
+      ...drafts,
+      main: { ...drafts.main, ...edit },
+      mainDocumentChanged: drafts.mainDocumentChanged || edit.document !== void 0
+    };
+  }
+  const version = drafts.translations[locale];
+  if (!version) return drafts;
+  const next2 = { ...version, ...edit };
+  return { ...drafts, translations: { ...drafts.translations, [locale]: next2 }, changed: withChanged(drafts.changed, locale) };
+}
+function keepLanguageDocument(drafts, locale, document) {
+  if (locale === null) return { ...drafts, main: { ...drafts.main, document } };
+  const version = drafts.translations[locale];
+  if (!version) return drafts;
+  return { ...drafts, translations: { ...drafts.translations, [locale]: { ...version, document } } };
+}
+function setLanguageStatus(drafts, locale, status) {
+  const version = drafts.translations[locale];
+  if (!version || version.status === status) return drafts;
+  return { ...drafts, translations: { ...drafts.translations, [locale]: { ...version, status } }, changed: withChanged(drafts.changed, locale) };
+}
+function draftsPatch(drafts, loaded) {
+  return buildTemplatePatch({
+    loaded,
+    insertions: drafts.insertions,
+    main: drafts.main,
+    documentChanged: drafts.mainDocumentChanged,
+    translations: drafts.translations,
+    changed: new Set(drafts.changed),
+    removed: new Set(drafts.removed)
+  });
+}
+function draftsDirty(drafts, loaded) {
+  return Object.keys(draftsPatch(drafts, loaded)).length > 0;
+}
+function readyWithoutSubject(drafts) {
+  return Object.entries(drafts.translations).filter(([tag, v]) => drafts.changed.includes(tag) && v.status === "ready" && storedTemplateLine(v.subject) === null).map(([tag]) => tag);
+}
+function rebaseDrafts(sent, now, saved) {
+  const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+  let out = draftsFromTemplate(saved);
+  if (!sameJson(now.insertions, sent.insertions)) out = { ...out, insertions: now.insertions };
+  if (now.main.subject !== sent.main.subject) out = editLanguageDraft(out, null, { subject: now.main.subject });
+  if (now.main.preheader !== sent.main.preheader) out = editLanguageDraft(out, null, { preheader: now.main.preheader });
+  out = same(now.main.document, sent.main.document) ? keepLanguageDocument(out, null, now.main.document) : editLanguageDraft(out, null, { document: now.main.document });
+  const tags = /* @__PURE__ */ new Set([...Object.keys(sent.translations), ...Object.keys(now.translations)]);
+  for (const tag of tags) {
+    const before = sent.translations[tag];
+    const after = now.translations[tag];
+    if (same(before, after)) {
+      if (after) out = keepLanguageDocument(out, tag, after.document);
+      continue;
+    }
+    if (!after) {
+      out = removeLanguageDraft(out, tag);
+      continue;
+    }
+    out = {
+      ...out,
+      translations: { ...out.translations, [tag]: after },
+      changed: withChanged(out.changed, tag),
+      removed: without(out.removed, tag)
+    };
+  }
+  return sameJson(out.insertions, saved.insertions ?? {}) ? out : alignDrafts(out);
+}
+function alignDrafts(drafts) {
+  const translations = {};
+  for (const [tag, version] of Object.entries(drafts.translations)) {
+    translations[tag] = { ...version, insertions: alignTranslationInsertions(drafts.insertions, version.insertions) };
+  }
+  return { ...drafts, translations };
+}
+function editMainInsertions(drafts, insertions) {
+  return alignDrafts({ ...drafts, insertions });
+}
+function renameKey(record, from, to) {
+  const out = {};
+  for (const [k, v] of Object.entries(record)) out[k === from ? to : k] = v;
+  return out;
+}
+function renameInsertion(drafts, from, to) {
+  if (from === to || !ownEntry(drafts.insertions, from) || ownEntry(drafts.insertions, to)) return drafts;
+  const translations = {};
+  let changed = drafts.changed;
+  for (const [tag, version] of Object.entries(drafts.translations)) {
+    if (version.insertions && ownEntry(version.insertions, from)) {
+      translations[tag] = { ...version, insertions: renameKey(version.insertions, from, to) };
+      changed = withChanged(changed, tag);
+    } else translations[tag] = version;
+  }
+  return { ...drafts, insertions: renameKey(drafts.insertions, from, to), translations, changed };
+}
+function renameInsertionChoice(drafts, name, from, to) {
+  const def = ownEntry(drafts.insertions, name);
+  if (!def || from === to || INSERTION_TEXT_SLOTS.includes(to) || ownEntry(def.choices, from) === void 0 || ownEntry(def.choices, to) !== void 0) {
+    return drafts;
+  }
+  const translations = {};
+  let changed = drafts.changed;
+  for (const [tag, version] of Object.entries(drafts.translations)) {
+    const t = ownEntry(version.insertions, name);
+    if (t && Object.prototype.hasOwnProperty.call(t.choices, from)) {
+      translations[tag] = { ...version, insertions: { ...version.insertions, [name]: { ...t, choices: renameKey(t.choices, from, to) } } };
+      changed = withChanged(changed, tag);
+    } else translations[tag] = version;
+  }
+  return {
+    ...drafts,
+    insertions: { ...drafts.insertions, [name]: { ...def, choices: renameKey(def.choices, from, to) } },
+    translations,
+    changed
+  };
+}
+function editInsertionText(drafts, locale, name, choice, text) {
+  const version = drafts.translations[locale];
+  const def = ownEntry(drafts.insertions, name);
+  if (!version || !def) return drafts;
+  const aligned = alignTranslationInsertions(drafts.insertions, version.insertions);
+  const current = aligned[name];
+  let next2;
+  if (choice === "filled") {
+    if (def.filled === null) return drafts;
+    next2 = { ...current, filled: text };
+  } else if (choice === "otherwise") next2 = { ...current, otherwise: text };
+  else if (Object.prototype.hasOwnProperty.call(def.choices, choice)) next2 = { ...current, choices: { ...current.choices, [choice]: text } };
+  else return drafts;
+  return {
+    ...drafts,
+    translations: { ...drafts.translations, [locale]: { ...version, insertions: { ...aligned, [name]: next2 } } },
+    changed: withChanged(drafts.changed, locale)
+  };
+}
+function missingInsertionTexts(drafts, locale) {
+  const version = drafts.translations[locale];
+  return version ? insertionCoverage(drafts.insertions, version.insertions) : [];
+}
+function readyWithoutInsertions(drafts) {
+  return Object.entries(drafts.translations).filter(([tag, v]) => drafts.changed.includes(tag) && v.status === "ready" && insertionCoverage(drafts.insertions, v.insertions).length > 0).map(([tag]) => tag);
+}
+function demotedBySave(drafts, loaded) {
+  if (sameJson(drafts.insertions, loaded.insertions ?? {})) return [];
+  return Object.entries(drafts.translations).filter(([tag, v]) => !drafts.changed.includes(tag) && v.status === "ready" && insertionCoverage(drafts.insertions, v.insertions).length > 0).map(([tag]) => tag).sort();
+}
+
+// src/insertion-editing.ts
+var has = (record, key) => Object.prototype.hasOwnProperty.call(record, key);
+function insertionNameProblem(insertions, name, current) {
+  if (!InsertionName.safeParse(name).success) return "Use lowercase letters, digits and underscores, starting with a letter (like opening).";
+  if (has(RESERVED_MERGE_FIELDS, name)) return `"${name}" is a merge field the service fills itself. Choose another name.`;
+  if (name !== current && has(insertions, name)) return `There is already an insertion called "${name}".`;
+  const chooser = Object.entries(insertions).find(([other, def]) => def.by === name && other !== current);
+  if (chooser) return `"${name}" is the value that chooses "${chooser[0]}". Choose another name.`;
+  if (current !== void 0 && ownEntry(insertions, current)?.by === name) return `"${name}" is the value that chooses this insertion. Choose another name.`;
+  return null;
+}
+function insertionByProblem(insertions, by, self) {
+  if (!InsertionName.safeParse(by).success) return "The value that chooses is a merge-field name: lowercase letters, digits and underscores (like reason).";
+  if (by === "unsubscribe_url") return "The unsubscribe link cannot choose a text. Use a value the client or the contact provides.";
+  if (by === self || has(insertions, by)) return `"${by}" is an insertion, not a value. Use a value the client or the contact provides.`;
+  return null;
+}
+function normalizeChoiceKey(raw) {
+  return raw.trim().toLowerCase();
+}
+function choiceKeyProblem(insertion, key, current) {
+  if (INSERTION_TEXT_SLOTS.includes(key)) {
+    return `"${key}" names the insertion's ${key === "filled" ? '"any other filled value"' : '"otherwise"'} text, so it cannot be a choice. Choose another value.`;
+  }
+  if (!InsertionChoiceKey.safeParse(key).success) return "A choice is the value a client sends: lowercase letters, digits, hyphens and underscores (like venue).";
+  if (key !== current && has(insertion.choices, key)) return `There is already a choice "${key}".`;
+  return null;
+}
+function addInsertion(drafts, rawName, rawBy) {
+  const name = rawName.trim();
+  const by = rawBy.trim();
+  if (Object.keys(drafts.insertions).length >= MAX_INSERTIONS) return { ok: false, message: `A template holds at most ${MAX_INSERTIONS} insertions.` };
+  const nameProblem = insertionNameProblem(drafts.insertions, name);
+  if (nameProblem) return { ok: false, message: nameProblem };
+  if (name === by) return { ok: false, message: "An insertion cannot be chosen by its own name. Use the value the client sends (like reason)." };
+  const byProblem = insertionByProblem(drafts.insertions, by);
+  if (byProblem) return { ok: false, message: byProblem };
+  return { ok: true, drafts: editMainInsertions(drafts, { ...drafts.insertions, [name]: { by, choices: {}, filled: null, otherwise: "" } }) };
+}
+function removeInsertion(drafts, name) {
+  if (!has(drafts.insertions, name)) return drafts;
+  const { [name]: _gone, ...rest } = drafts.insertions;
+  return editMainInsertions(drafts, rest);
+}
+function renameInsertionChecked(drafts, from, rawTo) {
+  const to = rawTo.trim();
+  if (to === from) return { ok: true, drafts };
+  const problem = insertionNameProblem(drafts.insertions, to, from);
+  if (problem) return { ok: false, message: problem };
+  return { ok: true, drafts: renameInsertion(drafts, from, to) };
+}
+function setInsertionBy(drafts, name, rawBy) {
+  const def = ownEntry(drafts.insertions, name);
+  if (!def) return { ok: false, message: `There is no insertion "${name}".` };
+  const by = rawBy.trim();
+  const problem = insertionByProblem(drafts.insertions, by, name);
+  if (problem) return { ok: false, message: problem };
+  if (by === def.by) return { ok: true, drafts };
+  return { ok: true, drafts: editMainInsertions(drafts, { ...drafts.insertions, [name]: { ...def, by } }) };
+}
+function addInsertionChoice(drafts, name, rawKey) {
+  const def = ownEntry(drafts.insertions, name);
+  if (!def) return { ok: false, message: `There is no insertion "${name}".` };
+  if (Object.keys(def.choices).length >= MAX_INSERTION_CHOICES) return { ok: false, message: `An insertion holds at most ${MAX_INSERTION_CHOICES} choices.` };
+  const key = normalizeChoiceKey(rawKey);
+  const problem = choiceKeyProblem(def, key);
+  if (problem) return { ok: false, message: problem };
+  return { ok: true, drafts: editMainInsertions(drafts, { ...drafts.insertions, [name]: { ...def, choices: { ...def.choices, [key]: "" } } }) };
+}
+function removeInsertionChoice(drafts, name, key) {
+  const def = ownEntry(drafts.insertions, name);
+  if (!def || !has(def.choices, key)) return drafts;
+  const { [key]: _gone, ...choices } = def.choices;
+  return editMainInsertions(drafts, { ...drafts.insertions, [name]: { ...def, choices } });
+}
+function renameInsertionChoiceChecked(drafts, name, from, rawTo) {
+  const def = ownEntry(drafts.insertions, name);
+  if (!def) return { ok: false, message: `There is no insertion "${name}".` };
+  const to = normalizeChoiceKey(rawTo);
+  if (to === from) return { ok: true, drafts };
+  const problem = choiceKeyProblem(def, to, from);
+  if (problem) return { ok: false, message: problem };
+  return { ok: true, drafts: renameInsertionChoice(drafts, name, from, to) };
+}
+function setInsertionFilled(drafts, name, on) {
+  const def = ownEntry(drafts.insertions, name);
+  if (!def || def.filled !== null === on) return drafts;
+  return editMainInsertions(drafts, { ...drafts.insertions, [name]: { ...def, filled: on ? "" : null } });
+}
+function editMainInsertionText(drafts, name, choice, text) {
+  const def = ownEntry(drafts.insertions, name);
+  if (!def) return drafts;
+  let next2;
+  if (choice === "otherwise") next2 = { ...def, otherwise: text };
+  else if (choice === "filled") {
+    if (def.filled === null) return drafts;
+    next2 = { ...def, filled: text };
+  } else if (has(def.choices, choice)) next2 = { ...def, choices: { ...def.choices, [choice]: text } };
+  else return drafts;
+  return editMainInsertions(drafts, { ...drafts.insertions, [name]: next2 });
+}
+function mainInsertionText(insertion, choice) {
+  if (choice === "otherwise") return insertion.otherwise;
+  if (choice === "filled") return insertion.filled;
+  return ownEntry(insertion.choices, choice) ?? null;
+}
+function translationTextFromInput(mainText, value) {
+  if (value.trim() !== "") return value;
+  return mainText !== null && mainText.trim() === "" ? "" : null;
+}
+function insertionTextSlots(insertion) {
+  return [...Object.keys(insertion.choices), ...insertion.filled !== null ? ["filled"] : [], "otherwise"];
+}
+function insertionSlotLabel(choice) {
+  if (choice === "filled") return "any other filled value";
+  if (choice === "otherwise") return "otherwise";
+  return `'${choice}'`;
+}
+function joinWords(items) {
+  if (items.length <= 1) return items.join("");
+  return `${items.slice(0, -1).join(", ")} and ${items[items.length - 1]}`;
+}
+function describeMissingTexts(missing) {
+  if (missing.length === 0) return "";
+  return `no text for ${joinWords(missing.map((m) => `${insertionSlotLabel(m.choice)} in ${m.insertion}`))}`;
+}
+function saveDemotions(drafts, loaded) {
+  const tags = [.../* @__PURE__ */ new Set([...demotedBySave(drafts, loaded), ...readyWithoutInsertions(drafts)])].sort();
+  return tags.map((locale) => ({ locale, missing: insertionCoverage(drafts.insertions, ownEntry(drafts.translations, locale)?.insertions) }));
+}
+function demoteForSave(drafts) {
+  let out = drafts;
+  for (const tag of readyWithoutInsertions(drafts)) out = setLanguageStatus(out, tag, "draft");
+  return out;
+}
+function draftInsertionProblems(drafts) {
+  const out = [];
+  const parsed = Insertions.safeParse(drafts.insertions);
+  if (!parsed.success) {
+    for (const issue of parsed.error.issues) out.push({ locale: null, reason: "invalid", path: issue.path.join("."), message: issue.message });
+    return out;
+  }
+  for (const p of insertionProblems(drafts.insertions)) out.push({ ...p, locale: null });
+  const places = (subject, preheader, document) => ({ subject, preheader, document: JSON.stringify(document) });
+  for (const p of placementProblems(places(drafts.main.subject, drafts.main.preheader, drafts.main.document), drafts.insertions)) out.push({ ...p, locale: null });
+  for (const [tag, version] of Object.entries(drafts.translations)) {
+    if (!drafts.changed.includes(tag)) continue;
+    for (const p of translationInsertionProblems(drafts.insertions, version.insertions ?? {})) out.push({ ...p, locale: tag });
+    for (const p of placementProblems(places(version.subject, version.preheader, version.document), drafts.insertions)) out.push({ ...p, locale: tag });
+  }
+  return out;
+}
+var PREVIEW_FILLED = ":filled";
+var PREVIEW_EMPTY = ":empty";
+function previewControls(insertions) {
+  return Object.entries(insertionInputs(insertions)).map(([by, input]) => ({
+    by,
+    insertions: input.insertions,
+    options: [
+      ...input.keys.map((key) => ({ value: key, label: key })),
+      ...input.filled ? [{ value: PREVIEW_FILLED, label: "any other value" }] : [],
+      { value: PREVIEW_EMPTY, label: "empty" }
+    ]
+  }));
+}
+function defaultPreviewPick(control) {
+  return control.options[0].value;
+}
+function effectivePreviewPicks(controls, picks) {
+  const out = {};
+  for (const control of controls) {
+    const picked = ownEntry(picks, control.by);
+    out[control.by] = picked !== void 0 && control.options.some((o) => o.value === picked) ? picked : defaultPreviewPick(control);
+  }
+  return out;
+}
+function sampleFilledValue(by, keys) {
+  const sample = by === "first_name" ? "Alex" : by === "last_name" ? "Morgan" : "Sample value";
+  return keys.includes(sample.toLowerCase()) ? "Sample value" : sample;
+}
+function previewInsertions(main, translation, missing) {
+  if (translation === void 0) return main;
+  const aligned = alignTranslationInsertions(main, translation);
+  const out = {};
+  for (const [name, def] of Object.entries(main)) {
+    const t = ownEntry(aligned, name);
+    const choices = {};
+    for (const key of Object.keys(def.choices)) choices[key] = ownEntry(t.choices, key) ?? missing;
+    out[name] = { by: def.by, choices, filled: def.filled === null ? null : t.filled ?? missing, otherwise: t.otherwise ?? missing };
+  }
+  return out;
+}
+function previewPersonalization(insertions, picks) {
+  const values = {};
+  const controlled = /* @__PURE__ */ new Set();
+  const shown = effectivePreviewPicks(previewControls(insertions), picks);
+  for (const [by, input] of Object.entries(insertionInputs(insertions))) {
+    controlled.add(by);
+    const pick = shown[by];
+    if (pick === PREVIEW_EMPTY) continue;
+    values[by] = pick === PREVIEW_FILLED ? sampleFilledValue(by, input.keys) : pick;
+  }
+  const sample = sampleMergeValue(values);
+  return {
+    insertions: resolveInsertions(insertions, (name) => ownEntry(values, name)),
+    value: (name, fallback) => controlled.has(name) ? sample(name, fallback) : `{{${name}${fallback === void 0 ? "" : `|${fallback}`}}}`
+  };
+}
+var REFUSAL_HINTS = {
+  ready_needs_insertions: "Write the missing texts in that language, or set it back to draft, then save.",
+  insertion_name: "Rename the insertion: the names first_name, last_name, email and unsubscribe_url are filled by the service.",
+  insertion_by: "Choose the insertion by a value the client or the contact provides, not by the unsubscribe link or another insertion.",
+  insertion_choice_key: "Use lowercase letters, digits, hyphens and underscores for a choice.",
+  insertion_text: "An insertion text can hold merge fields such as {{first_name}}, but not another insertion.",
+  insertion_with_fallback: 'Remove the |fallback from the insertion in the subject, preheader or body: its "otherwise" text is the fallback.',
+  unknown_translation_insertion: "A language names an insertion or a choice the main language no longer has. Reload the template and try again."
+};
+function insertionRefusalHint(details) {
+  const reason = details?.reason;
+  if (typeof reason !== "string" || !has(REFUSAL_HINTS, reason)) return null;
+  const hint = REFUSAL_HINTS[reason];
+  if (reason !== "ready_needs_insertions") return hint;
+  const missing = Array.isArray(details?.missing) ? details.missing.filter((m) => typeof m === "object" && m !== null && typeof m.insertion === "string" && typeof m.choice === "string") : [];
+  return missing.length > 0 ? `The language has ${describeMissingTexts(missing)}. ${hint}` : hint;
+}
+
 // src/providers.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var PROVIDER_KINDS = ["smtp", "resend"];
-var ProviderKind = z10.enum(PROVIDER_KINDS);
-var ProviderPolicy = z10.object({
-  daily_recipient_budget: z10.number().int().min(1).max(1e7),
-  min_interval_ms: z10.number().int().min(0).max(36e5),
-  max_recipients_per_message: z10.number().int().min(1).max(1e3)
+var ProviderKind = z11.enum(PROVIDER_KINDS);
+var ProviderPolicy = z11.object({
+  daily_recipient_budget: z11.number().int().min(1).max(1e7),
+  min_interval_ms: z11.number().int().min(0).max(36e5),
+  max_recipients_per_message: z11.number().int().min(1).max(1e3)
 });
 var ICLOUD_SMTP_POLICY = {
   daily_recipient_budget: 800,
@@ -2232,17 +3205,17 @@ var ICLOUD_SMTP_POLICY = {
   max_recipients_per_message: 1
 };
 var SMTP_SECURITY = ["tls", "starttls"];
-var SmtpConfigBase = z10.object({
-  host: z10.string().min(1).max(255),
-  port: z10.number().int().min(1).max(65535),
+var SmtpConfigBase = z11.object({
+  host: z11.string().min(1).max(255),
+  port: z11.number().int().min(1).max(65535),
   /** `tls` connects encrypted (465), `starttls` upgrades (587). Never plaintext. */
-  security: z10.enum(SMTP_SECURITY),
-  username: z10.string().min(1).max(255)
+  security: z11.enum(SMTP_SECURITY),
+  username: z11.string().min(1).max(255)
 });
-var ResendConfigBase = z10.object({});
-var ProviderRejections = z10.object({
-  count: z10.number().int().min(0),
-  last_error: z10.string().nullable(),
+var ResendConfigBase = z11.object({});
+var ProviderRejections = z11.object({
+  count: z11.number().int().min(0),
+  last_error: z11.string().nullable(),
   last_at: Timestamp.nullable(),
   /**
    * The last time the bounce circuit breaker tripped on one of this provider's
@@ -2252,59 +3225,59 @@ var ProviderRejections = z10.object({
    * run's bounce blocks were undone and the mailing paused. `sample` is the
    * reply that tripped it.
    */
-  anomaly: z10.object({
+  anomaly: z11.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: z10.enum(["mailing", "provider"]),
+    scope: z11.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: z10.boolean(),
+    blocking: z11.boolean(),
     mailing_id: Id.nullable(),
-    reason: z10.string(),
-    sample: z10.string()
+    reason: z11.string(),
+    sample: z11.string()
   }).nullable()
 });
-var ProviderEvents = z10.object({
-  status: z10.enum(["active", "needs_secret"]),
-  source: z10.enum(["automatic", "manual"]).nullable(),
-  url: z10.string().url(),
-  error: z10.string().nullable(),
+var ProviderEvents = z11.object({
+  status: z11.enum(["active", "needs_secret"]),
+  source: z11.enum(["automatic", "manual"]).nullable(),
+  url: z11.string().url(),
+  error: z11.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: z10.number().int().min(0)
+  unmatched: z11.number().int().min(0)
 });
 var RESEND_EVENT_TYPES = ["email.bounced", "email.complained", "email.delivery_delayed"];
-var ResendSigningSecret = z10.string().max(200).regex(/^whsec_[A-Za-z0-9+/]{16,}={0,2}$/, "must be the signing secret Resend shows, starting with whsec_");
-var ProviderEventsSecret = z10.object({ signing_secret: ResendSigningSecret });
+var ResendSigningSecret = z11.string().max(200).regex(/^whsec_[A-Za-z0-9+/]{16,}={0,2}$/, "must be the signing secret Resend shows, starting with whsec_");
+var ProviderEventsSecret = z11.object({ signing_secret: ResendSigningSecret });
 var ProviderFields = {
-  name: z10.string().min(1).max(120),
-  from_name: z10.string().min(1).max(120),
+  name: z11.string().min(1).max(120),
+  from_name: z11.string().min(1).max(120),
   from_email: Email,
   reply_to: Email.nullable(),
   policy: ProviderPolicy
 };
-var Provider = z10.discriminatedUnion("kind", [
-  z10.object({
+var Provider = z11.discriminatedUnion("kind", [
+  z11.object({
     id: Id,
-    kind: z10.literal("smtp"),
+    kind: z11.literal("smtp"),
     config: SmtpConfigBase,
-    has_secret: z10.boolean(),
+    has_secret: z11.boolean(),
     ...ProviderFields,
     rejections: ProviderRejections,
     created_at: Timestamp,
     updated_at: Timestamp
   }),
-  z10.object({
+  z11.object({
     id: Id,
-    kind: z10.literal("resend"),
+    kind: z11.literal("resend"),
     config: ResendConfigBase,
-    has_secret: z10.boolean(),
+    has_secret: z11.boolean(),
     ...ProviderFields,
     rejections: ProviderRejections,
     events: ProviderEvents,
@@ -2312,31 +3285,31 @@ var Provider = z10.discriminatedUnion("kind", [
     updated_at: Timestamp
   })
 ]);
-var ProviderCreate = z10.discriminatedUnion("kind", [
-  z10.object({
-    kind: z10.literal("smtp"),
-    config: SmtpConfigBase.extend({ password: z10.string().min(1).max(1024) }),
+var ProviderCreate = z11.discriminatedUnion("kind", [
+  z11.object({
+    kind: z11.literal("smtp"),
+    config: SmtpConfigBase.extend({ password: z11.string().min(1).max(1024) }),
     ...ProviderFields
   }),
-  z10.object({
-    kind: z10.literal("resend"),
-    config: ResendConfigBase.extend({ api_key: z10.string().min(1).max(1024) }),
+  z11.object({
+    kind: z11.literal("resend"),
+    config: ResendConfigBase.extend({ api_key: z11.string().min(1).max(1024) }),
     ...ProviderFields
   })
 ]);
-var ProviderUpdate = z10.discriminatedUnion("kind", [
-  z10.object({
-    kind: z10.literal("smtp"),
-    config: SmtpConfigBase.extend({ password: z10.string().min(1).max(1024).optional() }).partial().optional(),
+var ProviderUpdate = z11.discriminatedUnion("kind", [
+  z11.object({
+    kind: z11.literal("smtp"),
+    config: SmtpConfigBase.extend({ password: z11.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()
   }),
-  z10.object({
-    kind: z10.literal("resend"),
-    config: ResendConfigBase.extend({ api_key: z10.string().min(1).max(1024).optional() }).optional(),
+  z11.object({
+    kind: z11.literal("resend"),
+    config: ResendConfigBase.extend({ api_key: z11.string().min(1).max(1024).optional() }).optional(),
     name: ProviderFields.name.optional(),
     from_name: ProviderFields.from_name.optional(),
     from_email: ProviderFields.from_email.optional(),
@@ -2344,48 +3317,48 @@ var ProviderUpdate = z10.discriminatedUnion("kind", [
     policy: ProviderPolicy.partial().optional()
   })
 ]);
-var ProviderUsage = z10.object({
+var ProviderUsage = z11.object({
   provider_id: Id,
-  recipients_last_24h: z10.number().int().min(0),
-  remaining_budget: z10.number().int().min(0),
+  recipients_last_24h: z11.number().int().min(0),
+  remaining_budget: z11.number().int().min(0),
   /** When enough of the rolling window frees up to send again, if exhausted. */
   next_capacity_at: Timestamp.nullable()
 });
-var ProviderVerifyResult = z10.object({
-  ok: z10.boolean(),
-  error: z10.string().nullable()
+var ProviderVerifyResult = z11.object({
+  ok: z11.boolean(),
+  error: z11.string().nullable()
 });
 
 // src/contacts.ts
-import { z as z11 } from "zod";
-var Topic = z11.object({
+import { z as z12 } from "zod";
+var Topic = z12.object({
   id: Id,
   slug: Slug,
-  name: z11.string().min(1).max(120),
+  name: z12.string().min(1).max(120),
   /** Shown on the hosted preference page. */
-  description: z11.string().max(1e3).nullable(),
+  description: z12.string().max(1e3).nullable(),
   /** Translations of `name` and `description` per locale, for the hosted page. */
-  translations: z11.record(
-    z11.object({ name: z11.string().min(1).max(120), description: z11.string().max(1e3).nullable() })
+  translations: z12.record(
+    z12.object({ name: z12.string().min(1).max(120), description: z12.string().max(1e3).nullable() })
   ),
   created_at: Timestamp,
   updated_at: Timestamp
 });
-var TopicCreate = z11.object({
+var TopicCreate = z12.object({
   slug: Slug,
-  name: z11.string().min(1).max(120),
-  description: z11.string().max(1e3).optional(),
+  name: z12.string().min(1).max(120),
+  description: z12.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 = z11.object({
+var Contact = z12.object({
   id: Id,
-  external_id: z11.string().min(1).max(255).nullable(),
+  external_id: z12.string().min(1).max(255).nullable(),
   /** Stored lowercased, unique per workspace. */
   email: Email,
-  first_name: z11.string().max(200).nullable(),
-  last_name: z11.string().max(200).nullable(),
-  locale: z11.string().min(2).max(35).nullable(),
+  first_name: z12.string().max(200).nullable(),
+  last_name: z12.string().max(200).nullable(),
+  locale: z12.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
@@ -2393,65 +3366,65 @@ var Contact = z11.object({
    */
   timezone: TimezoneName.nullable(),
   properties: Properties,
-  topics: z11.array(Slug),
+  topics: z12.array(Slug),
   /** The slugs of the contact's tags (S4). */
-  tags: z11.array(Slug),
+  tags: z12.array(Slug),
   created_at: Timestamp,
   updated_at: Timestamp
 });
-var ContactUpsert = z11.object({
-  external_id: z11.string().min(1).max(255).optional(),
+var ContactUpsert = z12.object({
+  external_id: z12.string().min(1).max(255).optional(),
   email: Email.optional(),
-  first_name: z11.string().max(200).nullable().optional(),
-  last_name: z11.string().max(200).nullable().optional(),
-  locale: z11.string().min(2).max(35).nullable().optional(),
+  first_name: z12.string().max(200).nullable().optional(),
+  last_name: z12.string().max(200).nullable().optional(),
+  locale: z12.string().min(2).max(35).nullable().optional(),
   timezone: TimezoneName.nullable().optional(),
   properties: Properties.optional(),
-  topics: z11.array(Slug).max(100).optional()
+  topics: z12.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 = z11.object({
+var ContactUpsertResult = z12.object({
   contact: Contact,
-  created: z11.boolean()
+  created: z12.boolean()
 });
 var ContactListQuery = PageQuery.extend({
-  email: z11.string().min(1).max(254).optional(),
-  external_id: z11.string().min(1).max(255).optional(),
+  email: z12.string().min(1).max(254).optional(),
+  external_id: z12.string().min(1).max(255).optional(),
   topic: Slug.optional()
 });
-var ContactErased = z11.object({
-  ok: z11.literal(true),
-  erased_messages: z11.number().int().min(0),
-  erased_recipients: z11.number().int().min(0),
-  suppressions_kept: z11.number().int().min(0)
+var ContactErased = z12.object({
+  ok: z12.literal(true),
+  erased_messages: z12.number().int().min(0),
+  erased_recipients: z12.number().int().min(0),
+  suppressions_kept: z12.number().int().min(0)
 });
 var SUPPRESSION_REASONS = ["unsubscribed", "bounced", "complained", "manual"];
-var SuppressionReason = z11.enum(SUPPRESSION_REASONS);
-var Suppression = z11.object({
+var SuppressionReason = z12.enum(SUPPRESSION_REASONS);
+var Suppression = z12.object({
   id: Id,
   email: Email,
   reason: SuppressionReason,
   topic: Slug.nullable(),
   source_message_id: Id.nullable(),
-  note: z11.string().max(1e3).nullable(),
+  note: z12.string().max(1e3).nullable(),
   created_at: Timestamp
 });
-var SuppressionCreate = z11.object({
+var SuppressionCreate = z12.object({
   email: Email,
-  reason: z11.enum(["manual", "unsubscribed"]),
+  reason: z12.enum(["manual", "unsubscribed"]),
   topic: Slug.nullable().optional(),
-  note: z11.string().max(1e3).optional()
+  note: z12.string().max(1e3).optional()
 });
 var SuppressionListQuery = PageQuery.extend({
-  email: z11.string().min(1).max(254).optional(),
+  email: z12.string().min(1).max(254).optional(),
   reason: SuppressionReason.optional(),
   topic: Slug.optional()
 });
 
 // src/webhooks.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 var WEBHOOK_EVENT_TYPES = [
   "message.sent",
   "message.failed",
@@ -2495,40 +3468,47 @@ var WEBHOOK_EVENT_TYPES = [
   "template.updated",
   "template.deleted"
 ];
-var WebhookEventType = z12.enum(WEBHOOK_EVENT_TYPES);
-var MessageEventBase = z12.object({
+var WebhookEventType = z13.enum(WEBHOOK_EVENT_TYPES);
+var MessageEventBase = z13.object({
   message_id: Id,
   mailing_id: Id.nullable(),
   mailing_metadata: MailingMetadata.nullable(),
   recipient_id: Id.nullable(),
   contact_id: Id.nullable(),
-  external_id: z12.string().nullable(),
+  external_id: z13.string().nullable(),
   email: Email,
-  subject: z12.string(),
+  subject: z13.string(),
   topic: Slug.nullable(),
-  provider_message_id: z12.string().nullable(),
-  is_test: z12.boolean()
+  provider_message_id: z13.string().nullable(),
+  is_test: z13.boolean()
 });
 var MessageSentData = MessageEventBase.extend({
   /** The final HTML as sent, so the client can archive it beside its own records. */
-  html: z12.string(),
-  sent_at: Timestamp
+  html: z13.string(),
+  sent_at: Timestamp,
+  /**
+   * The choice each insertion made (see `Message.insertions`); absent or null
+   * when the message had none. A `matched: false` entry is a value the
+   * template has no choice for: the client sent something its form should
+   * not offer.
+   */
+  insertions: InsertionChoices.nullish()
 });
 var MessageFailedData = MessageEventBase.extend({
-  error: z12.string(),
+  error: z13.string(),
   /** False when the provider rejected permanently; the recipient will not be retried. */
-  retryable: z12.boolean(),
+  retryable: z13.boolean(),
   failed_at: Timestamp
 });
 var UNSUBSCRIBE_SOURCES = ["hosted_page", "one_click", "api", "dashboard", "signup_form"];
-var ContactUnsubscribedData = z12.object({
+var ContactUnsubscribedData = z13.object({
   contact_id: Id.nullable(),
-  external_id: z12.string().nullable(),
+  external_id: z13.string().nullable(),
   email: Email,
   /** The topic unsubscribed from; null means every topic. */
   topic: Slug.nullable(),
   mailing_id: Id.nullable(),
-  source: z12.enum(UNSUBSCRIBE_SOURCES),
+  source: z13.enum(UNSUBSCRIBE_SOURCES),
   unsubscribed_at: Timestamp
 });
 var ContactResubscribedData = ContactUnsubscribedData.omit({ unsubscribed_at: true }).extend({
@@ -2537,142 +3517,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: z12.enum([...UNSUBSCRIBE_SOURCES, "bounce_reverted"]),
+  source: z13.enum([...UNSUBSCRIBE_SOURCES, "bounce_reverted"]),
   resubscribed_at: Timestamp
 });
-var ContactBouncedData = z12.object({
+var ContactBouncedData = z13.object({
   contact_id: Id.nullable(),
-  external_id: z12.string().nullable(),
+  external_id: z13.string().nullable(),
   email: Email,
   /** `bounced` for a hard bounce, `complained` for a spam complaint. */
-  reason: z12.enum(["bounced", "complained"]),
+  reason: z13.enum(["bounced", "complained"]),
   message_id: Id.nullable(),
-  diagnostic: z12.string().nullable(),
+  diagnostic: z13.string().nullable(),
   bounced_at: Timestamp
 });
-var MailingFinishedData = z12.object({
+var MailingFinishedData = z13.object({
   mailing_id: Id,
   mailing_metadata: MailingMetadata,
-  status: z12.enum(["sent", "partially_failed", "cancelled"]),
+  status: z13.enum(["sent", "partially_failed", "cancelled"]),
   counts: MailingCounts,
   finished_at: Timestamp
 });
-var ContactSubscribedData = z12.object({
+var ContactSubscribedData = z13.object({
   contact_id: Id,
-  external_id: z12.string().nullable(),
+  external_id: z13.string().nullable(),
   email: Email,
-  topics: z12.array(Slug),
-  source: z12.enum(["signup_form", "api", "dashboard", "automation"]),
+  topics: z13.array(Slug),
+  source: z13.enum(["signup_form", "api", "dashboard", "automation"]),
   signup_form_id: Id.nullable(),
-  signup_form_version: z12.number().int().min(1).nullable(),
+  signup_form_version: z13.number().int().min(1).nullable(),
   subscribed_at: Timestamp
 });
-var ImportFinishedData = z12.object({
+var ImportFinishedData = z13.object({
   import_id: Id,
-  status: z12.enum(["completed", "cancelled", "failed"]),
+  status: z13.enum(["completed", "cancelled", "failed"]),
   result: ImportReport.nullable(),
-  error: z12.string().nullable(),
+  error: z13.string().nullable(),
   finished_at: Timestamp
 });
-var MailingScheduledData = z12.object({
+var MailingScheduledData = z13.object({
   mailing_id: Id,
   mailing_metadata: MailingMetadata,
   scheduled_at: Timestamp.nullable()
 });
-var MailingStartedData = z12.object({
+var MailingStartedData = z13.object({
   mailing_id: Id,
   mailing_metadata: MailingMetadata,
-  trigger: z12.enum(["send", "schedule"]),
-  recipients: z12.number().int().min(0),
+  trigger: z13.enum(["send", "schedule"]),
+  recipients: z13.number().int().min(0),
   started_at: Timestamp
 });
-var MailingScheduleFailedData = z12.object({
+var MailingScheduleFailedData = z13.object({
   mailing_id: Id,
   mailing_metadata: MailingMetadata,
-  code: z12.string(),
-  message: z12.string(),
+  code: z13.string(),
+  message: z13.string(),
   failed_at: Timestamp
 });
-var MailingAbWinnerSelectedData = z12.object({
+var MailingAbWinnerSelectedData = z13.object({
   mailing_id: Id,
   mailing_metadata: MailingMetadata,
-  winner: z12.string(),
-  decided_by: z12.enum(["metric", "manual"]),
-  variants: z12.array(VariantAnalytics),
+  winner: z13.string(),
+  decided_by: z13.enum(["metric", "manual"]),
+  variants: z13.array(VariantAnalytics),
   decided_at: Timestamp
 });
-var ContactTaggedData = z12.object({
+var ContactTaggedData = z13.object({
   contact_id: Id,
-  external_id: z12.string().nullable(),
+  external_id: z13.string().nullable(),
   email: Email,
   /** Only the tags the contact did not already have. */
-  tags: z12.array(Slug).min(1),
-  source: z12.enum(["api", "dashboard", "signup_form", "import", "automation"]),
+  tags: z13.array(Slug).min(1),
+  source: z13.enum(["api", "dashboard", "signup_form", "import", "automation"]),
   tagged_at: Timestamp
 });
-var ContactUpdatedData = z12.object({
+var ContactUpdatedData = z13.object({
   contact_id: Id,
-  external_id: z12.string().nullable(),
+  external_id: z13.string().nullable(),
   email: Email,
-  changed: z12.array(z12.string()).min(1),
+  changed: z13.array(z13.string()).min(1),
   properties: Properties,
-  source: z12.enum(["api", "dashboard", "signup_form", "import", "automation"]),
+  source: z13.enum(["api", "dashboard", "signup_form", "import", "automation"]),
   updated_at: Timestamp
 });
-var AutomationRunEventBase = z12.object({
+var AutomationRunEventBase = z13.object({
   automation_id: Id,
-  automation_name: z12.string(),
+  automation_name: z13.string(),
   run_id: Id,
-  version: z12.number().int().min(1),
+  version: z13.number().int().min(1),
   contact_id: Id,
-  external_id: z12.string().nullable(),
+  external_id: z13.string().nullable(),
   email: Email
 });
 var AutomationRunStartedData = AutomationRunEventBase.extend({
   /** What let them in: a trigger kind, or `manual` for an explicit enrolment. */
-  trigger_kind: z12.string(),
+  trigger_kind: z13.string(),
   entered_at: Timestamp
 });
 var AutomationRunCompletedData = AutomationRunEventBase.extend({
-  last_step_id: z12.string().nullable(),
+  last_step_id: z13.string().nullable(),
   completed_at: Timestamp
 });
 var AutomationRunExitedData = AutomationRunEventBase.extend({
   reason: AutomationEndReason,
-  step_id: z12.string().nullable(),
+  step_id: z13.string().nullable(),
   exited_at: Timestamp
 });
 var AutomationRunFailedData = AutomationRunEventBase.extend({
-  reason: z12.string(),
-  step_id: z12.string().nullable(),
+  reason: z13.string(),
+  step_id: z13.string().nullable(),
   failed_at: Timestamp
 });
 var AutomationWebhookData = AutomationRunEventBase.extend({
-  step_id: z12.string(),
+  step_id: z13.string(),
   /** The step's own label, when it was given one, so a receiver can branch on a name. */
-  step_label: z12.string().nullable(),
+  step_label: z13.string().nullable(),
   /** Whatever the step carries, verbatim. Null when it carries nothing. */
   payload: JsonValue.nullable(),
   fired_at: Timestamp
 });
-var TemplateEventBase = z12.object({
+var TemplateEventBase = z13.object({
   template_id: Id,
-  name: z12.string().min(1).max(200),
-  version: z12.number().int().min(1),
-  source: z12.enum(["api", "dashboard", "mjml_import"])
+  name: z13.string().min(1).max(200),
+  version: z13.number().int().min(1),
+  source: z13.enum(["api", "dashboard", "mjml_import"])
 });
 var TemplateCreatedData = TemplateEventBase.extend({ created_at: Timestamp });
-var TemplateUpdatedData = TemplateEventBase.extend({ archived: z12.boolean(), updated_at: Timestamp });
+var TemplateUpdatedData = TemplateEventBase.extend({ archived: z13.boolean(), updated_at: Timestamp });
 var TemplateDeletedData = TemplateEventBase.extend({ deleted_at: Timestamp });
-var envelope = (type, data) => z12.object({
+var envelope = (type, data) => z13.object({
   /** Unique per event: a receiver deduplicates on it (deliveries may repeat). */
   id: Id,
-  type: z12.literal(type),
+  type: z13.literal(type),
   created_at: Timestamp,
   workspace_id: Id,
   data
 });
-var WebhookEvent = z12.discriminatedUnion("type", [
+var WebhookEvent = z13.discriminatedUnion("type", [
   envelope("message.sent", MessageSentData),
   envelope("message.failed", MessageFailedData),
   envelope("contact.unsubscribed", ContactUnsubscribedData),
@@ -2696,16 +3676,16 @@ var WebhookEvent = z12.discriminatedUnion("type", [
   envelope("template.updated", TemplateUpdatedData),
   envelope("template.deleted", TemplateDeletedData)
 ]);
-var WebhookEndpoint = z12.object({
+var WebhookEndpoint = z13.object({
   id: Id,
-  url: z12.string().url(),
-  description: z12.string().max(500).nullable(),
-  events: z12.array(WebhookEventType).min(1),
-  enabled: z12.boolean(),
+  url: z13.string().url(),
+  description: z13.string().max(500).nullable(),
+  events: z13.array(WebhookEventType).min(1),
+  enabled: z13.boolean(),
   created_at: Timestamp,
   updated_at: Timestamp
 });
-var WebhookUrl = z12.string().url().refine((u) => {
+var WebhookUrl = z13.string().url().refine((u) => {
   try {
     const url = new URL(u);
     if (url.protocol === "https:") return true;
@@ -2714,35 +3694,35 @@ var WebhookUrl = z12.string().url().refine((u) => {
     return false;
   }
 }, "must be https (http only for localhost)");
-var WebhookEndpointCreate = z12.object({
+var WebhookEndpointCreate = z13.object({
   url: WebhookUrl,
-  description: z12.string().max(500).optional(),
-  events: z12.array(WebhookEventType).min(1),
-  enabled: z12.boolean().optional()
+  description: z13.string().max(500).optional(),
+  events: z13.array(WebhookEventType).min(1),
+  enabled: z13.boolean().optional()
 });
-var WebhookEndpointUpdate = z12.object({
+var WebhookEndpointUpdate = z13.object({
   url: WebhookUrl,
-  description: z12.string().max(500).nullable(),
-  events: z12.array(WebhookEventType).min(1),
-  enabled: z12.boolean()
+  description: z13.string().max(500).nullable(),
+  events: z13.array(WebhookEventType).min(1),
+  enabled: z13.boolean()
 }).partial().refine((v) => Object.keys(v).length > 0, "at least one field");
-var WebhookEndpointWithSecret = z12.object({
+var WebhookEndpointWithSecret = z13.object({
   endpoint: WebhookEndpoint,
-  secret: z12.string().min(32)
+  secret: z13.string().min(32)
 });
 var WEBHOOK_DELIVERY_STATUSES = ["pending", "succeeded", "failed"];
-var WebhookDeliveryStatus = z12.enum(WEBHOOK_DELIVERY_STATUSES);
+var WebhookDeliveryStatus = z13.enum(WEBHOOK_DELIVERY_STATUSES);
 var WEBHOOK_MAX_ATTEMPTS = 8;
 var WEBHOOK_RETRY_DELAYS_SECONDS = [30, 120, 600, 1800, 3600, 7200, 21600];
-var WebhookDelivery = z12.object({
+var WebhookDelivery = z13.object({
   id: Id,
   endpoint_id: Id,
   event_id: Id,
   event_type: WebhookEventType,
   status: WebhookDeliveryStatus,
-  attempts: z12.number().int().min(0),
-  last_status_code: z12.number().int().min(100).max(599).nullable(),
-  last_error: z12.string().nullable(),
+  attempts: z13.number().int().min(0),
+  last_status_code: z13.number().int().min(100).max(599).nullable(),
+  last_error: z13.string().nullable(),
   next_attempt_at: Timestamp.nullable(),
   delivered_at: Timestamp.nullable(),
   created_at: Timestamp
@@ -2751,7 +3731,7 @@ var WebhookDeliveryListQuery = PageQuery.extend({
   status: WebhookDeliveryStatus.optional(),
   event_type: WebhookEventType.optional()
 });
-var WebhookDeliveryParams = z12.object({ id: Id, delivery_id: Id });
+var WebhookDeliveryParams = z13.object({ id: Id, delivery_id: Id });
 
 // src/webhook-signing.ts
 var WEBHOOK_SIGNATURE_HEADER = "x-mail-signature";
@@ -2818,79 +3798,79 @@ async function verifyWebhook(input) {
 }
 
 // src/billing.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 var PLAN_IDS = ["free", "starter", "growth", "design_partner"];
-var PlanId = z13.enum(PLAN_IDS);
-var PlanLimits = z13.object({
-  monthly_messages: z13.number().int().min(0).nullable(),
-  contacts: z13.number().int().min(0).nullable(),
-  members: z13.number().int().min(1).nullable(),
-  providers: z13.number().int().min(1).nullable(),
-  webhook_endpoints: z13.number().int().min(0).nullable(),
+var PlanId = z14.enum(PLAN_IDS);
+var PlanLimits = z14.object({
+  monthly_messages: z14.number().int().min(0).nullable(),
+  contacts: z14.number().int().min(0).nullable(),
+  members: z14.number().int().min(1).nullable(),
+  providers: z14.number().int().min(1).nullable(),
+  webhook_endpoints: z14.number().int().min(0).nullable(),
   /** Automations that may be live (active or paused) at once (A1). */
-  active_automations: z13.number().int().min(0).nullable(),
+  active_automations: z14.number().int().min(0).nullable(),
   /** Steps one automation may hold. Null is the flow's own cap, not unlimited. */
-  automation_steps: z13.number().int().min(1).nullable()
+  automation_steps: z14.number().int().min(1).nullable()
 });
-var PlanFeatures = z13.object({
+var PlanFeatures = z14.object({
   /** A/B tests of subject and content on a mailing (S4). */
-  ab_testing: z13.boolean(),
+  ab_testing: z14.boolean(),
   /** Open and click tracking, still off until a workspace turns it on (`settings.tracking_enabled`). */
-  tracking: z13.boolean(),
+  tracking: z14.boolean(),
   /** Sending and hosting pages on the workspace's own domain (a later phase). */
-  custom_domains: z13.boolean(),
+  custom_domains: z14.boolean(),
   /** Automations: flows a person walks through step by step (A1). */
-  automations: z13.boolean()
+  automations: z14.boolean()
 });
 var PLAN_FEATURES = ["ab_testing", "tracking", "custom_domains", "automations"];
-var Plan = z13.object({
+var Plan = z14.object({
   id: PlanId,
-  name: z13.string().min(1),
+  name: z14.string().min(1),
   /** Price in the smallest currency unit per month; null for plans not sold. */
-  monthly_price_cents: z13.number().int().min(0).nullable(),
-  currency: z13.string().length(3),
+  monthly_price_cents: z14.number().int().min(0).nullable(),
+  currency: z14.string().length(3),
   limits: PlanLimits,
   features: PlanFeatures
 });
-var CatalogPlan = Plan.extend({ sellable: z13.boolean() });
-var Subscription = z13.object({
+var CatalogPlan = Plan.extend({ sellable: z14.boolean() });
+var Subscription = z14.object({
   workspace_id: Id,
   plan: PlanId,
-  status: z13.enum(["active", "trialing", "past_due", "cancelled"]),
+  status: z14.enum(["active", "trialing", "past_due", "cancelled"]),
   current_period_start: Timestamp,
   current_period_end: Timestamp,
-  cancel_at_period_end: z13.boolean(),
+  cancel_at_period_end: z14.boolean(),
   /**
    * A design partner outside billing (plan `design_partner`, no limits, no
    * checkout). Set only by an operator, never through the API.
    */
-  billing_exempt: z13.boolean()
+  billing_exempt: z14.boolean()
 });
 var USAGE_METRICS = ["messages", "contacts", "members", "providers", "webhook_endpoints", "active_automations"];
-var UsageMetric = z13.enum(USAGE_METRICS);
+var UsageMetric = z14.enum(USAGE_METRICS);
 var USAGE_WARNING_RATIO = 0.8;
-var UsageWarning = z13.object({
+var UsageWarning = z14.object({
   metric: UsageMetric,
-  used: z13.number().int().min(0),
-  limit: z13.number().int().min(0),
+  used: z14.number().int().min(0),
+  limit: z14.number().int().min(0),
   /** `approaching`: at or above USAGE_WARNING_RATIO of the limit; `reached`: at or above the limit. */
-  level: z13.enum(["approaching", "reached"])
+  level: z14.enum(["approaching", "reached"])
 });
-var Usage = z13.object({
+var Usage = z14.object({
   plan: PlanId,
   period_start: Timestamp,
   period_end: Timestamp,
-  metrics: z13.record(UsageMetric, z13.object({ used: z13.number().int().min(0), limit: z13.number().int().min(0).nullable() })),
-  warnings: z13.array(UsageWarning)
+  metrics: z14.record(UsageMetric, z14.object({ used: z14.number().int().min(0), limit: z14.number().int().min(0).nullable() })),
+  warnings: z14.array(UsageWarning)
 });
-var CheckoutRequest = z13.object({
-  plan: z13.enum(["starter", "growth"]),
-  success_url: z13.string().url(),
-  cancel_url: z13.string().url()
+var CheckoutRequest = z14.object({
+  plan: z14.enum(["starter", "growth"]),
+  success_url: z14.string().url(),
+  cancel_url: z14.string().url()
 });
-var CheckoutSession = z13.object({ url: z13.string().url() });
-var PortalRequest = z13.object({ return_url: z13.string().url() });
-var PortalSession = z13.object({ url: z13.string().url() });
+var CheckoutSession = z14.object({ url: z14.string().url() });
+var PortalRequest = z14.object({ return_url: z14.string().url() });
+var PortalSession = z14.object({ url: z14.string().url() });
 var USAGE_WARNING_HEADER = "x-mail-usage-warning";
 function formatUsageWarningHeader(warnings) {
   if (warnings.length === 0) return null;
@@ -2910,7 +3890,7 @@ function parseUsageWarningHeader(value) {
 }
 
 // src/routes.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 var list = (item) => page(item);
 var foundationRoutes = {
   "workspaces.create": {
@@ -3118,7 +4098,7 @@ var templateRoutes = {
     path: "/v1/templates/:id/export",
     params: IdParams,
     query: TemplateExportQuery,
-    response: z14.string(),
+    response: z15.string(),
     responseType: "text",
     status: 200,
     access: "read",
@@ -3442,7 +4422,7 @@ var sendingRoutes = {
     path: "/v1/mailings/:id/export",
     params: IdParams,
     query: MailingExportQuery,
-    response: z14.string(),
+    response: z15.string(),
     responseType: "text",
     status: 200,
     access: "read",
@@ -3675,7 +4655,7 @@ var platformRoutes = {
   "contactProperties.list": {
     method: "GET",
     path: "/v1/contact-properties",
-    response: z14.object({ data: z14.array(ContactPropertyDefinition) }),
+    response: z15.object({ data: z15.array(ContactPropertyDefinition) }),
     status: 200,
     access: "read",
     phase: "S4"
@@ -3811,6 +4791,15 @@ var platformRoutes = {
     access: "read",
     phase: "S4"
   },
+  "mailings.languages": {
+    method: "GET",
+    path: "/v1/mailings/:id/languages",
+    params: IdParams,
+    response: MailingLanguageReport,
+    status: 200,
+    access: "read",
+    phase: "S4"
+  },
   "signupForms.list": {
     method: "GET",
     path: "/v1/signup-forms",
@@ -3965,7 +4954,7 @@ var billingRoutes = {
   "billing.plans": {
     method: "GET",
     path: "/v1/billing/plans",
-    response: z14.object({ data: z14.array(CatalogPlan) }),
+    response: z15.object({ data: z15.array(CatalogPlan) }),
     status: 200,
     access: "read",
     phase: "S5"
@@ -4107,7 +5096,7 @@ var automationRoutes = {
     method: "POST",
     path: "/v1/automations/:id/pause",
     params: IdParams,
-    body: z14.object({}).strict(),
+    body: z15.object({}).strict(),
     response: Automation,
     status: 200,
     access: "write",
@@ -4117,7 +5106,7 @@ var automationRoutes = {
     method: "POST",
     path: "/v1/automations/:id/resume",
     params: IdParams,
-    body: z14.object({}).strict(),
+    body: z15.object({}).strict(),
     response: Automation,
     status: 200,
     access: "write",
@@ -4127,7 +5116,7 @@ var automationRoutes = {
     method: "POST",
     path: "/v1/automations/:id/archive",
     params: IdParams,
-    body: z14.object({}).strict(),
+    body: z15.object({}).strict(),
     response: Automation,
     status: 200,
     access: "write",
@@ -4261,13 +5250,13 @@ function matchRoute(method, pathname) {
   for (const [id, route] of Object.entries(routes)) {
     if (route.method !== method) continue;
     const names = [];
-    const pattern = new RegExp(
+    const pattern2 = new RegExp(
       "^" + route.path.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/:([a-z_]+)/g, (_, name) => {
         names.push(name);
         return "([^/]+)";
       }) + "$"
     );
-    const match = pattern.exec(pathname);
+    const match = pattern2.exec(pathname);
     if (!match) continue;
     const params = {};
     names.forEach((name, i) => {
@@ -4408,6 +5397,7 @@ export {
   EXPORT_WARNING_COUNT_HEADER,
   Email,
   EmailStep,
+  EmailStepLanguage,
   ErrorBody,
   ErrorCodeSchema,
   Event,
@@ -4432,6 +5422,8 @@ export {
   IMPORT_SKIP_REASONS,
   IMPORT_STATUSES,
   IMPORT_TERMINAL_STATUSES,
+  INSERTION_PROBLEM_REASONS,
+  INSERTION_TEXT_SLOTS,
   INVITE_REFUSAL_REASONS,
   INVITE_STATUSES,
   Id,
@@ -4449,6 +5441,13 @@ export {
   ImportStatus,
   ImportWarning,
   ImportedAsset,
+  Insertion,
+  InsertionChoice,
+  InsertionChoiceKey,
+  InsertionChoices,
+  InsertionName,
+  InsertionText,
+  Insertions,
   Invite,
   InviteAccept,
   InviteAccepted,
@@ -4459,6 +5458,8 @@ export {
   JsonValue,
   LETTER_RECIPIENT_REFUSAL,
   LIST_UNSUBSCRIBE_POST_VALUE,
+  LOCALE_TAG_PATTERN,
+  LocaleTag,
   MAILING_ACTIONS,
   MAILING_KINDS,
   MAILING_STATUSES,
@@ -4474,6 +5475,9 @@ export {
   MAX_IMPORT_BYTES,
   MAX_IMPORT_ROWS,
   MAX_IMPORT_URL_LENGTH,
+  MAX_INSERTIONS,
+  MAX_INSERTION_CHOICES,
+  MAX_INSERTION_TEXT_LENGTH,
   MAX_INVITE_TTL_DAYS,
   MAX_IN_LIST,
   MAX_LETTER_RECIPIENTS,
@@ -4483,12 +5487,15 @@ export {
   MAX_MJML_ELEMENTS,
   MAX_MJML_IMPORT_BYTES,
   MAX_PAGE_LIMIT,
+  MAX_PREHEADER_LENGTH,
   MAX_RECIPIENTS_PER_BATCH,
   MAX_RE_ENTRY_COOLDOWN_SECONDS,
   MAX_SAVED_SECTIONS,
   MAX_SPLIT_BRANCHES,
   MAX_STEPS,
   MAX_STEP_VISITS,
+  MAX_SUBJECT_LENGTH,
+  MAX_TEMPLATE_TRANSLATIONS,
   MAX_TRIGGERS,
   MEMBER_ROLES,
   MERGE_FIELD_PATTERN,
@@ -4506,6 +5513,9 @@ export {
   MailingExportQuery,
   MailingFinishedData,
   MailingKind,
+  MailingLanguage,
+  MailingLanguageReport,
+  MailingLanguageStatus,
   MailingListQuery,
   MailingMetadata,
   MailingRetryFailedRequest,
@@ -4540,6 +5550,8 @@ export {
   Ok,
   PLAN_FEATURES,
   PLAN_IDS,
+  PREVIEW_EMPTY,
+  PREVIEW_FILLED,
   PROVIDER_KINDS,
   PageQuery,
   Plan,
@@ -4606,6 +5618,7 @@ export {
   SuppressionCreate,
   SuppressionListQuery,
   SuppressionReason,
+  TEMPLATE_LANGUAGE_STATUSES,
   TERMINAL_MAILING_STATUSES,
   Tag,
   TagAssignment,
@@ -4621,8 +5634,13 @@ export {
   TemplateImportPreview,
   TemplateImportPreviewRequest,
   TemplateImportResult,
+  TemplateLanguageStatus,
   TemplateListQuery,
+  TemplatePreheader,
+  TemplateSubject,
   TemplateSummary,
+  TemplateTranslation,
+  TemplateTranslations,
   TemplateUpdate,
   TemplateUpdatedData,
   TemplateVersion,
@@ -4634,6 +5652,8 @@ export {
   TopicCreate,
   TopicUpdate,
   TrackingSettings,
+  TranslationInsertion,
+  TranslationInsertions,
   UNSUBSCRIBE_PATH_PREFIX,
   UNSUBSCRIBE_SOURCES,
   USAGE_METRICS,
@@ -4675,16 +5695,39 @@ export {
   WorkspaceSettings,
   WorkspaceUpdate,
   acceptsIdempotencyKey,
+  addInsertion,
+  addInsertionChoice,
+  addLanguageDraft,
+  alignTranslationInsertions,
   alwaysWaits,
   automationFilterFamily,
   automationRoutes,
   billingRoutes,
   buildPath,
+  buildTemplatePatch,
   canTransition,
+  canonicalLocale,
+  choiceKeyProblem,
+  chooseInsertion,
   cycles,
+  defaultPreviewPick,
   defaultSettings,
+  demoteForSave,
+  demotedBySave,
+  describeMissingTexts,
+  draftDocument,
+  draftInsertionProblems,
+  draftsDirty,
+  draftsFromTemplate,
+  draftsPatch,
+  editInsertionText,
+  editLanguageDraft,
+  editMainInsertionText,
+  editMainInsertions,
+  effectivePreviewPicks,
   emptyFlow,
   errorBody,
+  escapeMergeHtml,
   exportFilename,
   filterConditions,
   filterDepth,
@@ -4694,30 +5737,78 @@ export {
   formatExportWarningsHeader,
   formatUsageWarningHeader,
   foundationRoutes,
+  insertionByProblem,
+  insertionChoices,
+  insertionCoverage,
+  insertionInputs,
+  insertionNameProblem,
+  insertionProblems,
+  insertionRefusalHint,
+  insertionSlotLabel,
+  insertionTextSlots,
+  insertionTokens,
+  insertionValue,
   inviteRoutes,
   isDayEntirelyPast,
   isPublishable,
   isRetryableError,
+  keepLanguageDocument,
+  languageInsertions,
+  languageName,
+  languageTabs,
+  mainInsertionText,
+  matchLocale,
   matchRoute,
+  missingInsertionTexts,
   missingRequiredMergeFields,
+  normalizeChoiceKey,
   nowSeconds,
   operationsWithAccess,
+  ownEntry,
   page,
   parseExportWarningsHeader,
   parseUsageWarningHeader,
+  personalizeHtml,
+  personalizeText,
+  placementProblems,
   platformRoutes,
+  previewControls,
+  previewInsertions,
+  previewPersonalization,
+  primaryLanguage,
   reachable,
+  readyWithoutInsertions,
+  readyWithoutSubject,
+  rebaseDrafts,
+  removeInsertion,
+  removeInsertionChoice,
+  removeLanguageDraft,
+  renameInsertion,
+  renameInsertionChecked,
+  renameInsertionChoice,
+  renameInsertionChoiceChecked,
+  resolveInsertions,
+  restorePatch,
   routes,
+  sampleMergeValue,
+  saveDemotions,
   sendingRoutes,
+  setInsertionBy,
+  setInsertionFilled,
+  setLanguageStatus,
   signWebhook,
   statusForError,
   stepTargets,
+  storedTemplateLine,
   stronglyConnected,
   templateRoutes,
   testGroupSize,
   tightLoops,
   timingSafeEqualString,
+  translationInsertionProblems,
+  translationTextFromInput,
   triggerKey,
+  unplacedInsertions,
   validateAutomation,
   verifyWebhook
 };