npm - @koda-sl/baker-cli - Versions diffs - 0.97.0 → 0.98.1 - Mend

@koda-sl/baker-cli 0.97.0 → 0.98.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

package/README.md +12 -0
package/canvas/tiktok-captions-composition/index.html +7 -2
package/canvas/video-overlay-composition/index.html +18 -25
package/dist/{chunk-RCPMJKI7.js → chunk-3JVYU72O.js} +130 -24
package/dist/chunk-3JVYU72O.js.map +1 -0
package/dist/cli.js +524 -203
package/dist/cli.js.map +1 -1
package/dist/engine/index.d.ts +7 -0
package/dist/engine/index.js +1 -1
package/package.json +1 -1
package/dist/chunk-RCPMJKI7.js.map +0 -1

package/README.md CHANGED Viewed

@@ -2436,14 +2436,26 @@ baker canvas validate my-canvas.json
 # 2. Run (executes nodes, writes files to ./canvas/<run_id>/)
 baker canvas run my-canvas.json
+#    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.
 # 3. Inspect a finished run (per-node timing, file list, optional video thumbs)
 baker canvas inspect <run_id>
 # 4. Discover what's available (all node types, all models, all compositions)
 baker canvas catalog | jq
+# 5. Safely edit a node's prompt without hand-jq (UTF-8 safe — use --text-file for
+#    multi-line / accented copy; the edit is re-validated before it is written back)
+baker canvas set-prompt my-canvas.json s0_start --text "Close-up, flushed and breathless"
+baker canvas set-prompt my-canvas.json s0_start --text-file ./hook-frame.txt
 ```
+> Scaffolded canvases use **workspace-relative** composition/asset paths and are validated
+> against the engine's hyperframe pre-render gate at `validate` time, so a broken overlay
+> (or a moved/renamed workspace) is caught before any billed clip. The scaffold also adds
+> `canvas/` + `.context/` to your `.gitignore` on first run.
 A re-run with no changes hits the cache for every node — total runtime drops to sub-second.
 ---

package/canvas/tiktok-captions-composition/index.html CHANGED Viewed

@@ -65,7 +65,7 @@
       data-width="1080"
       data-height="1920"
     >
-      <video id="bg" src="background.mp4" muted></video>
+      <video id="bg" class="clip" src="background.mp4" data-start="0" data-duration="{{duration}}" muted></video>
       <div class="caption-container" id="captions"></div>
     </div>
@@ -84,8 +84,13 @@
         groups.forEach((group, gi) => {
           const el = document.createElement('div');
-          el.className = 'caption-group';
+          // `clip` marks this as a hyperframes-timed element (the GSAP timeline
+          // below drives its actual show/hide); without it the pre-render gate
+          // flags every group as visible for the whole composition.
+          el.className = 'caption-group clip';
           el.id = 'cg_' + gi;
+          el.setAttribute('data-start', String(group[0].start));
+          el.setAttribute('data-duration', String((group[group.length - 1].end - group[0].start) || 0.5));
           group.forEach((word, wi) => {
             const span = document.createElement('span');

package/canvas/video-overlay-composition/index.html CHANGED Viewed

@@ -70,10 +70,8 @@
          bottom, but if you hand-place, respect the bands. */
       /* COLLISION-SAFE TOP BAR — wrap co-timed top items (logo + trust badge + …) in ONE
-         .top-bar so they pack side-by-side with a gap and never overlap. Example:
-           <div class="top-bar" data-start="0" data-dur="30">
-             <img class="brandmark" src="logo.svg"><span class="trust">★ 4,5/5</span>
-           </div> */
+         .top-bar (a div.ov.clip.top-bar with data-start/data-dur) so they pack side-by-side
+         with a gap and never overlap; put the brandmark img + a trust span inside it. */
       .top-bar {
         position: absolute; top: 70px; left: 56px; right: 56px;
         display: flex; align-items: center; gap: 20px; flex-wrap: wrap;
@@ -102,30 +100,25 @@
   </head>
   <body>
     <div id="root" data-composition-id="main" data-start="0" data-duration="{{duration}}" data-width="1080" data-height="1920">
-      <video id="bg" src="background.mp4" muted></video>
+      <video id="bg" class="clip" src="background.mp4" data-start="0" data-duration="{{duration}}" muted></video>
       <div id="overlay-root">
 <!--OVERLAYS-->
-        <!-- ── NESTED BLOCK SLOT (optional) ───────────────────────────────────
-             For an ANIMATED graphic (lower-third, social-proof/review card, stat
-             counter, chart, logo sting), pull a ready-made block instead of a
-             static <img>. From this dir:
-                 npx hyperframes catalog --type block        # find one by tag/name
-                 npx hyperframes add yt-lower-third           # writes compositions/yt-lower-third.html
-             then uncomment + retime the nested clip (add data-start/data-track-index;
-             data-composition-id is optional but if set must match the block's id):
-             <div data-composition-src="compositions/yt-lower-third.html"
-                  data-start="3" data-duration="4.5" data-track-index="2"
-                  data-width="1920" data-height="1080"></div>
-             ──────────────────────────────────────────────────────────────────── -->
-        <!-- ── CAPTION TRACK SLOT (optional, recommended for sound-off feeds) ──
-             The feed plays muted — burn in captions from the word-level transcript
-             the deconstruct produced. Floor: `npx hyperframes add caption-highlight`
-             (TikTok karaoke); escalate by register (caption-kinetic-slam, etc.).
-             Wiring + the {id,text,start,end} sync contract:
-             references/hyperframes/captions-and-audio.md.
-             ──────────────────────────────────────────────────────────────────── -->
+        <!-- NESTED BLOCK SLOT (optional): for an ANIMATED graphic (lower-third,
+             social/review card, stat counter, chart, logo sting), pull a ready-made
+             block instead of a static image. From this dir run `npx hyperframes
+             catalog --type block` to find one, `npx hyperframes add yt-lower-third`
+             to write it into compositions/, then add a nested clip element — a div
+             with class clip plus data-composition-src pointing at the block file,
+             data-start, data-duration and data-track-index. See
+             references/hyperframes/blueprints-and-transitions.md. -->
+        <!-- CAPTION TRACK SLOT (optional, recommended for sound-off feeds): the feed
+             plays muted, so burn in captions from the word-level transcript the
+             deconstruct produced. Floor: `npx hyperframes add caption-highlight`
+             (TikTok karaoke); escalate by register (caption-kinetic-slam, etc.). The
+             scaffold already wires a default caption track as a separate composition;
+             see references/hyperframes/captions-and-audio.md for the sync contract. -->
       </div>
     </div>

package/dist/{chunk-RCPMJKI7.js → chunk-3JVYU72O.js} RENAMED Viewed

@@ -1937,6 +1937,25 @@ function topologicalLayers(graph) {
   }
   return layers;
 }
+function reachableNodes(graph, roots) {
+  const reachable = /* @__PURE__ */ new Set();
+  const stack = [...roots];
+  while (stack.length > 0) {
+    const id = stack.pop();
+    if (id === void 0 || reachable.has(id) || !graph.has(id)) continue;
+    reachable.add(id);
+    for (const dep of graph.get(id) ?? []) stack.push(dep);
+  }
+  return reachable;
+}
+function subgraph(graph, keep) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [id, deps] of graph) {
+    if (!keep.has(id)) continue;
+    out.set(id, new Set([...deps].filter((d) => keep.has(d))));
+  }
+  return out;
+}
 function cloneGraph(graph) {
   const out = /* @__PURE__ */ new Map();
   for (const [k, deps] of graph) out.set(k, new Set(deps));
@@ -2369,6 +2388,18 @@ function estimateCredits(ctx) {
   }
   return total;
 }
+function nativeAudioReachesMix(ctx, scene) {
+  const wanted = [
+    `$ref:s${scene}_voextract.audio`,
+    `$ref:s${scene}_clip.audio`,
+    new RegExp(`\\$ref:s${scene}_r\\d+_(voextract|clip)\\.audio`)
+  ];
+  return ctx.canvas.nodes.some((n) => {
+    if (n.type !== "audio_timeline") return false;
+    const blob = JSON.stringify(n.inputs ?? {});
+    return wanted.some((w) => typeof w === "string" ? blob.includes(w) : w.test(blob));
+  });
+}
 function talkingSceneSatisfied(ctx, entry, scene) {
   const nodes = ctx.canvas.nodes;
   if (typeof entry === "object" && "voice_convert_node" in entry) {
@@ -2377,7 +2408,7 @@ function talkingSceneSatisfied(ctx, entry, scene) {
       (n) => nativeClipRe.test(n.id) && n.type === "video_generate" && n.params?.generate_audio === true
     );
     const converted = nodes.some((n) => n.id === entry.voice_convert_node && n.type === "audio_voice_convert");
-    return clipNativeAudio && converted;
+    return clipNativeAudio && (converted || nativeAudioReachesMix(ctx, scene));
   }
   if (typeof entry === "object") {
     return nodes.some((n) => n.id === entry.lipsync_node && n.type === "video_lipsync");
@@ -2418,7 +2449,7 @@ function checkVideoInvariants(ctx) {
       ctx.issues.push({
         path: "metadata.video.talking_scenes",
         code: STAGE_CODES.LIPSYNC_MISSING,
-        message: `scene ${scene} is a single-on-camera-speaker talking head but its clip lacks native audio (generate_audio) or the audio_voice_convert node is missing \u2014 the voice won't be brand-consistent / lips may drift`
+        message: `scene ${scene} is a single-on-camera-speaker talking head but its clip lacks native audio (generate_audio: true) \u2014 the lips would drift. Generate the clip with native audio, then route it to the mix via either the audio_voice_convert node (one brand voice) or directly (s${scene}_voextract \u2192 audio_mix)`
       });
     }
   }
