@koda-sl/baker-cli 0.404.0 → 0.406.0-dev.e84bc866b

package/dist/engine/index.d.ts

@@ -544,14 +544,6 @@ type RunOptions = {
     cache_policy?: "read_write" | "bypass" | "read_only";
     /** Max nodes of one layer in flight at once; invalid or missing → 8 (DEFAULT_CONCURRENCY). */
     concurrency?: number;
-    /**
-     * Credit ceiling (`--max-credits`). Enforced pre-flight against the deep
-     * validator's estimate (nothing billed) and at layer boundaries against
-     * actual spend — a boundary is the only point with no async job in flight,
-     * so aborting there strands nothing. Cached nodes cost 0, so a capped run
-     * retried with a higher cap loses no completed work.
-     */
-    max_credits?: number;
     /**
      * Node ids to force fresh for THIS run only (the `--regenerate` flag). Folds
      * the run id into each named node's cache key so it re-renders regardless of
@@ -567,11 +559,18 @@ type RunOptions = {
      * them. This is what lets someone see those first: the run settles everything cheap and
      * stops on the doorstep of the expensive half.
      *
-     * Deliberately the same shape as the cost cap: it raises `RunAbortedError`, the completed
+     * It raises `RunAbortedError`, the completed
      * nodes are already cached, and continuing is re-running the same `--run-id`, which pays
      * for none of them twice.
      */
     stop_before_kinds?: ReadonlySet<string>;
+    /**
+     * Run only what is already paid for: before a layer dispatches, a billed node (one with a
+     * credit estimate) that would miss the cache stops the run, so nothing in that layer is
+     * billed. Raises `RunAbortedError("cache_only")`; the cached nodes before it stay done.
+     * A static ad whose pictures are spent re-draws its copy this way (render-budget.ts).
+     */
+    billed_from_cache_only?: boolean;
     onProgress?: (event: RunProgressEvent) => void;
 };
 type EngineOptions = {
@@ -632,6 +631,22 @@ declare class Engine$1 {
     private pruneToOutput;
     private writeFinal;
     private executeOne;
+    /**
+     * 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.
+     */
+    private assertLayerMayRun;
+    /**
+     * 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.
+     */
+    private billedMisses;
     /** A cache hit replayed as this node's result: its outputs written, and free. */
     private replayCached;
     /** Best-effort: a failed upload keeps the outputs local-only, never fails the node. */

package/dist/engine/index.js

@@ -8,7 +8,7 @@ import {
   defaultRegistry,
   generateCatalog,
   validateCanvasDeep
-} from "../chunk-KE6GXLDE.js";
+} from "../chunk-WTCR7RAD.js";
 import "../chunk-5X5LUMVV.js";
 import "../chunk-N72QYDJY.js";
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@koda-sl/baker-cli",
-  "version": "0.404.0",
+  "version": "0.406.0-dev.e84bc866b",
   "description": "AI-agent-first CLI for interacting with Baker, including the Baker creative canvas.",
   "type": "module",
   "bin": {