@koda-sl/baker-cli 0.514.0 → 0.515.0-dev.957976bb7

package/dist/chunk-XUXRA7IB.js

@@ -0,0 +1,942 @@
+import {
+  finalOutputLabelsFromCanvas
+} from "./chunk-4IHWT7PH.js";
+import {
+  fetchRunRecord
+} from "./chunk-3QHXF3QI.js";
+import {
+  readRenderState
+} from "./chunk-AN4OEQXE.js";
+import {
+  STATIC_AD_ROLE,
+  fixBriefNode,
+  formatOfAdaptId,
+  isCustomersWords,
+  isSignatureLine,
+  parseDefinitionStrategyFields,
+  plateFixPrompt,
+  sameTag,
+  seriesMemberAd
+} from "./chunk-GNMEOU46.js";
+import {
+  localPathParam
+} from "./chunk-EJGAJHLB.js";
+import {
+  LOGO_COMPOSITE_ROLE,
+  NodeDecl,
+  SERIES_LEAD_ROLE,
+  STATIC_ADAPT_FORMAT_ROLE,
+  STATIC_FIX_ROLE,
+  STATIC_FORMAT_ROLE,
+  STATIC_LEAD_ROLE,
+  STATIC_MASTER_ROLE,
+  STATIC_PICK_ROLE,
+  STATIC_PLATE_ROLE,
+  STATIC_SAFE_FIT_ROLE,
+  STATIC_SIZE_ROLE,
+  STATIC_VARIANTS_ROLE,
+  STATIC_VARIANT_CALL_ROLE,
+  VARIANT_PREFILTER_ROLE,
+  isPlateCanvas,
+  nodesWithRole,
+  relaidPictureRole,
+  rolesById,
+  staticMasterFormat
+} from "./chunk-AULSX5ZA.js";
+import {
+  isAdSpec,
+  readAdSpec
+} from "./chunk-QHZE62GP.js";
+import {
+  canonicalize
+} from "./chunk-F3CZFUXZ.js";
+import {
+  sha256Hex,
+  toModelSafeImage
+} from "./chunk-FOMFU2RX.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/engine/scaffold/static-history.ts
+var PICTURE_ROLES = /* @__PURE__ */ new Set([
+  STATIC_VARIANT_CALL_ROLE,
+  STATIC_VARIANTS_ROLE,
+  VARIANT_PREFILTER_ROLE,
+  STATIC_PICK_ROLE,
+  STATIC_FIX_ROLE,
+  SERIES_LEAD_ROLE,
+  STATIC_LEAD_ROLE,
+  STATIC_PLATE_ROLE
+]);
+var EDIT_ID = /^edit_(\d+)$/;
+function refNode(ref) {
+  return typeof ref === "string" ? ref.match(/^\$ref:([a-z][a-z0-9_]*)\./)?.[1] ?? null : null;
+}
+function depsOf(node) {
+  const found = [];
+  const walk = (v) => {
+    if (typeof v === "string") {
+      const id = refNode(v);
+      if (id) found.push(id);
+    } else if (Array.isArray(v)) v.forEach(walk);
+    else if (v && typeof v === "object") Object.values(v).forEach(walk);
+  };
+  walk(node.inputs);
+  walk(node.params);
+  return found;
+}
+function ancestors(nodes, id) {
+  const byId = new Map(nodes.map((n) => [n.id, n]));
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (at) => {
+    const n = byId.get(at);
+    if (!n || seen.has(at)) return;
+    seen.add(at);
+    for (const dep of depsOf(n)) visit(dep);
+  };
+  visit(id);
+  return nodes.filter((n) => seen.has(n.id));
+}
+var isPicture = (n) => PICTURE_ROLES.has(n.tags?.role ?? "");
+function framingPrefilter(nodes, master) {
+  const reads = JSON.stringify(master.inputs ?? {});
+  return nodes.find((n) => n.tags?.role === VARIANT_PREFILTER_ROLE && reads.includes(`$ref:${n.id}.`));
+}
+function frameNode(prefilter, id, image) {
+  if (!prefilter) return null;
+  const { judge_model: _judge, judge_prompt: _prompt, ...params } = prefilter.params ?? {};
+  return { ...prefilter, id, inputs: { ...prefilter.inputs, images: [image] }, params };
+}
+function variantIndex(outputs, sha) {
+  const images = Array.isArray(outputs?.images) ? outputs.images : [];
+  const want = sha.trim().toLowerCase();
+  if (!/^[0-9a-f]{8,64}$/.test(want)) return null;
+  const hits = images.flatMap((img, i) => typeof img?.sha256 === "string" && img.sha256.startsWith(want) ? [i] : []);
+  return hits.length === 1 ? hits[0] ?? null : null;
+}
+function variantSources(nodes) {
+  const calls = nodes.filter((n) => n.tags?.role === STATIC_VARIANT_CALL_ROLE);
+  const ids = new Set(calls.flatMap((call) => ancestors(nodes, call.id).map((n) => n.id)));
+  return nodes.filter((n) => ids.has(n.id));
+}
+function variantFiles(canvas) {
+  return variantSources(canvas.nodes).flatMap((n) => {
+    const { source, path: path3, expect } = n.params ?? {};
+    return n.type === "ingest" && source === "path" && typeof path3 === "string" ? [{ id: n.id, path: path3, expect: String(expect ?? "") }] : [];
+  });
+}
+function declared(n) {
+  const { path: _where, ...params } = n.params ?? {};
+  const own = n.type === "ingest" && n.params?.source === "path" ? params : n.params ?? {};
+  return canonicalize({ type: n.type, inputs: n.inputs ?? {}, params: own });
+}
+function makesSameVariants(current, version, ingested) {
+  const sources = variantSources(current.nodes);
+  if (sources.length === 0) return false;
+  const was = new Map(version.canvas.nodes.map((n) => [n.id, n]));
+  const sameDeclaration = sources.every((n) => {
+    const before = was.get(n.id);
+    return before !== void 0 && declared(before) === declared(n);
+  });
+  return sameDeclaration && variantFiles(current).every((file) => {
+    const asset = version.outputs[file.id]?.asset;
+    return typeof asset?.sha256 === "string" && (ingested[file.id] ?? []).includes(asset.sha256);
+  });
+}
+function madeThisRun(grown) {
+  const master = grown.canvas.nodes.find((n) => n.tags?.role === STATIC_MASTER_ROLE);
+  const head = refNode(master?.inputs?.image);
+  const nodes = grown.canvas.nodes.filter((n) => !(n.id in grown.pinned) || n.id === head);
+  return { ...grown.canvas, nodes };
+}
+function growFromVersion(current, version, growth) {
+  if (isPlateCanvas(current)) return growPlateFromVersion(current, version, growth);
+  const master = current.nodes.find((n) => n.tags?.role === STATIC_MASTER_ROLE);
+  const history = master ? versionHistory(current, version, growth) : null;
+  if (!master || !history) return null;
+  const { kept, pinned } = history;
+  const keptIds = new Set(kept.map((n) => n.id));
+  const stage = new Set(
+    ancestors(current.nodes, master.id).filter((n) => n.id !== master.id && isPicture(n)).map((n) => n.id)
+  );
+  const rest = current.nodes.filter((n) => !stage.has(n.id) && !keptIds.has(n.id));
+  const top = stepsOnTop({ current, master, kept, rest }, history.picture, growth);
+  if (!top) return null;
+  const at = rest.findIndex((n) => n.id === master.id);
+  const nodes = rest.map((n) => n.id === master.id ? { ...n, inputs: { ...n.inputs, image: top.picture } } : n);
+  return {
+    canvas: { ...current, nodes: [...nodes.slice(0, at), ...kept, ...top.added, ...nodes.slice(at)] },
+    pinned
+  };
+}
+function versionHistory(current, version, growth) {
+  const was = version.canvas.nodes;
+  const image = was.find((n) => n.tags?.role === STATIC_MASTER_ROLE)?.inputs?.image;
+  if (typeof image !== "string") return null;
+  let picture = image;
+  let from = refNode(image) ?? "";
+  if (growth.kind === "variant") {
+    const variants = was.find((n) => n.tags?.role === STATIC_VARIANTS_ROLE);
+    const at = variants ? variantIndex(version.outputs[variants.id], growth.sha256) : null;
+    if (!variants || at === null) return null;
+    picture = `$ref:${variants.id}.images#${at}`;
+    from = variants.id;
+  }
+  const own = new Set(current.nodes.map((n) => n.id));
+  const kept = ancestors(was, from).filter((n) => isPicture(n) || !own.has(n.id));
+  const pinned = {};
+  for (const n of kept) {
+    const outputs = version.outputs[n.id];
+    if (!outputs) return null;
+    pinned[n.id] = outputs;
+  }
+  return { kept, pinned, picture };
+}
+function stepsOnTop(at, picture, growth) {
+  if (growth.kind === "keep") return { added: [], picture };
+  const prefilter = framingPrefilter(at.current.nodes, at.master);
+  const step = growth.kind === "edit" ? editStep(at, picture, growth) : chosenStep(picture);
+  if (!step) return null;
+  const frame = frameNode(prefilter, `${step.id}_frame`, `$ref:${step.id}.images#0`);
+  return frame ? { added: [step, frame], picture: `$ref:${frame.id}.image` } : { added: [step], picture: `$ref:${step.id}.images#0` };
+}
+function editStep(at, picture, growth) {
+  const n = 1 + Math.max(0, ...at.kept.map((k) => Number(k.id.match(EDIT_ID)?.[1] ?? 0)));
+  const template = at.current.nodes.find(
+    (v) => v.type === "image_generate" && [STATIC_VARIANT_CALL_ROLE, STATIC_VARIANTS_ROLE].includes(v.tags?.role ?? "")
+  );
+  if (!template) return null;
+  const masterFormat = staticMasterFormat(at.current);
+  const brief = fixBriefNode({ nodes: [...at.kept, ...at.rest] }, template, growth.promptJson, {
+    instruction: growth.instruction,
+    previous: picture,
+    ...growth.rejected ? { rejected: growth.rejected } : {},
+    ...growth.rules ? { rules: growth.rules } : {},
+    ...masterFormat ? { format: masterFormat } : {}
+  });
+  const { n: _n, ...params } = brief.params ?? {};
+  return {
+    id: `edit_${n}`,
+    type: brief.type,
+    ...brief.inputs ? { inputs: brief.inputs } : {},
+    params,
+    tags: { role: STATIC_FIX_ROLE }
+  };
+}
+function chosenStep(picture) {
+  return { id: "chosen", type: "collect", inputs: { images: [picture] }, tags: { role: STATIC_PICK_ROLE } };
+}
+function platePrefilter(nodes) {
+  return nodes.find((n) => n.type === "static_prefilter" && n.tags?.role === VARIANT_PREFILTER_ROLE);
+}
+function shownPlate(nodes, fallback) {
+  const size = nodes.find(
+    (n) => n.type === "static_format" && n.tags?.role === STATIC_FORMAT_ROLE && typeof n.inputs?.plate === "string" && !n.inputs.plate.startsWith("$ref:plate_wide.")
+  );
+  return typeof size?.inputs?.plate === "string" ? size.inputs.plate : fallback;
+}
+function askedForPlate(canvas) {
+  return canvas.metadata?.master_shape === "plate";
+}
+function adPlate(nodes) {
+  return nodes.find(
+    (n) => n.type === "static_plate" && n.tags?.role === STATIC_PLATE_ROLE && n.params?.mode === "from_ad"
+  );
+}
+function rewired(node, from, to) {
+  if (!node.inputs) return node;
+  const text = JSON.stringify(node.inputs);
+  const next = text.split(JSON.stringify(from)).join(JSON.stringify(to));
+  return next === text ? node : { ...node, inputs: JSON.parse(next) };
+}
+function growPlateFromVersion(current, version, growth) {
+  const head = platePrefilter(current.nodes);
+  const was = platePrefilter(version.canvas.nodes);
+  if (head && !isPlateCanvas(version.canvas)) return growFromApprovedAd(current, head, version, growth);
+  if (head && !was && adPlate(version.canvas.nodes)) return growFromMovedAd(current, head, version, growth);
+  const shown = head && was ? plateShownBy(version, was, growth) : null;
+  if (!head || !shown) return null;
+  const own = new Set(current.nodes.map((n) => n.id));
+  const kept = ancestors(version.canvas.nodes, shown.from).filter((n) => isPicture(n) || !own.has(n.id));
+  const pinned = recordedOutputs(kept, version);
+  const edit = growth.kind === "edit" ? plateEditStep(current, kept, shown.plate, growth) : null;
+  if (!pinned || growth.kind === "edit" && !edit) return null;
+  const plate = edit ? `$ref:${edit.id}.images#0` : shown.plate;
+  const added = [...shown.chosen ? [shown.chosen] : [], ...edit ? [edit] : []];
+  const stage = new Set(
+    ancestors(current.nodes, head.id).filter(isPicture).map((n) => n.id)
+  );
+  const keptIds = new Set(kept.map((n) => n.id));
+  const remaining = current.nodes.filter((n) => !stage.has(n.id) && !keptIds.has(n.id));
+  const at = afterHead(current.nodes, remaining, head);
+  const rest = remaining.map((n) => rewired(n, `$ref:${head.id}.plate`, plate));
+  return {
+    canvas: { ...current, nodes: [...rest.slice(0, at), ...kept, ...added, ...rest.slice(at)] },
+    pinned
+  };
+}
+function plateShownBy(version, was, growth) {
+  if (growth.kind !== "variant") {
+    const plate2 = shownPlate(version.canvas.nodes, `$ref:${was.id}.plate`);
+    return { plate: plate2, from: refNode(plate2) ?? was.id };
+  }
+  const variants = version.canvas.nodes.find((n) => n.tags?.role === STATIC_VARIANTS_ROLE);
+  const at = variants ? variantIndex(version.outputs[variants.id], growth.sha256) : null;
+  const plates = was.inputs?.plates;
+  const plate = at !== null && Array.isArray(plates) ? plates[at] : void 0;
+  if (!variants || typeof plate !== "string") return null;
+  const { judge_model: _judge, judge_prompt: _prompt, ...params } = was.params ?? {};
+  const chosen = {
+    id: "chosen",
+    type: "static_prefilter",
+    inputs: { images: [`$ref:${variants.id}.images#${at}`], plates: [plate] },
+    params,
+    tags: { role: STATIC_PICK_ROLE }
+  };
+  return { plate: "$ref:chosen.plate", from: was.id, chosen };
+}
+function recordedOutputs(kept, version) {
+  const pinned = {};
+  for (const n of kept) {
+    const outputs = version.outputs[n.id];
+    if (!outputs) return null;
+    pinned[n.id] = outputs;
+  }
+  return pinned;
+}
+function plateEditStep(current, kept, plate, growth) {
+  const n = 1 + Math.max(0, ...kept.map((k) => Number(k.id.match(EDIT_ID)?.[1] ?? 0)));
+  const template = current.nodes.find((v) => v.type === "image_generate" && v.tags?.role === STATIC_VARIANT_CALL_ROLE);
+  if (!template) return null;
+  const { n: _n, prompt: _prompt, ...params } = template.params ?? {};
+  const wired = template.inputs?.reference;
+  const refs = (Array.isArray(wired) ? wired : []).filter(
+    (r) => typeof r === "string" && !r.startsWith("$ref:original.")
+  );
+  return {
+    id: `edit_${n}`,
+    type: "image_generate",
+    inputs: { reference: [plate, ...refs] },
+    params: {
+      ...params,
+      prompt: plateFixPrompt(growth.instruction, {
+        ...growth.rejected ? { rejected: growth.rejected } : {},
+        ...growth.rules ? { rules: growth.rules } : {}
+      })
+    },
+    tags: { role: STATIC_FIX_ROLE }
+  };
+}
+function afterHead(nodes, remaining, head) {
+  const headAt = nodes.indexOf(head);
+  const at = remaining.findIndex((n) => nodes.indexOf(n) > headAt);
+  return at < 0 ? remaining.length : at;
+}
+function urlOf(output) {
+  const url = output?.url;
+  return typeof url === "string" && /^(?:https?|data):/.test(url) ? url : null;
+}
+function approvedAd(version, growth) {
+  if (growth.kind === "variant") {
+    const variants = version.canvas.nodes.find((n) => n.tags?.role === STATIC_VARIANTS_ROLE);
+    const at = variants ? variantIndex(version.outputs[variants.id], growth.sha256) : null;
+    const images = variants ? version.outputs[variants.id]?.images : void 0;
+    const url2 = at !== null && Array.isArray(images) ? urlOf(images[at]) : null;
+    return url2 ? { url: url2, delivered: false } : null;
+  }
+  const master = version.canvas.nodes.find((n) => n.tags?.role === STATIC_MASTER_ROLE);
+  const url = master ? urlOf(version.outputs[master.id]?.image ?? version.outputs[master.id]?.asset) : null;
+  return url ? { url, delivered: true } : null;
+}
+function growFromApprovedAd(current, head, version, growth) {
+  if (!askedForPlate(current)) return null;
+  const ad = approvedAd(version, growth);
+  const parts = adParts(current);
+  if (!ad || !parts) return null;
+  const { template, lead } = parts;
+  const asIs = ad.delivered && growth.kind === "keep" && growth.wordsChanged !== true;
+  const approved = {
+    id: "approved",
+    type: "ingest",
+    params: { source: "url", url: ad.url, expect: "image" },
+    // Delivered as it is, it is the version's chosen picture to every reader (`withDeliveredSizes`).
+    ...asIs ? { tags: { role: STATIC_MASTER_ROLE } } : {}
+  };
+  const words = lead.params?.words ?? {};
+  const plate = {
+    id: "plate_ad",
+    type: "static_plate",
+    inputs: { image: "$ref:approved.asset" },
+    params: {
+      mode: "from_ad",
+      aspect_ratio: String(template.params?.aspect_ratio ?? "9:16"),
+      paint: {
+        model: String(words.model ?? template.params?.model ?? ""),
+        ...words.quality ? { quality: words.quality } : {}
+      },
+      ...Array.isArray(lead.params?.copy) ? { copy: lead.params.copy } : {},
+      ...Array.isArray(lead.params?.in_scene) ? { in_scene: lead.params.in_scene } : {}
+    },
+    tags: { role: STATIC_PLATE_ROLE }
+  };
+  const edit = growth.kind === "edit" ? plateEditStep(current, [], "$ref:plate_ad.image", growth) : null;
+  return {
+    canvas: cutFromAd(current, head, parts, { top: [approved, plate, ...edit ? [edit] : []], edit, plate, asIs }),
+    pinned: {}
+  };
+}
+function growFromMovedAd(current, head, version, growth) {
+  const plate = adPlate(version.canvas.nodes);
+  const parts = adParts(current);
+  if (!plate || !parts || growth.kind === "variant") return null;
+  const shown = shownPlate(version.canvas.nodes, `$ref:${plate.id}.image`);
+  const own = new Set(current.nodes.map((n) => n.id));
+  const kept = ancestors(version.canvas.nodes, refNode(shown) ?? plate.id).filter(
+    (n) => isPicture(n) || !own.has(n.id)
+  );
+  const pinned = recordedOutputs(kept, version);
+  const edit = growth.kind === "edit" ? plateEditStep(current, kept, shown, growth) : null;
+  if (!pinned || growth.kind === "edit" && !edit) return null;
+  const approvedId = refNode(plate.inputs?.image);
+  const deliveredAsIs = kept.some((n) => n.id === approvedId && n.tags?.role === STATIC_MASTER_ROLE);
+  const asIs = deliveredAsIs && growth.kind === "keep" && growth.wordsChanged !== true;
+  const top = kept.map((n) => {
+    if (n.id !== approvedId || asIs || !n.tags) return n;
+    const { tags: _tags, ...untagged } = n;
+    return untagged;
+  });
+  return {
+    canvas: cutFromAd(current, head, parts, { top: [...top, ...edit ? [edit] : []], edit, plate, shown, asIs }),
+    pinned
+  };
+}
+function adParts(current) {
+  const template = current.nodes.find((v) => v.type === "image_generate" && v.tags?.role === STATIC_VARIANT_CALL_ROLE);
+  const master = current.nodes.find((n) => n.tags?.role === STATIC_MASTER_ROLE);
+  const leadId = refNode(master?.inputs?.image);
+  const lead = current.nodes.find((n) => n.id === leadId && n.type === "static_format");
+  return template && master && lead ? { template, master, lead } : null;
+}
+function cutFromAd(current, head, parts, at) {
+  const painted = `$ref:${at.plate.id}.image`;
+  const picture = at.edit ? `$ref:${at.edit.id}.images#0` : at.shown ?? painted;
+  const approved = `$ref:${refNode(at.plate.inputs?.image) ?? "approved"}.asset`;
+  const stage = new Set(
+    ancestors(current.nodes, head.id).filter(isPicture).map((n) => n.id)
+  );
+  const topIds = new Set(at.top.map((n) => n.id));
+  const leadLogo = at.asIs ? current.nodes.find((n) => n.tags?.role === LOGO_COMPOSITE_ROLE && refNode(n.inputs?.image) === parts.master.id) : void 0;
+  const dropped = at.asIs ? /* @__PURE__ */ new Set([...stage, parts.master.id, parts.lead.id, ...leadLogo ? [leadLogo.id] : []]) : stage;
+  const remaining = current.nodes.filter((n) => !dropped.has(n.id) && !topIds.has(n.id)).map((n) => leadLogo ? rewired(n, `$ref:${leadLogo.id}.image`, approved) : n);
+  const insertAt = afterHead(current.nodes, remaining, head);
+  const rest = remaining.map((n) => {
+    const cut = rewired(n, `$ref:${head.id}.plate`, picture);
+    const subjects = picture === painted && cut.type === "static_format" && cut.inputs?.plate === picture && cut.inputs.subjects === void 0 ? { ...cut, inputs: { ...cut.inputs, subjects: `$ref:${at.plate.id}.subjects` } } : cut;
+    return at.asIs ? rewired(rewired(subjects, `$ref:${parts.master.id}.image`, approved), `$ref:${parts.lead.id}.image`, approved) : subjects;
+  });
+  return { ...current, nodes: [...rest.slice(0, insertAt), ...at.top, ...rest.slice(insertAt)] };
+}
+function plainRunGrowth(current, version, opts) {
+  if (opts.sameVariants) return { kind: "keep" };
+  if (!isPlateCanvas(current) || opts.frameChanged || opts.pictureChanged) return null;
+  if (isPlateCanvas(version.canvas) && !adPlate(version.canvas.nodes))
+    return opts.wordsChanged ? { kind: "keep" } : null;
+  if (!isPlateCanvas(version.canvas) && !askedForPlate(current)) return null;
+  return { kind: "keep", wordsChanged: opts.wordsChanged };
+}
+function shownPlateUrl(version) {
+  const was = platePrefilter(version.canvas.nodes);
+  const painted = adPlate(version.canvas.nodes);
+  const fallback = was ? `$ref:${was.id}.plate` : painted ? `$ref:${painted.id}.image` : null;
+  if (!fallback || !isPlateCanvas(version.canvas)) return null;
+  const ref = shownPlate(version.canvas.nodes, fallback).match(/^\$ref:([a-z][a-z0-9_]*)\.([a-z_]+)(?:#(\d+))?$/);
+  if (!ref) return null;
+  const [, id = "", slot = "", index] = ref;
+  const out = version.outputs[id]?.[slot];
+  return urlOf(index === void 0 ? out : Array.isArray(out) ? out[Number(index)] : void 0);
+}
+
+// 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 urlOf2(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 = urlOf2(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 = urlOf2(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,
+    STATIC_FORMAT_ROLE,
+    STATIC_PLATE_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);
+  const version = isPlateCanvas(canvas) ? await versionRun(canvasRoot, runId).catch(() => null) : null;
+  const plate = version ? shownPlateUrl(version) : null;
+  if (!picture || isPlateCanvas(canvas) && !plate) {
+    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, ...plate ? { plate } : {} }, canvas, spec: drawn };
+}
+async function deliveredSizes(canvasRoot, runId, canvas, record) {
+  const masterReads = String(nodesWithRole(canvas, STATIC_MASTER_ROLE)[0]?.inputs?.image ?? "");
+  const wanted = /* @__PURE__ */ new Set([
+    ...nodesWithRole(canvas, STATIC_ADAPT_FORMAT_ROLE).flatMap((n) => formatOfAdaptId(n.id) ?? []),
+    ...nodesWithRole(canvas, STATIC_FORMAT_ROLE).flatMap((n) => {
+      const format = n.params?.format;
+      return typeof format === "string" && !masterReads.startsWith(`$ref:${n.id}.`) ? [format] : [];
+    })
+  ]);
+  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,
+  variantFiles,
+  makesSameVariants,
+  madeThisRun,
+  growFromVersion,
+  plainRunGrowth,
+  isStaticAdCanvas,
+  previousAdImage,
+  previousDelivered,
+  versionRun,
+  ingestedNow,
+  correctedPicture,
+  pictureRecord,
+  keepsChosen,
+  relaysSizesOnly,
+  variantImage,
+  seriesLeadsAbove,
+  seriesMembers,
+  leadVersion,
+  writeSeriesMemberCanvas,
+  seriesRunHints
+};
+//# sourceMappingURL=chunk-XUXRA7IB.js.map