@marlinjai/mail-contract 0.4.0 → 0.5.0

package/dist/index.js

@@ -150,6 +150,7 @@ __export(index_exports, {
   EXPORT_WARNING_COUNT_HEADER: () => EXPORT_WARNING_COUNT_HEADER,
   Email: () => Email,
   EmailStep: () => EmailStep,
+  EmailStepLanguage: () => EmailStepLanguage,
   ErrorBody: () => ErrorBody,
   ErrorCodeSchema: () => ErrorCodeSchema,
   Event: () => Event,
@@ -201,6 +202,8 @@ __export(index_exports, {
   JsonValue: () => JsonValue,
   LETTER_RECIPIENT_REFUSAL: () => LETTER_RECIPIENT_REFUSAL,
   LIST_UNSUBSCRIBE_POST_VALUE: () => LIST_UNSUBSCRIBE_POST_VALUE,
+  LOCALE_TAG_PATTERN: () => LOCALE_TAG_PATTERN,
+  LocaleTag: () => LocaleTag,
   MAILING_ACTIONS: () => MAILING_ACTIONS,
   MAILING_KINDS: () => MAILING_KINDS,
   MAILING_STATUSES: () => MAILING_STATUSES,
@@ -225,12 +228,15 @@ __export(index_exports, {
   MAX_MJML_ELEMENTS: () => MAX_MJML_ELEMENTS,
   MAX_MJML_IMPORT_BYTES: () => MAX_MJML_IMPORT_BYTES,
   MAX_PAGE_LIMIT: () => MAX_PAGE_LIMIT,
+  MAX_PREHEADER_LENGTH: () => MAX_PREHEADER_LENGTH,
   MAX_RECIPIENTS_PER_BATCH: () => MAX_RECIPIENTS_PER_BATCH,
   MAX_RE_ENTRY_COOLDOWN_SECONDS: () => MAX_RE_ENTRY_COOLDOWN_SECONDS,
   MAX_SAVED_SECTIONS: () => MAX_SAVED_SECTIONS,
   MAX_SPLIT_BRANCHES: () => MAX_SPLIT_BRANCHES,
   MAX_STEPS: () => MAX_STEPS,
   MAX_STEP_VISITS: () => MAX_STEP_VISITS,
+  MAX_SUBJECT_LENGTH: () => MAX_SUBJECT_LENGTH,
+  MAX_TEMPLATE_TRANSLATIONS: () => MAX_TEMPLATE_TRANSLATIONS,
   MAX_TRIGGERS: () => MAX_TRIGGERS,
   MEMBER_ROLES: () => MEMBER_ROLES,
   MERGE_FIELD_PATTERN: () => MERGE_FIELD_PATTERN,
@@ -248,6 +254,9 @@ __export(index_exports, {
   MailingExportQuery: () => MailingExportQuery,
   MailingFinishedData: () => MailingFinishedData,
   MailingKind: () => MailingKind,
+  MailingLanguage: () => MailingLanguage,
+  MailingLanguageReport: () => MailingLanguageReport,
+  MailingLanguageStatus: () => MailingLanguageStatus,
   MailingListQuery: () => MailingListQuery,
   MailingMetadata: () => MailingMetadata,
   MailingRetryFailedRequest: () => MailingRetryFailedRequest,
@@ -348,6 +357,7 @@ __export(index_exports, {
   SuppressionCreate: () => SuppressionCreate,
   SuppressionListQuery: () => SuppressionListQuery,
   SuppressionReason: () => SuppressionReason,
+  TEMPLATE_LANGUAGE_STATUSES: () => TEMPLATE_LANGUAGE_STATUSES,
   TERMINAL_MAILING_STATUSES: () => TERMINAL_MAILING_STATUSES,
   Tag: () => Tag,
   TagAssignment: () => TagAssignment,
@@ -363,8 +373,13 @@ __export(index_exports, {
   TemplateImportPreview: () => TemplateImportPreview,
   TemplateImportPreviewRequest: () => TemplateImportPreviewRequest,
   TemplateImportResult: () => TemplateImportResult,
+  TemplateLanguageStatus: () => TemplateLanguageStatus,
   TemplateListQuery: () => TemplateListQuery,
+  TemplatePreheader: () => TemplatePreheader,
+  TemplateSubject: () => TemplateSubject,
   TemplateSummary: () => TemplateSummary,
+  TemplateTranslation: () => TemplateTranslation,
+  TemplateTranslations: () => TemplateTranslations,
   TemplateUpdate: () => TemplateUpdate,
   TemplateUpdatedData: () => TemplateUpdatedData,
   TemplateVersion: () => TemplateVersion,
@@ -417,14 +432,22 @@ __export(index_exports, {
   WorkspaceSettings: () => WorkspaceSettings,
   WorkspaceUpdate: () => WorkspaceUpdate,
   acceptsIdempotencyKey: () => acceptsIdempotencyKey,
+  addLanguageDraft: () => addLanguageDraft,
   alwaysWaits: () => alwaysWaits,
   automationFilterFamily: () => automationFilterFamily,
   automationRoutes: () => automationRoutes,
   billingRoutes: () => billingRoutes,
   buildPath: () => buildPath,
+  buildTemplatePatch: () => buildTemplatePatch,
   canTransition: () => canTransition,
+  canonicalLocale: () => canonicalLocale,
   cycles: () => cycles,
   defaultSettings: () => defaultSettings,
+  draftDocument: () => draftDocument,
+  draftsDirty: () => draftsDirty,
+  draftsFromTemplate: () => draftsFromTemplate,
+  draftsPatch: () => draftsPatch,
+  editLanguageDraft: () => editLanguageDraft,
   emptyFlow: () => emptyFlow,
   errorBody: () => errorBody,
   exportFilename: () => exportFilename,
@@ -440,6 +463,10 @@ __export(index_exports, {
   isDayEntirelyPast: () => isDayEntirelyPast,
   isPublishable: () => isPublishable,
   isRetryableError: () => isRetryableError,
+  keepLanguageDocument: () => keepLanguageDocument,
+  languageName: () => languageName,
+  languageTabs: () => languageTabs,
+  matchLocale: () => matchLocale,
   matchRoute: () => matchRoute,
   missingRequiredMergeFields: () => missingRequiredMergeFields,
   nowSeconds: () => nowSeconds,
@@ -448,12 +475,19 @@ __export(index_exports, {
   parseExportWarningsHeader: () => parseExportWarningsHeader,
   parseUsageWarningHeader: () => parseUsageWarningHeader,
   platformRoutes: () => platformRoutes,
+  primaryLanguage: () => primaryLanguage,
   reachable: () => reachable,
+  readyWithoutSubject: () => readyWithoutSubject,
+  rebaseDrafts: () => rebaseDrafts,
+  removeLanguageDraft: () => removeLanguageDraft,
+  restorePatch: () => restorePatch,
   routes: () => routes,
   sendingRoutes: () => sendingRoutes,
+  setLanguageStatus: () => setLanguageStatus,
   signWebhook: () => signWebhook,
   statusForError: () => statusForError,
   stepTargets: () => stepTargets,
+  storedTemplateLine: () => storedTemplateLine,
   stronglyConnected: () => stronglyConnected,
   templateRoutes: () => templateRoutes,
   testGroupSize: () => testGroupSize,
@@ -489,6 +523,29 @@ function page(item) {
 }
 var IdParams = import_zod.z.object({ id: Id });
 var Ok = import_zod.z.object({ ok: import_zod.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 = import_zod.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
 var import_zod2 = require("zod");
@@ -604,32 +661,71 @@ var TemplateDocument = import_zod3.z.object({
   sections: import_zod3.z.array(import_zod3.z.record(import_zod3.z.unknown()))
 }).passthrough();
 var MAX_DOCUMENT_BYTES = 1e6;
+var MAX_SUBJECT_LENGTH = 998;
+var MAX_PREHEADER_LENGTH = 500;
+var TemplateSubject = import_zod3.z.string().max(MAX_SUBJECT_LENGTH).regex(/^[^\x00-\x1f\x7f]*$/, "one line, without control characters");
+var TemplatePreheader = import_zod3.z.string().max(MAX_PREHEADER_LENGTH).regex(/^[^\x00-\x1f\x7f]*$/, "one line, without control characters");
+var TEMPLATE_LANGUAGE_STATUSES = ["draft", "ready"];
+var TemplateLanguageStatus = import_zod3.z.enum(TEMPLATE_LANGUAGE_STATUSES);
+var TemplateTranslation = import_zod3.z.object({
+  subject: TemplateSubject.nullable(),
+  preheader: TemplatePreheader.nullable(),
+  document: TemplateDocument,
+  status: TemplateLanguageStatus
+});
+var MAX_TEMPLATE_TRANSLATIONS = 19;
+var TemplateTranslations = import_zod3.z.record(LocaleTag, TemplateTranslation).refine((t) => Object.keys(t).length <= MAX_TEMPLATE_TRANSLATIONS, `at most ${MAX_TEMPLATE_TRANSLATIONS} language versions`);
 var Template = import_zod3.z.object({
   id: Id,
   name: import_zod3.z.string().min(1).max(200),
   description: import_zod3.z.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. */
+  /**
+   * 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,
+  /** Increments on every saved change, of any language. */
   version: import_zod3.z.number().int().min(1),
   thumbnail_url: import_zod3.z.string().url().nullable(),
   archived_at: Timestamp.nullable(),
   created_at: Timestamp,
   updated_at: Timestamp
 });
-var TemplateSummary = Template.omit({ document: true });
+var TemplateSummary = Template.omit({ document: true, translations: true }).extend({
+  languages: import_zod3.z.record(LocaleTag, TemplateLanguageStatus)
+});
 var TemplateCreate = import_zod3.z.object({
   name: import_zod3.z.string().min(1).max(200),
   description: import_zod3.z.string().max(2e3).optional(),
-  document: TemplateDocument
+  locale: LocaleTag.optional(),
+  subject: TemplateSubject.nullable().optional(),
+  preheader: TemplatePreheader.nullable().optional(),
+  document: TemplateDocument,
+  translations: TemplateTranslations.optional()
 });
 var TemplateUpdate = import_zod3.z.object({
   base_version: import_zod3.z.number().int().min(1),
   name: import_zod3.z.string().min(1).max(200).optional(),
   description: import_zod3.z.string().max(2e3).nullable().optional(),
+  locale: LocaleTag.optional(),
+  subject: TemplateSubject.nullable().optional(),
+  preheader: TemplatePreheader.nullable().optional(),
   document: TemplateDocument.optional(),
+  translations: import_zod3.z.record(LocaleTag, TemplateTranslation.nullable()).optional(),
   archived: import_zod3.z.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.archived !== void 0,
   "at least one field besides base_version"
 );
 var SavedSectionBody = import_zod3.z.record(import_zod3.z.unknown());
@@ -659,7 +755,11 @@ var TemplateListQuery = PageQuery.extend({
 var TemplateVersion = import_zod3.z.object({
   template_id: Id,
   version: import_zod3.z.number().int().min(1),
+  locale: LocaleTag,
+  subject: TemplateSubject.nullable(),
+  preheader: TemplatePreheader.nullable(),
   document: TemplateDocument,
+  translations: TemplateTranslations,
   created_by: import_zod3.z.string().nullable(),
   created_at: Timestamp
 });
@@ -680,7 +780,8 @@ var CompileResult = import_zod3.z.object({
   errors: import_zod3.z.array(CompileMessage)
 });
 var TemplateCompileRequest = import_zod3.z.object({
-  version: import_zod3.z.number().int().min(1).optional()
+  version: import_zod3.z.number().int().min(1).optional(),
+  locale: LocaleTag.optional()
 });
 var CompileRequest = import_zod3.z.object({
   document: TemplateDocument
@@ -772,7 +873,8 @@ var EXPORT_FORMATS = ["mjml", "html"];
 var ExportFormat = import_zod3.z.enum(EXPORT_FORMATS);
 var TemplateExportQuery = import_zod3.z.object({
   format: ExportFormat,
-  version: import_zod3.z.coerce.number().int().min(1).optional()
+  version: import_zod3.z.coerce.number().int().min(1).optional(),
+  locale: LocaleTag.optional()
 });
 var MailingExportQuery = import_zod3.z.object({ format: ExportFormat });
 var EXPORT_CONTENT_TYPES = {
@@ -903,9 +1005,29 @@ var Mailing = import_zod5.z.object({
   name: import_zod5.z.string().max(200).nullable(),
   subject: import_zod5.z.string().min(1).max(998),
   preheader: import_zod5.z.string().max(500).nullable(),
-  /** The template the document was taken from, if any. The snapshot is what is sent. */
+  /**
+   * 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
@@ -936,6 +1058,8 @@ var MailingContent = {
   name: import_zod5.z.string().max(200).optional(),
   subject: import_zod5.z.string().min(1).max(998),
   preheader: import_zod5.z.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
@@ -948,11 +1072,15 @@ var MailingContent = {
 };
 var MailingCreate = import_zod5.z.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 = import_zod5.z.object({
   name: import_zod5.z.string().max(200).nullable().optional(),
@@ -960,6 +1088,7 @@ var MailingUpdate = import_zod5.z.object({
   preheader: import_zod5.z.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()
@@ -982,7 +1111,8 @@ var MailingRetryFailedRequest = import_zod5.z.object({
 var MailingActionRequest = import_zod5.z.object({}).strict();
 var MailingTestRequest = import_zod5.z.object({
   to: Email,
-  merge: Properties.optional()
+  merge: Properties.optional(),
+  locale: LocaleTag.optional()
 });
 var MailingTestResult = import_zod5.z.object({
   message_id: Id,
@@ -1049,9 +1179,27 @@ var MessageSummary = import_zod5.z.object({
   error: import_zod5.z.string().nullable(),
   is_test: import_zod5.z.boolean(),
   recipient_count: import_zod5.z.number().int().min(1),
+  /** The language version the message was sent in; null for messages archived before languages existed. */
+  locale: LocaleTag.nullable(),
   created_at: Timestamp
 });
 var Message = MessageSummary.extend({ html: import_zod5.z.string() });
+var MailingLanguageStatus = import_zod5.z.enum(["main", "ready", "draft", "not_a_workspace_language"]);
+var MailingLanguage = import_zod5.z.object({
+  locale: LocaleTag,
+  status: MailingLanguageStatus,
+  /** Queued recipients who will get this version. */
+  planned: import_zod5.z.number().int().min(0),
+  /** Messages already sent in this language (tests excluded). */
+  sent: import_zod5.z.number().int().min(0)
+});
+var MailingLanguageReport = import_zod5.z.object({
+  main_locale: LocaleTag,
+  send_locale: LocaleTag.nullable(),
+  languages: import_zod5.z.array(MailingLanguage),
+  fallback: import_zod5.z.array(import_zod5.z.object({ wanted: import_zod5.z.string(), planned: import_zod5.z.number().int().min(1) })),
+  no_language: import_zod5.z.number().int().min(0)
+});
 var MessageListQuery = PageQuery.extend({
   mailing_id: Id.optional(),
   outcome: MessageOutcome.optional()
@@ -1561,15 +1709,22 @@ var Unchosen = import_zod7.z.literal("");
 var DraftSlug = import_zod7.z.union([Slug, Unchosen]);
 var DraftPropertyKey = import_zod7.z.union([ContactPropertyKey, Unchosen]);
 var label = { label: import_zod7.z.string().max(120).nullish() };
+var EmailStepLanguage = import_zod7.z.object({
+  subject: import_zod7.z.string().min(1).max(998),
+  preheader: import_zod7.z.string().max(500).nullable(),
+  document: TemplateDocument
+}).strict();
 var EmailStep = import_zod7.z.object({
   kind: import_zod7.z.literal("email"),
   ...label,
   ...next,
   template_id: Id.nullish(),
   document: TemplateDocument.nullish(),
-  /** Empty while the step is being written; `not_chosen` refuses to publish it. */
+  /** Empty while the step is being written, or when its template has a subject; else `not_chosen` refuses to publish it. */
   subject: import_zod7.z.string().max(998),
-  preheader: import_zod7.z.string().max(500).nullish()
+  preheader: import_zod7.z.string().max(500).nullish(),
+  locale: LocaleTag.nullish(),
+  languages: import_zod7.z.record(LocaleTag, EmailStepLanguage).nullish()
 }).strict();
 var DelayStep = import_zod7.z.object({
   kind: import_zod7.z.literal("delay"),
@@ -1875,7 +2030,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);
@@ -2360,7 +2515,7 @@ var AutomationReport = import_zod7.z.object({
 var AutomationExitRunRequest = import_zod7.z.object({ reason: import_zod7.z.string().max(200).optional() }).strict();
 var AutomationRunParams = import_zod7.z.object({ id: Id, run_id: Id });
 var AutomationStepParams = import_zod7.z.object({ id: Id, step_id: StepId });
-var AutomationTestEmailRequest = import_zod7.z.object({ to: Email, merge: Properties.optional() }).strict();
+var AutomationTestEmailRequest = import_zod7.z.object({ to: Email, merge: Properties.optional(), locale: LocaleTag.optional() }).strict();
 var AutomationValidateRequest = import_zod7.z.object({ flow: AutomationFlow.optional(), settings: AutomationSettings.partial().optional() }).strict();
 var EventCreate = import_zod7.z.object({
   name: EventName,
@@ -2429,10 +2584,19 @@ var MergeDefaults = import_zod8.z.record(MergeFieldName, MergeDefaultValue).refi
   message: `a reserved merge field (${Object.keys(RESERVED_MERGE_FIELDS).join(", ")}) cannot have a workspace default`
 });
 var WorkspaceSettings = import_zod8.z.object({
-  /** Default language of the hosted unsubscribe page (BCP 47 tag, e.g. "de"). */
-  default_locale: import_zod8.z.string().min(2).max(35),
-  /** Languages the hosted pages are offered in. Includes `default_locale`. */
-  locales: import_zod8.z.array(import_zod8.z.string().min(2).max(35)).min(1).max(20),
+  /**
+   * 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: import_zod8.z.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: import_zod8.z.boolean(),
   /** Where images, stylesheets and fonts in a mail may load from. `any` by default. */
@@ -2684,6 +2848,200 @@ var InviteAccepted = import_zod9.z.object({
 });
 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 = {};
+  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 };
+    }
+  }
+  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 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;
+  }
+  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,
+    ...Object.keys(patch).length > 0 ? { translations: patch } : {}
+  };
+  return { update, skipped: skipped.sort() };
+}
+function draftsFromTemplate(template) {
+  const translations = {};
+  for (const [tag, version] of Object.entries(template.translations)) translations[canonicalLocale(tag) ?? tag] = version;
+  return {
+    main: { subject: template.subject ?? "", preheader: template.preheader ?? "", document: template.document },
+    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"
+      }
+    },
+    changed: withChanged(drafts.changed, tag),
+    removed: without(drafts.removed, tag)
+  };
+}
+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,
+    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 (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 out;
+}
+
 // src/providers.ts
 var import_zod10 = require("zod");
 var PROVIDER_KINDS = ["smtp", "resend"];
@@ -4278,6 +4636,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",
@@ -4876,6 +5243,7 @@ function matchRoute(method, pathname) {
   EXPORT_WARNING_COUNT_HEADER,
   Email,
   EmailStep,
+  EmailStepLanguage,
   ErrorBody,
   ErrorCodeSchema,
   Event,
@@ -4927,6 +5295,8 @@ function matchRoute(method, pathname) {
   JsonValue,
   LETTER_RECIPIENT_REFUSAL,
   LIST_UNSUBSCRIBE_POST_VALUE,
+  LOCALE_TAG_PATTERN,
+  LocaleTag,
   MAILING_ACTIONS,
   MAILING_KINDS,
   MAILING_STATUSES,
@@ -4951,12 +5321,15 @@ function matchRoute(method, pathname) {
   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,
@@ -4974,6 +5347,9 @@ function matchRoute(method, pathname) {
   MailingExportQuery,
   MailingFinishedData,
   MailingKind,
+  MailingLanguage,
+  MailingLanguageReport,
+  MailingLanguageStatus,
   MailingListQuery,
   MailingMetadata,
   MailingRetryFailedRequest,
@@ -5074,6 +5450,7 @@ function matchRoute(method, pathname) {
   SuppressionCreate,
   SuppressionListQuery,
   SuppressionReason,
+  TEMPLATE_LANGUAGE_STATUSES,
   TERMINAL_MAILING_STATUSES,
   Tag,
   TagAssignment,
@@ -5089,8 +5466,13 @@ function matchRoute(method, pathname) {
   TemplateImportPreview,
   TemplateImportPreviewRequest,
   TemplateImportResult,
+  TemplateLanguageStatus,
   TemplateListQuery,
+  TemplatePreheader,
+  TemplateSubject,
   TemplateSummary,
+  TemplateTranslation,
+  TemplateTranslations,
   TemplateUpdate,
   TemplateUpdatedData,
   TemplateVersion,
@@ -5143,14 +5525,22 @@ function matchRoute(method, pathname) {
   WorkspaceSettings,
   WorkspaceUpdate,
   acceptsIdempotencyKey,
+  addLanguageDraft,
   alwaysWaits,
   automationFilterFamily,
   automationRoutes,
   billingRoutes,
   buildPath,
+  buildTemplatePatch,
   canTransition,
+  canonicalLocale,
   cycles,
   defaultSettings,
+  draftDocument,
+  draftsDirty,
+  draftsFromTemplate,
+  draftsPatch,
+  editLanguageDraft,
   emptyFlow,
   errorBody,
   exportFilename,
@@ -5166,6 +5556,10 @@ function matchRoute(method, pathname) {
   isDayEntirelyPast,
   isPublishable,
   isRetryableError,
+  keepLanguageDocument,
+  languageName,
+  languageTabs,
+  matchLocale,
   matchRoute,
   missingRequiredMergeFields,
   nowSeconds,
@@ -5174,12 +5568,19 @@ function matchRoute(method, pathname) {
   parseExportWarningsHeader,
   parseUsageWarningHeader,
   platformRoutes,
+  primaryLanguage,
   reachable,
+  readyWithoutSubject,
+  rebaseDrafts,
+  removeLanguageDraft,
+  restorePatch,
   routes,
   sendingRoutes,
+  setLanguageStatus,
   signWebhook,
   statusForError,
   stepTargets,
+  storedTemplateLine,
   stronglyConnected,
   templateRoutes,
   testGroupSize,