@koda-sl/baker-cli 0.404.0 → 0.405.0

package/README.md

@@ -5775,7 +5775,7 @@ It then scaffolds a canvas that draws **only what `prompt.json` holds**; no elem
 
 **Placement formats.** The canvas delivers the platform's full placement set, each format at its exact size, collected under `final` with the format as its label. The set is derived from `--platform` (`meta` → 4:5 + 9:16, `google` → 1:1 + 4:5 + 16:9, `linkedin` → 1:1, `tiktok` → 9:16, `youtube` → 16:9); override it with `--placements <preset>` or `--placements none` for a single format. The report's `aspect_ratio` is the ratio the plates really render at (the model's nearest to the lead format), and `format_plan` says how each format is made.
 
-**After a run** the CLI reads the finished ad back on what makes a static win, not a checklist of elements: every delivered image's pixel shape against its format, and one vision pass that reads each word against the copy `prompt.json` holds and checks one dominant idea, clipping, artifacts, the brand with the logo covered and the concept's mechanisms, with every format shown a second time at phone-feed thumbnail size (240px wide, same call): a lead message unreadable at that size is blocking. A missing logo, CTA or copy is never a finding; a logo that is drawn and broken is. stdout carries `verdict` (`ready` | `ready_with_notes` | `needs_fixes` | `not_reviewed`), `judge` (the per-plate scores) and hints that end with what the run made; the findings are stored on the run as its `review`. `needs_fixes` means the ad is not done even though every node completed; its hints name the cheapest fix (overlapping or unreadable copy is fixed with a smaller `size`, a `highlight` or `sticker` treatment or shorter words, which re-draw the formats from the cached plates). **Render budget:** a static ad gets 3 renders per creative in a chat before the person reacts; the fourth exits 2 with `RENDER_BUDGET` without rendering, and `baker creatives feedback record` or `baker creatives select` on that creative opens a new round. Resuming an interrupted run does not count again, and a run that died only on an outage (timeout, network, a provider that says retry) gives its render back.
+**After a run** the CLI reads the finished ad back on what makes a static win, not a checklist of elements: every delivered image's pixel shape against its format, and one vision pass that reads each word against the copy `prompt.json` holds and checks one dominant idea, clipping, artifacts, the brand with the logo covered and the concept's mechanisms, with every format shown a second time at phone-feed thumbnail size (240px wide, same call): a lead message unreadable at that size is blocking. A missing logo, CTA or copy is never a finding; a logo that is drawn and broken is. stdout carries `verdict` (`ready` | `ready_with_notes` | `needs_fixes` | `not_reviewed`), `judge` (the per-plate scores) and hints that end with what the run made; the findings are stored on the run as its `review`. `needs_fixes` means the ad is not done even though every node completed; its hints name the cheapest fix (overlapping or unreadable copy is fixed with a smaller `size`, a `highlight` or `sticker` treatment or shorter words, which re-draw the formats from the cached plates). **Render budget:** a static ad gets, per creative in a chat before the person reacts, 3 renders that paint pictures and then 4 re-draws from those pictures; a render that paints nothing (every billed node from the cache) counts as a re-draw. With the pictures spent a re-draw runs only from the cache (the engine's `billed_from_cache_only`), and one that would paint exits 2 with `RENDER_BUDGET` before billing; with both spent every render exits 2 with `RENDER_BUDGET` without rendering, and `baker creatives feedback record` or `baker creatives select` on that creative opens a new round. Resuming an interrupted run does not count again, and a run that died only on an outage (timeout, network, a provider that says retry) gives its render back.
 
 The logo is never a slot to fill: use the company's committed logo in `src/brand/logos/` (per `BRAND.md`), never `baker images logo <domain>`, whose Brandfetch CDN often serves an outdated mark.
 

package/dist/{chunk-KE6GXLDE.js → chunk-DGZ5DLXK.js}

@@ -6223,20 +6223,7 @@ var Engine = class {
     const layers = topologicalLayers(graph);
     const limit = resolveConcurrency(opts.concurrency);
     for (const layer of layers) {
-      if (opts.signal?.aborted) throw new RunAbortedError("signal", "run aborted before layer dispatch");
-      if (opts.max_credits !== void 0 && counters.totalCredits > opts.max_credits) {
-        throw new RunAbortedError(
-          "cost_cap",
-          `spent ${counters.totalCredits} credits, over the ${opts.max_credits}-credit cap \u2014 completed nodes are cached; raise --max-credits to continue where this stopped`
-        );
-      }
-      const held = heldByCheckpoint(canvas, layer, opts.stop_before_kinds);
-      if (held.length > 0) {
-        throw new RunAbortedError(
-          "checkpoint",
-          `stopped before ${held.join(", ")} \u2014 everything up to here is done and cached, so continuing this run id pays for none of it again`
-        );
-      }
+      await this.assertLayerMayRun(canvas, layer, outputs, runId, opts, counters);
       const settled = await mapWithConcurrency(layer, limit, (nodeId) => {
         if (opts.signal?.aborted) {
           return Promise.reject(new RunAbortedError("signal", "run aborted before node dispatch"));
@@ -6363,6 +6350,59 @@ var Engine = class {
     this.logOutputWarnings(node.id, outputsObj);
     return { cached: false, credits, durationMs: elapsed };
   }
+  /**
+   * Every reason a layer must not dispatch, checked before any of its nodes starts, so a stop
+   * never leaves a layer half billed: a signal, the cost cap, a checkpoint, and a billed node
+   * the cache cannot serve when the run is cache-only.
+   */
+  async assertLayerMayRun(canvas, layer, outputs, runId, opts, counters) {
+    if (opts.signal?.aborted) throw new RunAbortedError("signal", "run aborted before layer dispatch");
+    if (opts.max_credits !== void 0 && counters.totalCredits > opts.max_credits) {
+      throw new RunAbortedError(
+        "cost_cap",
+        `spent ${counters.totalCredits} credits, over the ${opts.max_credits}-credit cap \u2014 completed nodes are cached; raise --max-credits to continue where this stopped`
+      );
+    }
+    const held = heldByCheckpoint(canvas, layer, opts.stop_before_kinds);
+    if (held.length > 0) {
+      throw new RunAbortedError(
+        "checkpoint",
+        `stopped before ${held.join(", ")} \u2014 everything up to here is done and cached, so continuing this run id pays for none of it again`
+      );
+    }
+    if (opts.billed_from_cache_only) {
+      const fresh = await this.billedMisses(canvas, layer, outputs, runId, opts);
+      if (fresh.length > 0) {
+        throw new RunAbortedError(
+          "cache_only",
+          `${fresh.join(", ")} would be rendered fresh and billed \u2014 nothing in this layer ran`
+        );
+      }
+    }
+  }
+  /**
+   * The billed nodes of a layer that would miss the cache, found before any of them runs:
+   * each is prepared exactly as `executeOne` would (same inputs, params and cache key).
+   *
+   * `executeOne` prepares each node again when it runs, so a cache-only layer hydrates its
+   * text slots and hashes its `cacheKeyExtras` twice. Deliberate: a re-draw's layers are
+   * small, and threading this preparation into `executeOne` would couple the check to the
+   * run path, where a stale preparation would bill the wrong key.
+   */
+  async billedMisses(canvas, layer, outputs, runId, opts) {
+    const misses = [];
+    for (const nodeId of layer) {
+      const node = canvas.nodes.find((n) => n.id === nodeId);
+      const def = node ? this.registry.get(node.type) : void 0;
+      if (!node || !def) continue;
+      const token = resolveRegenerateToken(node, opts.regenerate, runId);
+      const prepared = await prepareForExecution(node, outputs, def, canvas.cache_salt, token, this.assets);
+      if (estimateNodeCredits2(def, prepared.renderedParams) <= 0) continue;
+      const hit = opts.cache_policy === "bypass" ? null : await this.cache.get(prepared.cacheKey);
+      if (!hit) misses.push(nodeId);
+    }
+    return misses;
+  }
   /** A cache hit replayed as this node's result: its outputs written, and free. */
   async replayCached(node, cacheKey, outputs, writer) {
     const cacheT0 = Date.now();
@@ -11668,4 +11708,4 @@ export {
   defaultRegistry,
   createEngineFromEnv
 };
-//# sourceMappingURL=chunk-KE6GXLDE.js.map
+//# sourceMappingURL=chunk-DGZ5DLXK.js.map