@koda-sl/baker-cli 0.477.0-dev.55c09e3e8 → 0.478.0

package/dist/chunk-V3NGFNHO.js

@@ -0,0 +1,509 @@
+import {
+  finalOutputLabelsFromCanvas,
+  parseDefinitionStrategyFields
+} from "./chunk-YDOZX6E5.js";
+import {
+  readRenderState
+} from "./chunk-L4LLNGJG.js";
+import {
+  STATIC_AD_ROLE,
+  formatOfAdaptId,
+  isCustomersWords,
+  isSignatureLine,
+  sameTag,
+  seriesMemberAd
+} from "./chunk-3YSLIBIM.js";
+import {
+  fetchRunRecord
+} from "./chunk-DWVNYWWQ.js";
+import {
+  localPathParam
+} from "./chunk-ANWV2VTO.js";
+import {
+  NodeDecl,
+  STATIC_ADAPT_FORMAT_ROLE,
+  STATIC_FIX_ROLE,
+  STATIC_MASTER_ROLE,
+  STATIC_PICK_ROLE,
+  STATIC_SAFE_FIT_ROLE,
+  STATIC_SIZE_ROLE,
+  STATIC_VARIANTS_ROLE,
+  nodesWithRole,
+  relaidPictureRole,
+  rolesById
+} from "./chunk-GRL25RKS.js";
+import {
+  isAdSpec,
+  readAdSpec
+} from "./chunk-5TV4GYP2.js";
+import {
+  sha256Hex,
+  toModelSafeImage
+} from "./chunk-NKXH3I65.js";
+
+// src/commands/baker-child.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var run = promisify(execFile);
+function lastJsonObject(stdout) {
+  for (let at = stdout.lastIndexOf("{"); at >= 0; at = stdout.lastIndexOf("{", at - 1)) {
+    if (at > 0 && stdout[at - 1] !== "\n") continue;
+    try {
+      const parsed = JSON.parse(stdout.slice(at));
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+    } catch {
+    }
+    if (at === 0) break;
+  }
+  return null;
+}
+async function runBaker(args, signal) {
+  const entry = process.argv[1];
+  const [file, argv] = entry ? [process.execPath, [...process.execArgv, entry, ...args]] : ["baker", args];
+  try {
+    const { stdout } = await run(file, argv, { maxBuffer: 32 * 1024 * 1024, ...signal ? { signal } : {} });
+    return lastJsonObject(stdout) ?? { ok: false, error: { code: "INTERNAL_ERROR", message: "no answer" } };
+  } catch (err) {
+    const { stdout = "", stderr = "" } = err;
+    return lastJsonObject(stdout) ?? lastJsonObject(stderr) ?? {
+      ok: false,
+      error: { code: "INTERNAL_ERROR", message: err instanceof Error ? err.message.slice(0, 300) : String(err) }
+    };
+  }
+}
+
+// src/commands/canvas/static-ad-canvas.ts
+function isStaticAdCanvas(parsed) {
+  const nodes = parsed?.nodes;
+  if (!Array.isArray(nodes)) return false;
+  return nodes.some((n) => {
+    const role = n?.tags?.role;
+    if (role === STATIC_VARIANTS_ROLE) return true;
+    return n?.type === "ingest" && (role === STATIC_AD_ROLE || n?.id === "compose_spec");
+  });
+}
+
+// src/commands/canvas/static-fix.ts
+import { readFile } from "fs/promises";
+import path from "path";
+import { z } from "zod";
+async function previousAdImage(canvasRoot, runId, fetchRecord = fetchRunRecord, roles = {}) {
+  try {
+    const manifest = JSON.parse(await readFile(path.join(canvasRoot, runId, "manifest.json"), "utf8"));
+    const byNode = Object.fromEntries(
+      Object.entries(manifest.outputs_by_node ?? {}).map(([id, out]) => [id, { ...out, ...roles[id] ? { role: roles[id] } : {} }])
+    );
+    const local = chosenUrl(byNode);
+    if (local) return local;
+  } catch {
+  }
+  const record = await fetchRecord(runId).catch(() => null);
+  if (!record) return null;
+  return chosenUrl(
+    Object.fromEntries(
+      record.nodes.map((n) => {
+        const role = n.role ?? roles[n.nodeId];
+        return [n.nodeId, { images: n.outputs, ...role ? { role } : {} }];
+      })
+    )
+  );
+}
+async function previousDelivered(canvasRoot, runId, finalNode, labels, opts = {}) {
+  try {
+    const manifest = JSON.parse(await readFile(path.join(canvasRoot, runId, "manifest.json"), "utf8"));
+    const images = manifest.outputs_by_node?.[finalNode]?.images ?? [];
+    return images.flatMap((image, i) => {
+      const local = typeof image.path === "string" ? image.path : null;
+      const durable = typeof image.url === "string" ? image.url : null;
+      const source = opts.prefer === "url" ? durable ?? local : local ?? durable;
+      const format = labels[i];
+      return source && format ? [{ format, path: source }] : [];
+    });
+  } catch {
+    return [];
+  }
+}
+var CHOSEN = [
+  (_, out) => out.role === STATIC_MASTER_ROLE,
+  (_, out) => out.role === STATIC_PICK_ROLE,
+  (_, out) => out.role === STATIC_FIX_ROLE,
+  (id, out) => id === "pick" && out.role === void 0,
+  (id, out) => id === "ad" && out.role === void 0
+];
+function urlOf(out) {
+  const url = out.images?.find((o) => typeof o?.url === "string")?.url ?? out.image?.url ?? out.asset?.url;
+  return typeof url === "string" ? url : null;
+}
+function chosenUrl(byNode) {
+  const entries = Object.entries(byNode).filter(([, out]) => out.role !== STATIC_VARIANTS_ROLE);
+  for (const matches of CHOSEN) {
+    for (const [id, out] of entries) {
+      if (!matches(id, out)) continue;
+      const url = urlOf(out);
+      if (url) return url;
+    }
+  }
+  return null;
+}
+function correctedUrl(byNode) {
+  const editNumber = (id) => Number(id.match(/^edit_(\d+)$/)?.[1] ?? 0);
+  const entries = Object.entries(byNode).sort(([a], [b]) => editNumber(b) - editNumber(a));
+  for (const [id, out] of entries) {
+    if (id === "fix" || id === "chosen" || out.role === STATIC_FIX_ROLE) {
+      const url = urlOf(out);
+      if (url) return url;
+    }
+  }
+  return null;
+}
+async function fetchGraph(url) {
+  const res = await fetch(url);
+  return res.ok ? res.json() : null;
+}
+var HISTORY = { record: fetchRunRecord, graph: fetchGraph };
+var VersionGraph = z.object({ nodes: z.array(NodeDecl) });
+var VersionManifest = z.object({
+  canvas: VersionGraph,
+  outputs_by_node: z.record(z.string(), z.record(z.string(), z.unknown()))
+});
+async function versionRun(canvasRoot, runId, sources = HISTORY) {
+  try {
+    const manifest = VersionManifest.safeParse(JSON.parse(await readFile(path.join(canvasRoot, runId, "manifest.json"), "utf8")));
+    if (manifest.success) return { canvas: manifest.data.canvas, outputs: manifest.data.outputs_by_node };
+  } catch {
+  }
+  const record = await sources.record(runId).catch(() => null);
+  const graph = record?.graphUrl ? await sources.graph(record.graphUrl).catch(() => null) : null;
+  const canvas = VersionGraph.safeParse(graph);
+  return record && canvas.success ? { canvas: canvas.data, outputs: outputsByNode(record.nodes) } : null;
+}
+async function ingestedNow(files, canvasDir) {
+  const entries = await Promise.all(
+    files.map(async (file) => {
+      const bytes = await readFile(path.resolve(canvasDir, file.path)).catch(() => null);
+      if (!bytes) return [file.id, []];
+      const own = sha256Hex(bytes);
+      if (file.expect !== "image") return [file.id, [own]];
+      const raster = await toModelSafeImage(bytes).catch(() => null);
+      return [file.id, raster ? [.../* @__PURE__ */ new Set([own, sha256Hex(raster.bytes)])] : [own]];
+    })
+  );
+  return Object.fromEntries(entries);
+}
+function outputsByNode(nodes) {
+  const byNode = {};
+  for (const node of nodes) {
+    const outputs = {};
+    for (const out of node.outputs) {
+      const [slot = "", index] = String(out.slot ?? "").split("#");
+      const { slot: _slot, label: _label, durationMs, ...ref } = out;
+      const asset = { ...ref, ...typeof durationMs === "number" ? { duration_ms: durationMs } : {} };
+      if (index === void 0) outputs[slot] = asset;
+      else {
+        const list = Array.isArray(outputs[slot]) ? outputs[slot] : [];
+        list[Number(index)] = asset;
+        outputs[slot] = list;
+      }
+    }
+    if (Object.keys(outputs).length > 0) byNode[node.nodeId] = outputs;
+  }
+  return byNode;
+}
+async function correctedPicture(canvasRoot, runId, fetchRecord = fetchRunRecord) {
+  try {
+    const manifest = JSON.parse(await readFile(path.join(canvasRoot, runId, "manifest.json"), "utf8"));
+    if (manifest.outputs_by_node) return correctedUrl(manifest.outputs_by_node);
+  } catch {
+  }
+  const record = await fetchRecord(runId).catch(() => null);
+  if (!record) return null;
+  return correctedUrl(
+    Object.fromEntries(record.nodes.map((n) => [n.nodeId, { images: n.outputs, ...n.role ? { role: n.role } : {} }]))
+  );
+}
+function pictureRecord(runId, opts) {
+  const chosen = opts.chose === true || opts.keeps === true && keepsChosen(opts.of, opts.from);
+  return { runId, ...chosen ? { chosen: true } : {}, ...opts.redrawn ? { redrawn: true } : {} };
+}
+function keepsChosen(picture, from) {
+  return picture?.chosen === true && from !== void 0 && picture.runId === from;
+}
+function relaysSizesOnly(canvas, ids) {
+  const roles = rolesById(canvas);
+  const sizing = /* @__PURE__ */ new Set([STATIC_ADAPT_FORMAT_ROLE, STATIC_SIZE_ROLE, STATIC_SAFE_FIT_ROLE]);
+  return ids.length > 0 && ids.every((id) => sizing.has(roles[id] ?? ""));
+}
+var SHA_PREFIX = /^[0-9a-f]{8,64}$/;
+function matchVariant(outputs, sha) {
+  const hits = outputs.filter((o) => typeof o?.sha256 === "string" && o.sha256.startsWith(sha) && typeof o.url === "string");
+  const urls = [...new Set(hits.map((o) => o.url))];
+  return urls.length === 1 ? urls[0] : null;
+}
+async function variantImage(canvasRoot, runId, sha256, fetchRecord = fetchRunRecord, roles = {}) {
+  const sha = sha256.trim().toLowerCase();
+  if (!SHA_PREFIX.test(sha)) return null;
+  try {
+    const manifest = JSON.parse(await readFile(path.join(canvasRoot, runId, "manifest.json"), "utf8"));
+    for (const [id, out] of Object.entries(manifest.outputs_by_node ?? {})) {
+      if (roles[id] !== STATIC_VARIANTS_ROLE) continue;
+      const url = matchVariant(out.images ?? [], sha);
+      if (url) return url;
+    }
+  } catch {
+  }
+  const record = await fetchRecord(runId).catch(() => null);
+  const variants = record?.nodes.find((n) => n.role === STATIC_VARIANTS_ROLE);
+  return variants ? matchVariant(variants.outputs, sha) : null;
+}
+
+// src/commands/canvas/series-member.ts
+import { existsSync } from "fs";
+import { readdir, readFile as readFile2, writeFile } from "fs/promises";
+import path2 from "path";
+var creativeDir = (root, slug) => path2.join(root, "src", "creatives", slug);
+var canvasFile = (root, slug) => path2.join(creativeDir(root, slug), `${slug}.canvas.json`);
+async function seriesFieldsOf(root, slug) {
+  const raw = await readFile2(path2.join(creativeDir(root, slug), "_definition.md"), "utf8").catch(() => null);
+  return raw === null ? {} : parseDefinitionStrategyFields(raw);
+}
+async function seriesLeadOf(root, slug) {
+  return (await seriesFieldsOf(root, slug)).seriesLead ?? null;
+}
+async function translatedInto(root, slug, lead) {
+  const own = (await seriesFieldsOf(root, slug)).language;
+  const leads = (await seriesFieldsOf(root, lead)).language;
+  return own && !(leads && sameTag(own, leads)) ? own : void 0;
+}
+var SERIES_DEPTH = 3;
+async function seriesLeadsAbove(root, slug) {
+  const leads = [];
+  let at = await seriesLeadOf(root, slug);
+  while (at && at !== slug && !leads.includes(at) && leads.length < SERIES_DEPTH) {
+    leads.push(at);
+    at = await seriesLeadOf(root, at);
+  }
+  return leads;
+}
+async function seriesMembers(root, lead) {
+  const slugs = await readdir(path2.join(root, "src", "creatives")).catch(() => []);
+  const members = [];
+  for (const slug of slugs.sort()) {
+    if (slug !== lead && await seriesLeadOf(root, slug) === lead) members.push(slug);
+  }
+  return members;
+}
+function refusal(code, message, fix) {
+  return { refused: { code, message, fix } };
+}
+async function leadVersion(root, lead, fetchRecord = fetchRunRecord) {
+  const file = canvasFile(root, lead);
+  const canvas = existsSync(file) ? JSON.parse(await readFile2(file, "utf8")) : null;
+  if (!canvas || !isStaticAdCanvas(canvas)) {
+    return refusal(
+      "series_lead_not_found",
+      `The lead ad "${lead}" is not a static ad in this workspace.`,
+      "Name a static ad of this workspace as the lead: make it with `baker creatives make <idea>` and render it first."
+    );
+  }
+  const canvasRoot = path2.join(root, "canvas");
+  const state = await readRenderState(canvasRoot, lead);
+  const runId = state.rendered?.runId;
+  if (!runId) {
+    return refusal(
+      "series_lead_not_rendered",
+      `The lead ad "${lead}" has no finished version yet: every ad of its series is made from it.`,
+      `Render the lead first and get it ready: baker canvas run --slug ${lead}. Then make the series.`
+    );
+  }
+  if ((state.blocking ?? []).length > 0) {
+    return refusal(
+      "series_lead_not_ready",
+      `The lead ad "${lead}" still needs fixes (${(state.blocking ?? []).join(" | ")}): the series would copy them.`,
+      `Correct the lead until its verdict is ready (baker canvas run --slug ${lead}, or --fix "<what to change>"), then run the series again.`
+    );
+  }
+  const record = () => fetchRecord(runId).catch(() => null);
+  const picture = await previousAdImage(canvasRoot, runId, record, { ...rolesById(canvas), ...relaidPictureRole(canvas) });
+  const sizes = await deliveredSizes(canvasRoot, runId, canvas, record);
+  if (!picture) {
+    return refusal(
+      "series_lead_not_rendered",
+      `The finished picture of the lead's version (${runId}) is not available.`,
+      `Render the lead again (baker canvas run --slug ${lead}), then run the series.`
+    );
+  }
+  const drawn = state.prompt ?? JSON.parse(await readFile2(path2.join(creativeDir(root, lead), "prompt.json"), "utf8"));
+  const copy = readAdSpec(drawn).copy.map((l) => ({ text: l.text, ...l.role ? { role: l.role } : {} }));
+  return { lead: { slug: lead, runId, copy, picture, sizes }, canvas, spec: drawn };
+}
+async function deliveredSizes(canvasRoot, runId, canvas, record) {
+  const wanted = new Set(nodesWithRole(canvas, STATIC_ADAPT_FORMAT_ROLE).flatMap((n) => formatOfAdaptId(n.id) ?? []));
+  const labels = finalOutputLabelsFromCanvas(canvas);
+  const local = await previousDelivered(canvasRoot, runId, labels?.nodeId ?? "final", labels?.labels ?? [], {
+    prefer: "url"
+  });
+  const found = local.length > 0 ? local : ((await record())?.finalOutputs ?? []).flatMap(
+    (o) => o.label && o.url ? [{ format: o.label, path: o.url }] : []
+  );
+  return Object.fromEntries(found.filter((d) => wanted.has(d.format)).map((d) => [d.format, d.path]));
+}
+function rebaseLeadPaths(canvas, leadDir, memberDir) {
+  const out = structuredClone(canvas);
+  for (const node of out.nodes ?? []) {
+    const key = localPathParam(node);
+    const value = key ? node.params?.[key] : void 0;
+    if (!key || !node.params || typeof value !== "string" || node.id === "prompt" || path2.isAbsolute(value)) continue;
+    const rel = path2.relative(memberDir, path2.resolve(leadDir, value)).split(path2.sep).join("/");
+    node.params[key] = rel.startsWith(".") ? rel : `./${rel}`;
+  }
+  return out;
+}
+var DESIGN_FIELDS = [
+  "scene",
+  "brand",
+  "colors",
+  "references",
+  "logo",
+  "logo_position",
+  "third_party_brands",
+  "formats",
+  "direction"
+];
+function seriesDesignOf(spec) {
+  try {
+    const read = readAdSpec(spec);
+    return JSON.stringify(DESIGN_FIELDS.map((key) => read[key] ?? null));
+  } catch {
+    return null;
+  }
+}
+function withLeadDesign(memberSpec, leadSpec) {
+  const asSpec = (spec) => isAdSpec(spec) ? spec : readAdSpec(spec);
+  const lead = asSpec(leadSpec);
+  const out = { ...asSpec(memberSpec) };
+  for (const key of DESIGN_FIELDS) {
+    if (key in lead) out[key] = lead[key];
+    else delete out[key];
+  }
+  return out;
+}
+function unchangedCopyRefusal(lead, memberSpec) {
+  const words = (copy2) => copy2.map((l) => l.text.trim()).join("\n");
+  let copy;
+  try {
+    copy = readAdSpec(memberSpec).copy;
+  } catch {
+    return null;
+  }
+  if (words(copy) !== words(lead.copy)) return null;
+  return refusal(
+    "series_copy_unchanged",
+    `This ad's words are still the lead's ("${lead.copy[0]?.text ?? ""}"): it would render the lead again.`,
+    "Write this ad's own words in its prompt.json `copy`, one line for each of the lead's (same roles), saying this ad's message. Keep everything else: the design is the lead's."
+  );
+}
+function changedCustomerWordsRefusal(lead, memberSpec) {
+  let copy;
+  try {
+    copy = readAdSpec(memberSpec).copy;
+  } catch {
+    return null;
+  }
+  const said = new Set(copy.map((l) => l.text.trim()));
+  const changed = lead.copy.filter((line, i) => {
+    const below = lead.copy[i + 1];
+    const theirs = isCustomersWords(line) || below !== void 0 && isSignatureLine(below);
+    return theirs && !said.has(line.text.trim());
+  });
+  if (changed.length === 0) return null;
+  return refusal(
+    "series_customer_words_changed",
+    `This translation changed a customer's own words: ${changed.map((l) => `"${l.text}"`).join(", ")} is how they said it, and translated it would be words they never said under their name.`,
+    `Put ${changed.length === 1 ? "that line" : "those lines"} back in this ad's prompt.json exactly as the lead has ${changed.length === 1 ? "it" : "them"}: ${changed.map((l) => `"${l.text}"`).join(", ")}. Translate only the advertiser's own lines.`
+  );
+}
+function designChangedRefusal(lead, leads) {
+  const chain = leads.length > 0 ? leads : [lead];
+  const design = chain[chain.length - 1] ?? lead;
+  const runs = [...chain].reverse().map((l) => `baker canvas run --series ${l}`);
+  return refusal(
+    "series_design_changed",
+    `This ad's design (its scene, colours, pictures or logo in prompt.json) was changed on the ad itself, but every ad of the series has the design of "${design}".`,
+    `Make the change once, on ${design}: edit src/creatives/${design}/prompt.json (or baker canvas run --slug ${design} --fix "<the change>"), then ${runs.join(", then ")}: every ad takes the new design, its own words kept. Only this ad's copy belongs in its own prompt.json.`
+  );
+}
+async function writeSeriesMemberCanvas(root, slug, opts = {}) {
+  const lead = await seriesLeadOf(root, slug);
+  if (!lead) return null;
+  const version = await leadVersion(root, lead, opts.fetchRecord);
+  if ("refused" in version) return version;
+  const dir = creativeDir(root, slug);
+  const promptPath = path2.join(dir, "prompt.json");
+  let memberSpec = JSON.parse(await readFile2(promptPath, "utf8").catch(() => "null"));
+  const unchanged = opts.leadWords ? null : unchangedCopyRefusal(version.lead, memberSpec);
+  if (unchanged) return unchanged;
+  const language = await translatedInto(root, slug, lead);
+  const rewritten = language ? changedCustomerWordsRefusal(version.lead, memberSpec) : null;
+  if (rewritten) return rewritten;
+  const file = canvasFile(root, slug);
+  const before = await readFile2(file, "utf8").catch(() => null);
+  const leadDesign = seriesDesignOf(version.spec);
+  const ownDesign = seriesDesignOf(memberSpec);
+  const previous = before ? JSON.parse(before).metadata?.series : void 0;
+  const synced = previous?.design;
+  let designFromLead = false;
+  if (leadDesign !== null && ownDesign !== null && ownDesign !== leadDesign) {
+    if (!opts.takeLeadDesign && ownDesign !== synced) {
+      return designChangedRefusal(lead, await seriesLeadsAbove(root, slug));
+    }
+    memberSpec = withLeadDesign(memberSpec, version.spec);
+    await writeFile(promptPath, `${JSON.stringify(memberSpec, null, 2)}
+`, "utf8");
+    designFromLead = true;
+  }
+  const canvas = seriesMemberAd(
+    rebaseLeadPaths(version.canvas, creativeDir(root, lead), dir),
+    { ...version.lead, ...leadDesign !== null ? { design: leadDesign } : {} },
+    language ? { language } : {}
+  );
+  const text = `${JSON.stringify(canvas, null, 2)}
+`;
+  if (before !== text) await writeFile(file, text, "utf8");
+  const madeFrom = (await readRenderState(path2.join(root, "canvas"), slug)).seriesLeadRun;
+  const newLeadVersion = madeFrom !== void 0 && madeFrom !== version.lead.runId;
+  return { lead, leadRunId: version.lead.runId, canvasPath: file, written: before !== text, designFromLead, newLeadVersion };
+}
+function seriesRunHints(slug, series) {
+  const leads = series.leads?.length ? series.leads : series.lead ? [series.lead] : [];
+  const root = leads[leads.length - 1];
+  if (root) {
+    const runs = [...leads].reverse().map((lead) => `baker canvas run --series ${lead}`);
+    return [
+      `This ad is one of the series led by ${leads[0]}: its picture is ${root}'s with its own words. A change to what every ad shares (the picture, colours, layout, logo) is made once, on ${root} (src/creatives/${root}/prompt.json, or baker canvas run --slug ${root} --fix "<the change>"), then ${runs.join(", then ")}. Correct only this ad's own words or its own defect here.`
+    ];
+  }
+  if (series.members.length === 0) return [];
+  return [
+    `This ad leads a series of ${series.members.length + 1}: baker canvas run --series ${slug} makes ${series.members.join(", ")} again from this version, each with its own words. Until then they show the lead's earlier version; an ad of the series run by itself (baker canvas run --slug ${series.members[0]}) is made from this version too, its design included.`
+  ];
+}
+
+export {
+  runBaker,
+  isStaticAdCanvas,
+  previousAdImage,
+  previousDelivered,
+  versionRun,
+  ingestedNow,
+  correctedPicture,
+  pictureRecord,
+  keepsChosen,
+  relaysSizesOnly,
+  variantImage,
+  seriesLeadsAbove,
+  seriesMembers,
+  leadVersion,
+  writeSeriesMemberCanvas,
+  seriesRunHints
+};
+//# sourceMappingURL=chunk-V3NGFNHO.js.map

