@koda-sl/baker-cli 0.146.1 → 0.148.0

package/README.md

@@ -492,6 +492,8 @@ Command groups: `budgets`, `campaigns`, `ad-groups`, `keywords` (add/update/remo
 
 **Amending a staged op** — `draft amend <ref> (--file patch.json | --patch '<json>')` merges a JSON patch into an already-staged op's payload (objects deep-merge, `null` deletes a key, arrays/scalars replace) and re-validates it in full. Always prefer this over removing and re-staging — it preserves the op's ref (so dependents don't break) and its position in the draft. `draft show <ref>` prints the full staged payload (including warnings/annotations) so you can verify a change looks right before publish.
 
+**Already-satisfied writes aren't staged** — an update or pause/resume whose every field already holds the requested value on the live account is dropped instead of staged: the envelope returns `"staged": false, "noop": true` with a `reason` ("this ad is already Paused on Google Ads"), plus a hint. This is a success, not an error — there is nothing to publish. Only a positively-read live snapshot can trigger it; a failed or empty read always stages. Batch responses list the dropped ops under `skipped`, and `count` reflects what actually entered the draft.
+
 **Batch keyword adds** — `keywords add`, `negative-keywords add`, and `keyword-lists add` take a whole batch in one command: comma-separate `--text` entries and/or pass `--file <list.txt>` (one keyword per line). A `:EXACT`/`:PHRASE`/`:BROAD` suffix per entry overrides the `--match-type` default. Batches stage all-or-nothing as one request (limit 500); each keyword still lands as its own draft op, so it stays individually removable/amendable.
 
 ---
@@ -2647,10 +2649,14 @@ baker canvas validate my-canvas.json
 #    Blocking issues exit non-zero. Advisory `warnings[]` (exit 0) flag likely-wrong-but-
 #    legal config to review before billing — a frame that describes a recurring element
 #    (a pet/product) but doesn't wire its reference (VIDEO_REFERENCE_MISSING), or a scene
-#    span that exceeds the assigned model's max clip duration (VIDEO_SPAN_EXCEEDS_MODEL).
+#    span that exceeds the assigned model's max clip duration (VIDEO_SPAN_EXCEEDS_MODEL),
+#    or the same ad rendered once per aspect ratio instead of one hero + a terminal
+#    image_aspect_adapt (IMAGE_PARALLEL_FORMAT_RENDERS — separate renders drift in type,
+#    crop, and color, so the sizes stop matching).
 
 # 2. Run (executes nodes, writes files to ./canvas/<run_id>/)
 baker canvas run my-canvas.json
+#    Advisory warnings print as `[warn] <CODE>: …` before anything bills.
 #    Only nodes reachable from the declared output execute (orphaned nodes are skipped,
 #    not billed). Add --keep-runs N to prune old r_* run dirs, keeping the N newest.
 
@@ -2681,7 +2687,7 @@ baker canvas run my-canvas.json --remote-cache off --no-record
 #     restructure the canvas (repointing output / deleting nodes) to trick the cache:
 #       • One-shot flag — forces the named nodes + everything downstream fresh this
 #         run, leaving every other node cached (unknown ids fail loudly before billing):
-baker canvas run my-canvas.json --regenerate gen_4x5,gen_9x16
+baker canvas run my-canvas.json --regenerate gen,adapt
 #       • Persistent — add/bump a node's `regenerate` field in the canvas JSON
 #         (e.g. "regenerate": 2) and re-run; the fresh render is reproducible in any
 #         later session. Bump it again (3, 4, …) for each additional draw.
@@ -4152,8 +4158,8 @@ Re-run a creative's latest recorded canvas **from run history** — no local fil
 | `--concurrency <n>` | — | Same as `canvas run --concurrency`. |
 
 ```bash
-baker canvas rerun spring-offer-4x5
-baker canvas rerun spring-offer-4x5 --force-remote --regenerate gen_4x5
+baker canvas rerun spring-offer
+baker canvas rerun spring-offer --force-remote --regenerate gen
 ```
 
 Use it when a creative was built in another conversation (or its sandbox is gone) and you need to continue or re-render it here. Files the snapshot could not include (missing at run time, or oversized) are listed as warnings — supply those locally only if the run actually needs to regenerate the nodes that read them.

package/dist/{chunk-TAGQCU36.js → chunk-2F5SCTNS.js}

@@ -2762,7 +2762,8 @@ var STAGE_CODES = {
   REGION_DROPPED: "VIDEO_REGION_DROPPED",
   OVERLAY_OUT_OF_BOUNDS: "VIDEO_OVERLAY_OUT_OF_BOUNDS",
   ORPHAN_NODE: "ORPHAN_NODE",
-  INGEST_PATH_URL_HEALED: "INGEST_PATH_URL_HEALED"
+  INGEST_PATH_URL_HEALED: "INGEST_PATH_URL_HEALED",
+  PARALLEL_FORMAT_RENDERS: "IMAGE_PARALLEL_FORMAT_RENDERS"
 };
 var SPAN_MODEL_SLACK_S = 0.25;
 var VIDEO_TIME_SLACK_S = 0.75;
@@ -2828,6 +2829,7 @@ function validateCanvas(input, registry) {
   const estimatedCredits = estimateCredits(ctx);
   checkOutputRef(ctx);
   checkOrphanNodes(ctx);
+  checkParallelFormatRenders(ctx);
   checkVideoInvariants(ctx);
   const hasBlocking = issues.some(isBlocking);
   if (hasBlocking) return { ok: false, issues };
@@ -3719,6 +3721,65 @@ function checkAspectConsistency(ctx) {
     message: `video_generate nodes disagree on aspect_ratio (${[...ratios].sort().join(", ")}) \u2014 the spine's segments would render at different shapes and the composite silently crops. Pin every clip to the same aspect_ratio`
   });
 }
+var SAME_CREATIVE_PROMPT_SIMILARITY = 0.6;
+function promptWordSet(text) {
+  return new Set(
+    text.toLowerCase().split(/[^a-z0-9']+/).filter((w) => w.length >= 3)
+  );
+}
+function jaccard(a, b) {
+  if (a.size === 0 || b.size === 0) return 0;
+  let shared = 0;
+  for (const w of a) if (b.has(w)) shared++;
+  return shared / (a.size + b.size - shared);
+}
+function parallelFormatRenderGroups(nodes) {
+  const parent = nodes.map((_, i) => i);
+  const find = (i) => {
+    let root = i;
+    while (parent[root] !== root) root = parent[root];
+    return root;
+  };
+  const words = nodes.map((n) => promptWordSet(n.prompt));
+  for (let i = 0; i < nodes.length; i++) {
+    for (let j = i + 1; j < nodes.length; j++) {
+      const a = nodes[i];
+      const b = nodes[j];
+      if (a.ratio === b.ratio) continue;
+      if (jaccard(words[i], words[j]) < SAME_CREATIVE_PROMPT_SIMILARITY) continue;
+      parent[find(i)] = find(j);
+    }
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (let i = 0; i < nodes.length; i++) {
+    const root = find(i);
+    const group = groups.get(root) ?? [];
+    group.push(nodes[i]);
+    groups.set(root, group);
+  }
+  return [...groups.values()].filter((g) => g.length > 1);
+}
+function checkParallelFormatRenders(ctx) {
+  const candidates = [];
+  for (const n of ctx.canvas.nodes) {
+    if (n.type !== "image_generate") continue;
+    const params = n.params;
+    const prompt = params?.prompt;
+    if (typeof prompt !== "string" || prompt.length === 0) continue;
+    candidates.push({ id: n.id, prompt, ratio: String(params?.aspect_ratio ?? "(unset)") });
+  }
+  if (candidates.length < 2) return;
+  for (const group of parallelFormatRenderGroups(candidates)) {
+    const ids = group.map((g) => g.id);
+    const ratios = [...new Set(group.map((g) => g.ratio))].sort();
+    ctx.issues.push({
+      path: "nodes",
+      code: STAGE_CODES.PARALLEL_FORMAT_RENDERS,
+      severity: "warning",
+      message: `${ids.join(", ")} render the same creative once per aspect ratio (${ratios.join(", ")}) \u2014 each is an independent generation, so the formats come back with different type, crop, and color and stop reading as one ad. Keep ONE hero render and add a terminal image_aspect_adapt node fed from it (params.formats or params.platform) so every ratio is re-framed from the same image`
+    });
+  }
+}
 function checkOrphanNodes(ctx) {
   const out = ctx.canvas.output;
   if (!out || !ctx.idToIndex.has(out.node)) return;
@@ -7837,4 +7898,4 @@ export {
   defaultRegistry,
   createEngineFromEnv
 };
-//# sourceMappingURL=chunk-TAGQCU36.js.map
+//# sourceMappingURL=chunk-2F5SCTNS.js.map