@koda-sl/baker-cli 0.404.0 → 0.406.0

package/README.md

@@ -5640,7 +5640,6 @@ A completed render the review calls ready (`verdict` `ready` or `ready_with_note
 | `--cache-policy <policy>` | `read_write` | `read_write`, `bypass`, or `read_only`. |
 | `--concurrency <n>` | `5` (or `BAKER_CANVAS_CONCURRENCY`) | Max nodes executing at once within a layer. |
 | `--remote-cache <on\|off>` | `on` (or `BAKER_CANVAS_REMOTE_CACHE`) | Operator only. Company-scoped remote cache + durable asset persistence. |
-| `--max-credits <n>` | uncapped (or `BAKER_CANVAS_MAX_CREDITS`) | Credit ceiling: aborts before billing when the estimate exceeds it, and at layer boundaries once actual spend does. Completed nodes stay cached, so retrying with a higher cap loses nothing. |
 | `--no-record` | records | Skip posting the durable run-history record (and its live progress). |
 | `--until frames` | none | Stop before the clips with the frames settled; the run is recorded as `awaiting_approval` (not failed, not interrupted) and resumes with `--run-id`. |
 | `--cache-dir <path>` | `<workspace root>/canvas/.cache` | Operator only. Where content-addressed bytes + cache index live. |
@@ -5775,7 +5774,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-YOF4XTUW.js}

@@ -3894,8 +3894,12 @@ function estimateNodeCredits2(def, params) {
   if (!parsed.success) return 0;
   return priceNode(def, parsed.data)?.credits ?? 0;
 }
-function estimateCanvasCredits(canvas, registry, ids) {
-  return canvas.nodes.filter((n) => !ids || ids.has(n.id)).map((n) => ({ node_id: n.id, node_type: n.type, credits: estimateNodeCredits2(registry.get(n.type), n.params) }));
+function estimateCanvasCredits(canvas, registry) {
+  return canvas.nodes.map((n) => ({
+    node_id: n.id,
+    node_type: n.type,
+    credits: estimateNodeCredits2(registry.get(n.type), n.params)
+  }));
 }
 function sumCredits(perNode) {
   return perNode.reduce((total, n) => total + n.credits, 0);
@@ -4270,16 +4274,6 @@ function dfsCycle(u, color, stack, reverseAdj) {
   stack.pop();
   return null;
 }
-function nodesBeforeCheckpoint(graph, types, stopKinds) {
-  const all = new Set(graph.keys());
-  if (!stopKinds?.size) return all;
-  const running = /* @__PURE__ */ new Set();
-  for (const layer of topologicalLayers(graph)) {
-    if (layer.some((id) => stopKinds.has(types.get(id) ?? ""))) return running;
-    for (const id of layer) running.add(id);
-  }
-  return running;
-}
 
 // src/engine/engine/validator.ts
 import path5 from "path";
@@ -6153,12 +6147,6 @@ var Engine = class {
   async run(input, opts = {}) {
     const validation = await this.validateDeep(input);
     if (!validation.ok) throw new ValidationError(validation.issues);
-    if (!opts.stop_before_kinds?.size && opts.max_credits !== void 0 && validation.estimatedCredits > opts.max_credits) {
-      throw new RunAbortedError(
-        "cost_cap",
-        `estimated ${validation.estimatedCredits} credits exceeds the ${opts.max_credits}-credit cap \u2014 nothing was billed; raise --max-credits or shrink the canvas`
-      );
-    }
     const canvas = validation.canvas;
     const runId = opts.run_id ?? `r_${ulid()}`;
     const writer = new OutputWriter({ outputsDir: this.outputsDir, runId });
@@ -6172,20 +6160,6 @@ var Engine = class {
     const counters = { cachedNodes: 0, totalCredits: 0 };
     const nodeRuns = [];
     const graph = this.pruneToOutput(canvas, buildDependencyGraph(canvas));
-    if (opts.max_credits !== void 0 && opts.stop_before_kinds?.size) {
-      const willRun = nodesBeforeCheckpoint(
-        graph,
-        new Map(canvas.nodes.map((n) => [n.id, n.type])),
-        opts.stop_before_kinds
-      );
-      const estimate = sumCredits(estimateCanvasCredits(canvas, this.registry, willRun));
-      if (estimate > opts.max_credits) {
-        throw new RunAbortedError(
-          "cost_cap",
-          `estimated ${estimate} credits exceeds the ${opts.max_credits}-credit cap \u2014 nothing was billed; raise --max-credits or shrink the canvas`
-        );
-      }
-    }
     const needsBytes = computeNeedsLocalBytes(canvas, graph, this.registry);
     this.emitProgress(opts, {
       kind: "plan",
@@ -6223,20 +6197,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);
       const settled = await mapWithConcurrency(layer, limit, (nodeId) => {
         if (opts.signal?.aborted) {
           return Promise.reject(new RunAbortedError("signal", "run aborted before node dispatch"));
@@ -6363,6 +6324,53 @@ 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) {
+    if (opts.signal?.aborted) throw new RunAbortedError("signal", "run aborted before layer dispatch");
+    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 +11676,4 @@ export {
   defaultRegistry,
   createEngineFromEnv
 };
-//# sourceMappingURL=chunk-KE6GXLDE.js.map
+//# sourceMappingURL=chunk-YOF4XTUW.js.map