package/dist/chunk-VDAYKWVH.js

@@ -0,0 +1,125 @@
+import {
+  apiGet
+} from "./chunk-7ANWFQEA.js";
+
+// src/commands/studio/batch.ts
+function projectBatch(generation, full) {
+  const compact = {
+    generationId: generation.generationId,
+    kind: generation.kind,
+    status: generation.status,
+    prompt: generation.prompt,
+    model: generation.model,
+    aspectRatio: generation.aspectRatio,
+    variants: generation.variants.map((variant) => ({
+      slot: variant.slot,
+      status: variant.status,
+      ...variant.imageId ? { imageId: variant.imageId } : {},
+      ...variant.videoId ? { videoId: variant.videoId } : {},
+      ...variant.url ? { url: variant.url } : {},
+      inLibrary: variant.inLibrary,
+      ...variant.error ? { error: variant.error } : {}
+    }))
+  };
+  if (!full) return compact;
+  return {
+    ...compact,
+    ...generation.skillId ? { skillId: generation.skillId } : {},
+    ...generation.imageSettings ? { imageSettings: generation.imageSettings } : {},
+    ...generation.clipSettings ? { clipSettings: generation.clipSettings } : {},
+    ...generation.referenceImageIds ? { referenceImageIds: generation.referenceImageIds } : {},
+    ...generation.chatId ? { chatId: generation.chatId } : {},
+    createdAt: generation.createdAt
+  };
+}
+function slotArg(candidates) {
+  return candidates.length === 1 ? `--slot ${candidates[0]?.slot}` : "--slot <n>";
+}
+function chooseFirst(candidates) {
+  return candidates.length === 1 ? "" : " Look at the takes and pick one \u2014 do not default to the first.";
+}
+function batchHints(generation) {
+  const id = generation.generationId;
+  if (generation.status === "running") {
+    return [
+      `Still rendering. Run \`baker studio get ${id}\` when you need the result \u2014 do not start the same batch again.`
+    ];
+  }
+  const hints = [];
+  const ready = generation.variants.filter((variant) => variant.status === "ready");
+  const failed = generation.variants.filter((variant) => variant.status === "failed");
+  if (generation.kind === "image" && ready.length > 0) {
+    hints.push(
+      'Every rendered image is already in the media library and searchable \u2014 `baker images library "<what it shows>"` finds it, and you can use its image id straight away.'
+    );
+    hints.push(
+      `Mark the take you are using: \`baker studio keep ${id} ${slotArg(ready)}\` stars it so the client reviews the right one.${chooseFirst(ready)}`
+    );
+  }
+  const unkeptClips = ready.filter((variant) => !variant.inLibrary);
+  if (generation.kind === "video" && unkeptClips.length > 0) {
+    hints.push(
+      `A clip is not usable anywhere \u2014 canvas, landing, ad \u2014 until you keep it. \`baker studio keep ${id} ${slotArg(unkeptClips)}\` puts it in the video library; takes nobody keeps are never ingested.${chooseFirst(unkeptClips)}`
+    );
+  }
+  if (generation.status === "partial" && failed.length > 0) {
+    hints.push(
+      `${failed.length === 1 ? "This take" : "These takes"} did not render \u2014 ${failed.map((variant) => `take ${variant.slot}: ${variant.error ?? "no reason given"}`).join("; ")}. Use the ones that did and carry on; do not re-run the whole batch.`
+    );
+  }
+  if (generation.status === "failed") {
+    hints.push(
+      `No take rendered \u2014 ${failed[0]?.error ?? "no reason given"}. Continue the job with a sourced or existing asset rather than stopping.`
+    );
+  }
+  return hints;
+}
+function waitingHint(outcome, generationId, maxWaitMs) {
+  const collect = `Run \`baker studio get ${generationId}\` to pick it up \u2014 the batch is still going, so do not start it again.`;
+  if (outcome.kind === "unreachable") {
+    return `The batch started and is rendering, but reading it back failed (${outcome.reason}). ${collect}`;
+  }
+  return `Still rendering after ${Math.round(maxWaitMs / 1e3)}s. ${collect}`;
+}
+var FALSEY_FLAG_VALUES = /* @__PURE__ */ new Set(["false", "0", "no", "off"]);
+function resolveMaxWaitMs(wait, maxWait, defaultMs) {
+  if (typeof wait === "string" && FALSEY_FLAG_VALUES.has(wait.trim().toLowerCase())) return 0;
+  if (wait === false) return 0;
+  if (maxWait === void 0 || maxWait === "") return defaultMs;
+  const parsed = Number(maxWait);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : defaultMs;
+}
+var POLL_INTERVAL_MS = 3e3;
+var defaultPollDeps = {
+  get: async (generationId) => {
+    const response = await apiGet(`/api/studio/generations/${generationId}`);
+    return response.generation;
+  },
+  sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+};
+async function pollBatch(generationId, maxWaitMs, deps = defaultPollDeps) {
+  const deadline = Date.now() + maxWaitMs;
+  while (Date.now() < deadline) {
+    const generation = await deps.get(generationId);
+    if (generation.status !== "running") return generation;
+    await deps.sleep(POLL_INTERVAL_MS);
+  }
+  return null;
+}
+async function awaitBatch(generationId, maxWaitMs, deps = defaultPollDeps) {
+  try {
+    const generation = await pollBatch(generationId, maxWaitMs, deps);
+    return generation ? { kind: "settled", generation } : { kind: "still-running" };
+  } catch (error) {
+    return { kind: "unreachable", reason: error instanceof Error ? error.message : "the read failed" };
+  }
+}
+
+export {
+  projectBatch,
+  batchHints,
+  waitingHint,
+  resolveMaxWaitMs,
+  awaitBatch
+};
+//# sourceMappingURL=chunk-VDAYKWVH.js.map