@@ -2596,7 +2627,7 @@ var Engine = class {
     return { run_id: runId, output, outputs_by_node: outputs, stats, outputs_dir: writer.runDir };
   }
   async runLayers(canvas, outputs, runId, writer, opts, counters, nodeRuns) {
-    const layers = topologicalLayers(buildGraph(canvas));
+    const layers = topologicalLayers(this.pruneToOutput(canvas, buildGraph(canvas)));
     for (const layer of layers) {
       const tasks = layer.map(
         (nodeId) => this.executeOne(canvas, nodeId, outputs, runId, writer, opts).then((r) => {
@@ -2617,6 +2648,21 @@ var Engine = class {
       await Promise.all(tasks);
     }
   }
+  /**
+   * Dead-node elimination: when the canvas declares an `output`, execute only the
+   * nodes that output transitively depends on. Orphaned nodes (left by an edit or
+   * a rewire) otherwise still run, bill, and abort the run on their own failure.
+   * No declared output ⇒ intent is ambiguous, so run everything (back-compat).
+   */
+  pruneToOutput(canvas, graph) {
+    const rootId = canvas.output?.node;
+    if (!rootId || !graph.has(rootId)) return graph;
+    const keep = reachableNodes(graph, [rootId]);
+    if (keep.size === graph.size) return graph;
+    const dropped = [...graph.keys()].filter((id) => !keep.has(id));
+    this.log(`[prune   ] skipping ${dropped.length} node(s) unreachable from output: ${dropped.join(", ")}`);
+    return subgraph(graph, keep);
+  }
   async writeFinal(writer, output) {
     if (output === void 0) return;
     if (isAssetRefArray(output)) {
@@ -2984,6 +3030,27 @@ var FontRef = BaseAssetRef.extend({
 });
 var AssetRef = z4.discriminatedUnion("kind", [ImageRef, VideoRef, AudioRef, JsonRef, TextRef, FontRef]);
+// src/engine/nodes/remote/upload.ts
+async function presignAndPut(args) {
+  const { putUrl, publicUrl } = await args.ctx.client.presignAssetUpload(args.sha256, args.mime, args.ctx.signal);
+  const putRes = await fetch(putUrl, {
+    method: "PUT",
+    body: new Uint8Array(args.bytes),
+    headers: { "Content-Type": args.mime },
+    signal: args.ctx.signal
+  });
+  if (!putRes.ok) {
+    throw new Error(`upload: presigned PUT failed ${putRes.status} ${putRes.statusText}`);
+  }
+  return publicUrl;
+}
+async function ensureUploaded(ref, ctx) {
+  if (ref.url) return ref;
+  const bytes = await ctx.assets.readBytes(ref.sha256, ref.mime);
+  const url = await presignAndPut({ bytes, sha256: ref.sha256, mime: ref.mime, ctx });
+  return { ...ref, url };
+}
 // src/engine/nodes/remote/delegate.ts
 function delegated(spec) {
   return {
@@ -3003,7 +3070,7 @@ function delegated(spec) {
 }
 async function callBackendExec(args) {
   try {
-    const serialized = serializeInputs(args.inputs);
+    const serialized = await serializeInputs(args.inputs, args.ctx);
     const idempotencyKey = args.ctx.cacheKey ? `${args.ctx.canvasRunId}:${args.ctx.cacheKey}` : void 0;
     const res = await args.ctx.client.exec(
       {
@@ -3020,19 +3087,19 @@ async function callBackendExec(args) {
     throw mapClientError(args.ctx, e);
   }
 }
-function serializeInputs(inputs) {
+async function serializeInputs(inputs, ctx) {
   if (!inputs || typeof inputs !== "object") return {};
   const out = {};
   for (const [k, v] of Object.entries(inputs)) {
-    out[k] = stripLocalRefs(v);
+    out[k] = await stripLocalRefs(v, ctx);
   }
   return out;
 }
-function stripLocalRefs(value) {
-  if (Array.isArray(value)) return value.map(stripLocalRefs);
+async function stripLocalRefs(value, ctx) {
+  if (Array.isArray(value)) return Promise.all(value.map((v) => stripLocalRefs(v, ctx)));
   if (value && typeof value === "object") {
     if ("kind" in value && "sha256" in value && "mime" in value) {
-      const ref = value;
+      const ref = await ensureUploaded(value, ctx);
       return {
         kind: ref.kind,
         url: ref.url,
@@ -3042,7 +3109,7 @@ function stripLocalRefs(value) {
       };
     }
     const out = {};
-    for (const [k, v] of Object.entries(value)) out[k] = stripLocalRefs(v);
+    for (const [k, v] of Object.entries(value)) out[k] = await stripLocalRefs(v, ctx);
     return out;
   }
   return value;
@@ -3555,16 +3622,7 @@ function buildYtDlpMetadata(sourceUrl, info) {
 }
 async function uploadAndIngest(args) {
   const sha = sha256Hex(args.bytes);
-  const { putUrl, publicUrl } = await args.ctx.client.presignAssetUpload(sha, args.mime, args.ctx.signal);
-  const putRes = await fetch(putUrl, {
-    method: "PUT",
-    body: new Uint8Array(args.bytes),
-    headers: { "Content-Type": args.mime },
-    signal: args.ctx.signal
-  });
-  if (!putRes.ok) {
-    throw new Error(`ingest: presigned PUT failed ${putRes.status} ${putRes.statusText}`);
-  }
+  const publicUrl = await presignAndPut({ bytes: args.bytes, sha256: sha, mime: args.mime, ctx: args.ctx });
   const localRef = await args.ctx.assets.ingestBytes({
     bytes: args.bytes,
     kind: args.kind,
@@ -4412,7 +4470,15 @@ import { readFile as readFile7 } from "fs/promises";
 import path9 from "path";
 import { promisify as promisify3 } from "util";
 var execFileAsync = promisify3(execFile3);
-var NEVER_BLOCK = [/contrast/i, /\bwcag\b/i, /missing_local_asset/i, /font[_-]?family/i, /font[_-]?face/i];
+var NEVER_BLOCK = [
+  /contrast/i,
+  /\bwcag\b/i,
+  /missing_local_asset/i,
+  /font[_-]?family/i,
+  /font[_-]?face/i,
+  /transcript[_-]?not[_-]?inline/i,
+  /text[_-]?occluded/i
+];
 var UNAVAILABLE = /unknown command|command not found|not found|Did you mean|Unknown argument|ENOENT/i;
 function isAdvisory(code, message) {
   const hay = `${code} ${message}`;
@@ -4474,6 +4540,31 @@ function classifyCheckOutput(lintRaw, inspectRaw) {
 function buildLintArgs(dir) {
   return ["hyperframes", "lint", dir, "--json"];
 }
+function buildLintArgsNoInstall(dir) {
+  return ["--no-install", "hyperframes", "lint", dir, "--json"];
+}
+var VALIDATE_STRUCTURAL_CODES = /media_missing_data_start|timed_element_missing_clip_class/i;
+function filterStructuralFindings(findings) {
+  return findings.filter((f) => VALIDATE_STRUCTURAL_CODES.test(f.code));
+}
+var hyperframesAvailable = null;
+async function isHyperframesAvailable() {
+  if (hyperframesAvailable !== null) return hyperframesAvailable;
+  try {
+    await execFileAsync("hyperframes", ["--version"], { timeout: 1e4 });
+    hyperframesAvailable = true;
+  } catch {
+    hyperframesAvailable = false;
+  }
+  return hyperframesAvailable;
+}
+async function lintStructuralIssues(dir, timeoutMs) {
+  if (!await isHyperframesAvailable()) return [];
+  const lintRaw = await runOne(buildLintArgsNoInstall(dir), timeoutMs);
+  if (lintRaw === null) return [];
+  const findings = classifyLint(parseCheckJson(lintRaw)).map((f) => ({ code: f.code, message: f.message }));
+  return filterStructuralFindings(findings);
+}
 function buildInspectArgs(dir, samples) {
   return ["hyperframes", "inspect", dir, "--json", "--samples", String(samples)];
 }
@@ -4681,7 +4772,7 @@ var hyperframeRenderNode = defineNode({
   params: HyperframeParams,
   outputs: HyperframeOutputs,
   cost: () => ({ credits: 0, seconds_estimate: 30 }),
-  validateExtra: ({ rawParams }) => validateCompositionParams(rawParams),
+  validateExtra: ({ rawParams }) => validateComposition(rawParams),
   cacheKeyExtras: async ({ params }) => {
     const out = {};
     const composition = params.composition;
@@ -4734,6 +4825,21 @@ async function resolveCompositionDir(composition) {
   if (s.isDirectory()) return compositionPath;
   return path11.dirname(compositionPath);
 }
+async function validateComposition(rawParams) {
+  const issues = await validateCompositionParams(rawParams);
+  const composition = rawParams?.composition;
+  if (typeof composition !== "string") return issues;
+  const dir = await resolveCompositionDir(composition).catch(() => null);
+  if (!dir) return issues;
+  const structural = await lintStructuralIssues(dir, 2e4);
+  for (const s of structural) {
+    issues.push({
+      path: "params.composition",
+      message: `pre-render gate would fail: [${s.code}] ${s.message}`
+    });
+  }
+  return issues;
+}
 async function validateCompositionParams(rawParams) {
   const issues = [];
   if (!rawParams || typeof rawParams !== "object") return issues;
@@ -5735,7 +5841,7 @@ import { z as z29 } from "zod";
 var VIDEO_DECONSTRUCT_MODELS = ["~google/gemini-flash-latest", "~google/gemini-pro-latest"];
 var videoDeconstructNode = delegated({
   id: "video_deconstruct",
-  version: "1.3.0",
+  version: "1.4.0",
   category: "video",
   summary: 'Deconstruct a video into a replication-grade blueprint: scene boundaries, the real start/end frame of every scene (extracted from the video as images), and an exhaustive JSON analysis \u2014 per-scene action detail, camera motion, generation-ready frame/motion prompts, overlay text with full typographic style, floating elements, deeply detailed cast (perceived demographics, ethnicity/skin-tone, styling, market-recasting notes), brand-identified logos (named by brand and what they signal, not by appearance, with on-screen timestamps), dialogue with voice descriptions, music spec, SFX list, plus a word-level transcript. `mode:"index"` is the cheap structure-first pass: scene boundaries + global blueprint only (one LLM call, no frames).',
   when_to_use: 'Use to reverse-engineer a reference video (e.g. a competitor ad) so a new canvas can reproduce or remix it scene by scene. Agent loop: (1) optionally run `mode:"index"` to see the structure cheaply (scene count, boundaries, transcript) before planning; (2) run the full deconstruct; (3) read `analysis` and author the reproduction canvas. The blueprint maps 1:1 onto generation nodes: `analysis.scenes[i]` aligns positionally with `start_frames#i`/`end_frames#i`; per scene, `start_frame_prompt`/`end_frame_prompt` feed image_generate (overlay text is excluded from them by contract \u2014 recomposite it from `overlays`), `motion_prompt` + the two frames feed video_generate (first_frame/last_frame), `dialogue[].voice_description` casts tts/dialogue voices, `global.music.music_prompt` feeds music, `sfx[].sound_effect_prompt` feeds sound_effect, and `overlays`/`floating_elements` drive an ffmpeg/hyperframe overlay pass. Long videos (over ~8 min single-shot): run `mode:"index"` first, then several full nodes IN PARALLEL each with a `start_s`/`end_s` window (\u2264480s, snap edges to index scene boundaries), and merge by concatenating `analysis.scenes`; over-length errors include suggested windows. Inject fields into downstream prompts via `{{slot}}`. Pick `~google/gemini-pro-latest` for the densest extraction, `~google/gemini-flash-latest` for cheap/fast passes.',
@@ -6146,4 +6252,4 @@ export {
   defaultRegistry,
   createEngineFromEnv
 };
-//# sourceMappingURL=chunk-RCPMJKI7.js.map
+//# sourceMappingURL=chunk-3JVYU72O.js.map