@koda-sl/baker-cli 0.403.0 → 0.405.0

package/dist/{chunk-X7PLV5QH.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();
@@ -8804,7 +8844,12 @@ var CompositionMetaSchema = z12.object({
   fps: z12.number().int().positive().default(30),
   default_duration: z12.number().positive().default(10),
   inputs: z12.record(z12.string(), InputSpec).default({}),
-  params: z12.record(z12.string(), ParamSpec).default({})
+  params: z12.record(z12.string(), ParamSpec).default({}),
+  /**
+   * The page reads its own staged files (a picture's pixels), so a snapshot opens it with
+   * file access. Off by default: Chromium grants it for every file:// path, not just these.
+   */
+  reads_staged_files: z12.boolean().optional()
 }).strict();
 async function loadCompositionMeta(compositionDir) {
   const metaPath = path13.join(compositionDir, "meta.json");
@@ -9835,7 +9880,7 @@ var hyperframeSnapshotNode = defineNode({
       const pwSpecifier = ["play", "wright"].join("");
       const playwright = require_3(pwSpecifier);
       const { chromium } = playwright;
-      const browser = await chromium.launch({ headless: true });
+      const browser = await chromium.launch({ headless: true, args: chromiumArgsFor(meta) });
       try {
         const context = await browser.newContext({
           viewport: { width: meta.width, height: meta.height },
@@ -9871,6 +9916,9 @@ var hyperframeSnapshotNode = defineNode({
     }
   }
 });
+function chromiumArgsFor(meta) {
+  return meta.reads_staged_files ? ["--allow-file-access-from-files"] : [];
+}
 function validateAndParseDynamicParams2(meta, params) {
   const dynamic = {};
   for (const [k, v] of Object.entries(params)) {
@@ -11660,4 +11708,4 @@ export {
   defaultRegistry,
   createEngineFromEnv
 };
-//# sourceMappingURL=chunk-X7PLV5QH.js.map
+//# sourceMappingURL=chunk-DGZ5DLXK.js.map