@koda-sl/baker-cli 0.542.0 → 0.544.0

package/dist/translate-2IHE5YDI.js

@@ -0,0 +1,603 @@
+import {
+  withoutFields
+} from "./chunk-XTZVZHTN.js";
+import {
+  leadVersion,
+  runBaker,
+  seriesLeadsAbove,
+  writeSeriesMemberCanvas
+} from "./chunk-3KIRDKVB.js";
+import "./chunk-GFBEO33K.js";
+import "./chunk-TNZUMU55.js";
+import {
+  isCustomersWords,
+  isSignatureLine,
+  languageName,
+  languageRegion,
+  languageTag,
+  maybeSigned,
+  parseDefinitionStrategyFields,
+  sameTag,
+  tagSlug
+} from "./chunk-LUIV5R2Z.js";
+import "./chunk-V2SU2SVZ.js";
+import "./chunk-6REXNFPV.js";
+import "./chunk-EKX37C3T.js";
+import {
+  setDefinitionFields
+} from "./chunk-WOE4TZHJ.js";
+import "./chunk-GN7K3NPI.js";
+import "./chunk-PKZA7XCB.js";
+import "./chunk-RJS47NTI.js";
+import "./chunk-7RXR34EN.js";
+import "./chunk-C4EE6LIF.js";
+import "./chunk-Z7BNOHTY.js";
+import "./chunk-RHEWQB5O.js";
+import "./chunk-4GLSV5AI.js";
+import "./chunk-3BI2PHW4.js";
+import "./chunk-NBWZVBDG.js";
+import "./chunk-G6XKD7QE.js";
+import "./chunk-NGQ5J4FV.js";
+import {
+  holdUnbilledSpend
+} from "./chunk-VWOKPC3T.js";
+import {
+  findWorkspaceRoot
+} from "./chunk-BGT5ZA4L.js";
+import "./chunk-JY3OJBKZ.js";
+import "./chunk-XYNQMRNX.js";
+import "./chunk-TARINRA4.js";
+import "./chunk-DGCUPJZD.js";
+import "./chunk-RP36XHWT.js";
+import {
+  isAdSpec,
+  readAdSpec
+} from "./chunk-KIXVHP2C.js";
+import {
+  RENDER_REVIEW_MODEL,
+  askAboutImages
+} from "./chunk-4D73PLXU.js";
+import "./chunk-MCJ5I5LR.js";
+import "./chunk-2WZI36D3.js";
+import "./chunk-65Y3RCWP.js";
+import {
+  askJev
+} from "./chunk-JF2XP76K.js";
+import "./chunk-SYLPRIFM.js";
+import "./chunk-XBR7TSZN.js";
+import "./chunk-DGUN7FUH.js";
+import "./chunk-NFXW6C6I.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-NSBNIPIW.js";
+import "./chunk-TI4UL56R.js";
+import "./chunk-B2OHCWYB.js";
+import "./chunk-SVUFNCOE.js";
+import "./chunk-E54435XT.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-WCIS4FZH.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/creatives/translate.ts
+import { readFile as readFile2 } from "fs/promises";
+import path2 from "path";
+import { defineCommand } from "citty";
+
+// src/commands/creatives/translate-ad.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import path from "path";
+
+// src/commands/creatives/translate-model.ts
+import { z } from "zod";
+function parseLanguages(raw, sourceLanguage) {
+  const asked = raw.split(",").map((code) => code.trim()).filter(Boolean);
+  if (asked.length === 0) {
+    return {
+      code: "translate_language_invalid",
+      message: "No language was named.",
+      fix: "Name each language as a code, comma-separated: --to es,de,fr (pt-BR, es-MX for a regional variant)."
+    };
+  }
+  const languages = [];
+  for (const code of asked) {
+    const tag = languageTag(code);
+    if (!tag) {
+      return {
+        code: "translate_language_invalid",
+        message: `"${code}" is not a language code.`,
+        fix: "Name each language as a BCP-47 code: es, de, fr, pt-BR, es-MX."
+      };
+    }
+    if (sourceLanguage && sameTag(tag, sourceLanguage)) {
+      return {
+        code: "translate_same_language",
+        message: `The ad is already in ${languageName(tag) ?? tag}.`,
+        fix: `Leave ${code} out of --to.`
+      };
+    }
+    if (!languages.some((l) => sameTag(l, tag))) languages.push(tag);
+  }
+  return { languages };
+}
+var quoteLineQuestion = (text) => ({
+  instructions: {
+    question: "Is `line` a customer's or reviewer's own words (a testimonial, or a quote signed with the name of the person who said it), rather than the advertiser's own copy, in whatever language it is written?",
+    line: text
+  }
+});
+var CUSTOMERS_WORDS = 0.5;
+function signedLines(lines) {
+  const signed = /* @__PURE__ */ new Set();
+  lines.forEach((line, i) => {
+    if (line.role === MESSAGE_ROLE) return;
+    const below = lines[i + 1];
+    if (isCustomersWords(line) || below !== void 0 && isSignatureLine(below)) signed.add(i);
+  });
+  return signed;
+}
+async function customersWordsAmong(lines, judge) {
+  const kept = signedLines(lines);
+  const open = lines.flatMap((line, i) => line.role === MESSAGE_ROLE || kept.has(i) ? [] : [i]);
+  if (!judge || open.length === 0) return kept;
+  const asked = (i) => {
+    const text = lines[i]?.text ?? "";
+    const below = lines[i + 1]?.text;
+    return below !== void 0 && maybeSigned(below) && !maybeSigned(text) ? `${text}
+${below}` : text;
+  };
+  const answers = await judge(open.map(asked));
+  if (answers?.length !== open.length) return kept;
+  for (const [k, i] of open.entries()) if ((answers[k] ?? 0) >= CUSTOMERS_WORDS) kept.add(i);
+  return kept;
+}
+var MESSAGE_ROLE = "message";
+var Answer = z.object({ translations: z.record(z.string(), z.array(z.string()).catch([])) });
+function acceptTranslations(answer, languages, lineCount) {
+  const wrapped = answer && typeof answer === "object" && !("translations" in answer) ? { translations: answer } : answer;
+  const parsed = Answer.safeParse(wrapped);
+  if (!parsed.success) return {};
+  const byTag = new Map(Object.entries(parsed.data.translations).map(([key, lines]) => [key.toLowerCase(), lines]));
+  const kept = {};
+  for (const language of languages) {
+    const lines = byTag.get(language.toLowerCase())?.map((line) => line.trim());
+    if (lines && lines.length === lineCount && lines.every(Boolean)) kept[language] = lines;
+  }
+  return kept;
+}
+function lineByKey(key, lines) {
+  if (/^\d+$/.test(key)) {
+    const n = Number(key) - 1;
+    return n >= 0 && n < lines.length ? n : void 0;
+  }
+  const i = lines.findIndex((l) => l.role !== MESSAGE_ROLE && l.role?.toLowerCase() === key.trim().toLowerCase());
+  return i === -1 ? void 0 : i;
+}
+function lineOverrides(file, languages, lines) {
+  const byTag = languageEntries(file);
+  const out = {};
+  for (const language of languages) {
+    const given = byTag.get(language.toLowerCase());
+    if (!given || Array.isArray(given) || typeof given !== "object") continue;
+    const words = {};
+    for (const [key, text] of Object.entries(given)) {
+      const i = lineByKey(key, lines);
+      if (i !== void 0 && typeof text === "string" && text.trim()) words[i] = text.trim();
+    }
+    if (Object.keys(words).length > 0) out[language] = words;
+  }
+  return out;
+}
+function unknownLineKeys(file, language, lines) {
+  const given = languageEntries(file).get(language.toLowerCase());
+  if (!given || Array.isArray(given) || typeof given !== "object") return [];
+  return Object.keys(given).filter((key) => lineByKey(key, lines) === void 0);
+}
+function numberedLines(lines) {
+  return lines.filter((l) => l.role !== MESSAGE_ROLE).map((l, i) => `${i + 1}${l.role ? ` ${l.role}` : ""}: ${JSON.stringify(l.text)}`).join("; ");
+}
+function languageEntries(file) {
+  const record = file && typeof file === "object" && !Array.isArray(file) ? file : {};
+  const languages = record.translations && typeof record.translations === "object" ? record.translations : record;
+  return new Map(Object.entries(languages).map(([k, v]) => [k.toLowerCase(), v]));
+}
+function buildTranslatePrompt(lines, languages, context) {
+  const from = context.from ? languageName(context.from) : null;
+  return [
+    `These are the lines of copy printed on a finished static ad${from ? `, written in ${from}` : ""}. Translate them${from ? ` from ${from}` : ""} into each of these languages: ${languages.map((l) => `${l} (${languageName(l) ?? l})`).join(", ")}.`,
+    "",
+    ...lines.map(
+      (line, i) => `${i + 1}. ${line.role === MESSAGE_ROLE ? "[not printed: what the ad says, in one sentence, for the team that runs it] " : line.role ? `[${line.role}] ` : ""}${line.customersWords ? "[a customer's own words: copy it exactly as written, untranslated] " : ""}${JSON.stringify(line.text)}`
+    ),
+    "",
+    "Rules:",
+    "- Transcreate as a native copywriter of that market would write the ad, not word for word: the same promise and tone, natural for the people who will see it.",
+    "- Each line keeps its role: a headline stays a headline, a button stays a short button.",
+    "- Keep each line about as long as the original: it is set in the same layout, in the same space, so a much longer line will not fit.",
+    `- Keep brand names${context.brand ? ` (${JSON.stringify(context.brand)})` : ""}, product names, numbers, prices, currencies, percentages and URLs exactly as they are.`,
+    "- Use the language's own accents and punctuation (\xBF \xA1 \xAB \xBB \xDF \xE7 \xE3).",
+    ...varieties(languages),
+    ...context.note ? [
+      "",
+      `The team's own instructions for this translation. Follow them over the rules above, except that a customer's own words stay exactly as written.
+${context.note}`
+    ] : [],
+    "",
+    `Reply with only this JSON, one array per language with exactly ${lines.length} lines in the order above: {"translations": {${languages.map((l) => `"${l}": ["..."]`).join(", ")}}}`
+  ].join("\n");
+}
+function translatedSpec(source, lines, language, customersWords = /* @__PURE__ */ new Set()) {
+  const spec = isAdSpec(source) ? source : readAdSpec(source);
+  const copy = Array.isArray(spec.copy) ? spec.copy : [];
+  const viewer = spec.viewer;
+  return {
+    ...spec,
+    // A customer's words stay theirs: translated, they would be words nobody said under their name.
+    copy: copy.map((line, i) => customersWords.has(i) ? line : { ...line, text: lines[i] ?? line.text }),
+    ...viewer?.market ? { viewer: { ...viewer, market: { ...viewer.market, ...marketOf(language) } } } : {}
+  };
+}
+var OWN_FIELDS = ["series", "language", "title", "status"];
+function translatedDefinition(source, translation) {
+  return setDefinitionFields(withoutFields(source, OWN_FIELDS), {
+    title: translation.title.slice(0, 120),
+    series: translation.source,
+    language: translation.language,
+    status: "draft",
+    ...translation.message ? { message: translation.message } : {}
+  });
+}
+function varieties(languages) {
+  const regional = languages.flatMap((tag) => {
+    const region = languageRegion(tag);
+    return region ? [
+      `- ${tag}: write it as people in ${region.name} write ads: its own vocabulary, spelling, idioms and form of address (t\xFA, usted or vos as ads there use it), not a neutral one and not a neighbouring country's variety of the same language.`
+    ] : [];
+  });
+  return regional.length > 0 ? ["", "Each regional variant is its own ad:", ...regional] : [];
+}
+function marketOf(language) {
+  const region = languageRegion(language);
+  return region ? { language, country: region.code } : { language };
+}
+
+// src/commands/creatives/translate-ad.ts
+function comparable(spec) {
+  try {
+    return JSON.stringify(readAdSpec(spec));
+  } catch {
+    return null;
+  }
+}
+async function changedSinceRender(root, source, rendered) {
+  const raw = await readFile(path.join(creativeDir(root, source), "prompt.json"), "utf8").catch(() => null);
+  if (raw === null) return false;
+  let now;
+  try {
+    now = JSON.parse(raw);
+  } catch {
+    return false;
+  }
+  const [a, b] = [comparable(now), comparable(rendered)];
+  return a !== null && b !== null && a !== b;
+}
+var translationSlug = (source, language) => `${source}-${tagSlug(language)}`;
+var creativeDir = (root, slug) => path.join(root, "src", "creatives", slug);
+function definitionOf(root, slug) {
+  return readFile(path.join(creativeDir(root, slug), "_definition.md"), "utf8").catch(() => null);
+}
+function sourceLanguageOf(definition, spec) {
+  const market = spec.viewer?.market?.language;
+  return parseDefinitionStrategyFields(definition).language ?? (typeof market === "string" ? languageTag(market) ?? void 0 : void 0);
+}
+async function planLanguages(root, source, languages, again) {
+  const settled = [];
+  const pending = [];
+  for (const language of languages) {
+    const creative = translationSlug(source, language);
+    const existing = await definitionOf(root, creative);
+    const fields = existing === null ? null : parseDefinitionStrategyFields(existing);
+    const ours = fields?.seriesLead === source && sameTag(fields.language ?? "", language);
+    if (!fields || again && ours) {
+      pending.push(language);
+    } else if (ours) {
+      settled.push({ language, creative, status: "exists" });
+    } else {
+      settled.push({
+        language,
+        creative,
+        status: "refused",
+        error: {
+          code: "translate_slug_taken",
+          message: `"${creative}" is already another creative, not the ${languageName(language) ?? language} version of "${source}".`,
+          fix: `Rename or remove src/creatives/${creative}/ if it is a leftover, then translate again.`
+        }
+      });
+    }
+  }
+  return { settled, pending };
+}
+function wordsInFile(copy, pending, overrides, lines) {
+  const printed = lines.flatMap((l, i) => l.role === MESSAGE_ROLE ? [] : [i]);
+  const full = acceptTranslations(copy, pending, lines.length);
+  const printedOnly = printed.length < lines.length ? acceptTranslations(copy, pending, printed.length) : {};
+  const byLine = Object.entries(overrides).flatMap(
+    ([language, given]) => printed.every((i) => given[i] !== void 0) ? [[language, printed.map((i) => given[i] ?? "")]] : []
+  );
+  return { ...Object.fromEntries(byLine), ...printedOnly, ...full };
+}
+async function wordsFor(pending, overrides, lines, context, deps) {
+  if (pending.length === 0) return { words: {}, asked: [] };
+  const fromFile = deps.copy === void 0 ? {} : wordsInFile(deps.copy, pending, overrides, lines);
+  const asked = deps.copy === void 0 ? [...pending] : pending.filter((l) => overrides[l] && !fromFile[l]);
+  const note = deps.note ? { note: deps.note } : {};
+  const answer = asked.length > 0 ? await deps.ask(buildTranslatePrompt(lines, asked, { ...context, ...note })) : null;
+  const answered = asked.length > 0 ? acceptTranslations(answer, asked, lines.length) : {};
+  const words = { ...fromFile };
+  for (const language of asked) {
+    const written = answered[language];
+    if (written) words[language] = written.map((text, i) => overrides[language]?.[i] ?? text);
+  }
+  return { words, asked };
+}
+async function translateAd(root, source, to, deps) {
+  const version = await leadVersion(root, source, deps.fetchRecord);
+  if ("refused" in version) return version.refused;
+  const spec = version.spec;
+  if (spec.native) {
+    return {
+      code: "translate_native_unsupported",
+      message: `"${source}" is a copy of a screen people know (a post, a chat, a review wall): its words are not lines of copy to translate.`,
+      fix: "Make it in the other language as its own ad: baker creatives make <idea> with the words written in that language."
+    };
+  }
+  const sourceDefinition = await definitionOf(root, source) ?? "---\nkind: static\n---\n";
+  const sourceLanguage = sourceLanguageOf(sourceDefinition, spec);
+  const asked = parseLanguages(to, sourceLanguage);
+  if ("code" in asked) return asked;
+  const { settled, pending } = await planLanguages(root, source, asked.languages, deps.again === true);
+  const lines = version.lead.copy;
+  const quoted = pending.length > 0 ? await customersWordsAmong(lines, deps.judgeQuotes) : /* @__PURE__ */ new Set();
+  const signed = signedLines(lines);
+  const overrides = deps.copy !== void 0 ? lineOverrides(deps.copy, pending, lines) : {};
+  const quotedIn = (language) => new Set([...quoted].filter((i) => overrides[language]?.[i] === void 0 || signed.has(i)));
+  const unchanged = pending.filter((language) => lines.every((_, i) => quotedIn(language).has(i)));
+  const open = pending.filter((language) => !unchanged.includes(language));
+  const brand = readAdSpec(spec).brand?.name;
+  const message = parseDefinitionStrategyFields(sourceDefinition).message;
+  const marked = lines.map((line, i) => quoted.has(i) ? { ...line, customersWords: true } : line);
+  const asks = message ? [...marked, { text: message, role: MESSAGE_ROLE }] : marked;
+  const { words, asked: modelAsked } = await wordsFor(
+    open,
+    overrides,
+    asks,
+    { ...sourceLanguage ? { from: sourceLanguage } : {}, ...brand ? { brand } : {} },
+    deps
+  );
+  const translations = [...settled, ...unchanged.map((language) => nothingToTranslate(source, language))];
+  for (const language of open) {
+    translations.push(
+      await makeTranslation(
+        root,
+        {
+          source,
+          language,
+          sourceDefinition,
+          spec,
+          lines,
+          quoted: quotedIn(language),
+          signed,
+          words: words[language],
+          fromModel: modelAsked.includes(language)
+        },
+        deps
+      )
+    );
+  }
+  const order = new Map(asked.languages.map((l, i) => [l, i]));
+  translations.sort((a, b) => (order.get(a.language) ?? 0) - (order.get(b.language) ?? 0));
+  return {
+    source,
+    ...sourceLanguage ? { sourceLanguage } : {},
+    leadsAbove: await seriesLeadsAbove(root, source),
+    translations,
+    ...await changedSinceRender(root, source, version.spec) ? { changedSinceRender: true } : {}
+  };
+}
+function nothingToTranslate(source, language) {
+  const name = languageName(language) ?? language;
+  return {
+    language,
+    creative: translationSlug(source, language),
+    status: "refused",
+    error: {
+      code: "translate_nothing_to_translate",
+      message: `Every line of "${source}" is a customer's own words, kept as they said them, so in ${name} it would be the same ad.`,
+      fix: `Never translate a customer's words yourself: that puts words they never said under their name. To reach ${name} speakers, run "${source}" as it is, or give it a line of your own (a headline or a call to action), render it, then translate again.`
+    }
+  };
+}
+function copyMissing(language, name, lines, unknown) {
+  const named = unknown.map((key) => JSON.stringify(key)).join(", ");
+  return {
+    code: "translate_copy_missing",
+    message: unknown.length ? `The copy file's ${name} lines ${named} name no line of the ad.` : `The copy file has no ${name} lines, or not one for each of the ad's ${lines.length} lines.`,
+    fix: `Give "${language}" an array of ${lines.length} lines in the ad's order, or only the lines to change, by number or role ({"${language}": {"headline": "\u2026"}}): the model writes the rest. The ad's lines: ${numberedLines(lines)}.`
+  };
+}
+async function makeTranslation(root, t, deps) {
+  const creative = translationSlug(t.source, t.language);
+  const refused = (error) => ({ language: t.language, creative, status: "refused", error });
+  const name = languageName(t.language) ?? t.language;
+  if (!t.words) {
+    return refused(
+      !t.fromModel ? copyMissing(t.language, name, t.lines, unknownLineKeys(deps.copy, t.language, t.lines)) : {
+        code: "translate_failed",
+        message: `The ${name} words could not be written.`,
+        fix: `Write them yourself: --copy-file <json> with {"${t.language}": [${t.lines.length} lines in the ad's order]}.`
+      }
+    );
+  }
+  const dir = creativeDir(root, creative);
+  const definitionPath = path.join(dir, "_definition.md");
+  await mkdir(dir, { recursive: true });
+  await writeFile(
+    path.join(dir, "prompt.json"),
+    `${JSON.stringify(translatedSpec(t.spec, t.words, t.language, t.quoted), null, 2)}
+`,
+    "utf8"
+  );
+  const headline = Math.max(
+    0,
+    t.lines.findIndex((l) => l.role === "headline")
+  );
+  await writeFile(
+    definitionPath,
+    translatedDefinition(t.sourceDefinition, {
+      source: t.source,
+      language: t.language,
+      title: t.words[headline] ?? creative,
+      ...t.words.length > t.lines.length ? { message: t.words[t.lines.length] } : {}
+    }),
+    "utf8"
+  );
+  const made = await writeSeriesMemberCanvas(root, creative, {
+    leadWords: true,
+    ...deps.fetchRecord ? { fetchRecord: deps.fetchRecord } : {}
+  });
+  if (made === null || "refused" in made) {
+    return refused(made?.refused ?? { code: "translate_not_made", message: `"${creative}" could not be made.` });
+  }
+  await deps.sync(dir);
+  const kept = [...t.quoted].sort((a, b) => a - b);
+  const judged = kept.filter((i) => !t.signed.has(i)).map((i) => i + 1);
+  return {
+    language: t.language,
+    creative,
+    status: "made",
+    ...kept.length ? { kept: kept.map((i) => t.lines[i]?.text ?? "") } : {},
+    ...judged.length ? { judged } : {}
+  };
+}
+function keptHint(source, t) {
+  const kept = (t.kept ?? []).map((text) => JSON.stringify(text)).join(", ");
+  const [line] = t.judged ?? [];
+  const change = line ? ` If line ${line} is the ad's own words, not a customer's, write it yourself: baker creatives translate --slug ${source} --to ${t.language} --again --copy-file with {"${t.language}": {"${line}": "<its words in ${t.language}>"}}; the model writes the other lines again.` : "";
+  return `${t.creative}: kept as the customer said them, untranslated: ${kept}.${change}`;
+}
+function translateEnvelope(result) {
+  const made = result.translations.filter((t) => t.status !== "refused").map((t) => t.creative);
+  const refused = result.translations.filter((t) => t.status === "refused");
+  const order = [...result.leadsAbove].reverse().concat(result.source);
+  return {
+    ok: true,
+    data: {
+      source: result.source,
+      made,
+      translations: result.translations.map((t) => ({ ...t, name: languageName(t.language) ?? t.language }))
+    },
+    hints: [
+      ...result.changedSinceRender ? [
+        `src/creatives/${result.source}/prompt.json was changed since its last render, and every language is made from the version rendered: none of them has that change. Never say they do. To carry it: baker canvas run --slug ${result.source}, then translate again with --again.`
+      ] : [],
+      ...made.length > 0 ? [
+        `Next: baker canvas run --series ${result.source} renders every language at once, each the ${result.source} picture with its own words, reviewed and corrected on its own. A language already rendered from the current version of ${result.source} is not rendered again.`
+      ] : [],
+      ...made.length > 0 ? [
+        `To change a line of one language (a word the person wants otherwise, a line too long), edit its words in that ad's own copy, src/creatives/${made[0]}/prompt.json \`copy\` (never its design), then baker canvas run --series ${result.source}: only that ad is made again. To change how every line reads (tone, t\xFA or usted, a term to keep), translate again with --again --note "<what to change>"; --again writes every line of that language again.`
+      ] : [],
+      `A later change to ${result.source} (its picture or design) reaches every language on the next ${order.map((slug) => `baker canvas run --series ${slug}`).join(", then ")}. A change to its words does not: translate again with --again for the languages to update.`,
+      ...refused.map((t) => `${t.creative}: ${t.error?.message ?? "not made"}${t.error?.fix ? ` ${t.error.fix}` : ""}`),
+      ...result.translations.flatMap((t) => t.kept?.length ? [keptHint(result.source, t)] : [])
+    ]
+  };
+}
+
+// src/commands/creatives/translate.ts
+var TRANSLATE_TIMEOUT_MS = 12e4;
+var DESCRIPTION = `The same static ad in other languages. Each language becomes its own creative, <ad>-<lang>, made as an ad of the series <ad> leads: its ready picture with only the words changed, so the design is never made again per language. Every language is translated in one call (transcreated for the market, same role and length per line, brand names, prices and numbers kept); seconds, nothing rendered. The ad must have a ready version.
+
+Start here:
+  baker creatives translate --slug spring-offer --to es-MX,es-CO,pt-BR     # one ad per country: Mexico and Colombia are two ads
+  baker creatives translate --slug spring-offer --to de,fr                 # a language with no country: its neutral variety
+  baker creatives translate --slug spring-offer --to de --copy-file de.json   # your own lines: {"de": ["line 1", "line 2"]}
+  baker creatives translate --slug spring-offer --to de --copy-file de.json   # only some lines yours, the model writes the rest: {"de": {"headline": "\u2026", "3": "\u2026"}}
+  baker creatives translate --slug spring-offer --to es-MX --note "Informal t\xFA. Keep 'Pro' in English."   # brief the translator
+To change one line of one language after: edit src/creatives/<ad>-<lang>/prompt.json copy, then baker canvas run --series <ad>.
+Ten angle ads in three languages: one design (the lead), the angle ads (creatives make <idea> --series <lead>), then translate each angle ad. Never a new canvas or a new design per language.
+Then: baker canvas run --series spring-offer (renders every language at once). Adding a language later leaves the ones made as they are.`;
+var ARGS = {
+  slug: {
+    type: "string",
+    required: true,
+    description: "The ad to translate (its creative slug); it must have a ready version"
+  },
+  to: {
+    type: "string",
+    required: true,
+    description: "The languages, comma-separated BCP-47 codes: es-MX,es-CO,pt-BR (a country's own variety) or de,fr. One new creative each: <slug>-<tag in lowercase>"
+  },
+  "copy-file": {
+    type: "string",
+    required: false,
+    description: `A JSON file with your own lines. A language as an array is every line, in the ad's order, no model asked: {"es": ["line 1", "line 2"]}. A language as an object is only the lines you write, by number (from 1) or role, and the model writes the rest: {"de": {"headline": "\u2026", "3": "\u2026"}}. Your words for a line also win over the reading that it is a customer's, unless it is signed as theirs`
+  },
+  note: {
+    type: "string",
+    required: false,
+    description: "Your instructions for the translator, as you would brief a copywriter: the tone, t\xFA or usted, a term to keep in English, what the market calls the product. A customer's words stay as they said them whatever it says"
+  },
+  again: {
+    type: "boolean",
+    required: false,
+    default: false,
+    description: "Translate a language already made again (after the ad's words changed); without it, a made language is left as it is"
+  }
+};
+registerSchema({ command: "creatives.translate", description: DESCRIPTION, args: ARGS });
+function fail(error) {
+  writeJson({ ok: false, error });
+  process.exit(1);
+}
+async function readCopyFile(file) {
+  try {
+    return JSON.parse(await readFile2(path2.resolve(file), "utf8"));
+  } catch (e) {
+    fail({
+      code: "translate_copy_file_unreadable",
+      message: `The copy file ${file} could not be read as JSON (${e instanceof Error ? e.message : String(e)}).`,
+      fix: 'Write it as {"<lang>": ["line 1", "line 2"]}, one array per language.'
+    });
+  }
+}
+var translateCommand = defineCommand({
+  meta: { name: "translate", description: DESCRIPTION },
+  args: ARGS,
+  async run({ args }) {
+    const root = findWorkspaceRoot(process.cwd()) ?? process.cwd();
+    const copyFile = typeof args["copy-file"] === "string" && args["copy-file"] ? args["copy-file"] : void 0;
+    const copy = copyFile ? await readCopyFile(copyFile) : void 0;
+    const spent = [];
+    const result = await translateAd(root, String(args.slug), String(args.to), {
+      ask: (prompt) => askAboutImages(RENDER_REVIEW_MODEL, [], prompt, (usage) => spent.push(usage), TRANSLATE_TIMEOUT_MS).catch(
+        () => null
+      ),
+      ...copy !== void 0 ? { copy } : {},
+      again: args.again === true,
+      ...typeof args.note === "string" && args.note.trim() ? { note: args.note.trim() } : {},
+      sync: (dir) => runBaker(["canvas", "sync-definition", dir, "--title"]),
+      judgeQuotes: (texts) => askJev(texts.map(quoteLineQuestion), (usage) => spent.push(usage))
+    });
+    await holdUnbilledSpend(path2.join(root, "canvas", ".cache"), spent).catch(() => void 0);
+    if ("code" in result) fail(result);
+    writeJson(translateEnvelope(result));
+  }
+});
+export {
+  translateCommand
+};
+//# sourceMappingURL=translate-2IHE5YDI.js.map