package/dist/chunk-VX45CG4L.js

@@ -0,0 +1,61 @@
+import {
+  COST_TYPES,
+  OBJECTIVE_TYPES,
+  calendarDaySchema,
+  targetingCriteriaSchema
+} from "./chunk-A5VAM472.js";
+
+// ../api/src/ads-linkedin/planning.ts
+import { z } from "zod";
+var moneySchema = z.object({
+  amount: z.string().regex(/^\d+(\.\d+)?$/, "use a plain amount such as 250 or 5.57"),
+  currencyCode: z.string().regex(/^[A-Z]{3}$/).optional()
+});
+var accountIdSchema = z.string().min(1);
+var linkedinBidPricingRequestSchema = z.object({
+  accountId: accountIdSchema,
+  objectiveType: z.enum(OBJECTIVE_TYPES),
+  costType: z.enum(COST_TYPES).default("CPC"),
+  campaignType: z.enum(["SPONSORED_UPDATES", "TEXT_AD", "SPONSORED_INMAILS"]).default("SPONSORED_UPDATES"),
+  /** EXACT = audience expansion off, the playbook default. */
+  matchType: z.enum(["EXACT", "AUDIENCE_EXPANDED"]).default("EXACT"),
+  targetingCriteria: targetingCriteriaSchema,
+  skipCache: z.boolean().optional()
+});
+var LINKEDIN_FORECAST_DEFAULT_DAYS = 30;
+var linkedinForecastRequestSchema = z.object({
+  accountId: accountIdSchema,
+  objectiveType: z.enum(OBJECTIVE_TYPES).optional(),
+  costType: z.enum(COST_TYPES).default("CPC"),
+  campaignType: z.enum(["SPONSORED_UPDATES", "SPONSORED_INMAILS", "DYNAMIC"]).default("SPONSORED_UPDATES"),
+  /** First forecast day (UTC); defaults to tomorrow — LinkedIn forecasts only the future. */
+  startDate: calendarDaySchema.optional(),
+  days: z.number().int().min(1).max(365).default(LINKEDIN_FORECAST_DEFAULT_DAYS),
+  dailyBudget: moneySchema.optional(),
+  totalBudget: moneySchema.optional(),
+  /** A manual bid; without one LinkedIn forecasts its automated bidding. */
+  bid: moneySchema.optional(),
+  optimizationTarget: z.string().regex(/^[A-Z_]+$/).optional(),
+  targetingCriteria: targetingCriteriaSchema,
+  /** Add LinkedIn's raw series (daily, 7-day, 30-day) to the summary. */
+  full: z.boolean().default(false),
+  skipCache: z.boolean().optional()
+}).superRefine((req, ctx) => {
+  if (!req.dailyBudget && !req.totalBudget) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["totalBudget"],
+      message: "a budget is required (daily or total) \u2014 LinkedIn forecasts what a budget buys"
+    });
+  }
+  if (req.dailyBudget && req.totalBudget) {
+    ctx.addIssue({ code: "custom", path: ["totalBudget"], message: "pass a daily or a total budget, not both" });
+  }
+});
+
+export {
+  linkedinBidPricingRequestSchema,
+  LINKEDIN_FORECAST_DEFAULT_DAYS,
+  linkedinForecastRequestSchema
+};
+//# sourceMappingURL=chunk-VX45CG4L.js.map