@koda-sl/baker-cli 0.80.0 → 0.82.0

package/README.md

@@ -3263,6 +3263,8 @@ Reverse-engineer a video into a replication-grade blueprint: scene boundaries, t
 
 Over-length runs fail with a message that includes ready-to-use suggested windows, so the loop is self-correcting.
 
+> **Async execution.** Full-mode `video_deconstruct` is a multi-minute job, so the backend runs it as a durable background workflow rather than over a single long-lived HTTP request: the exec call returns immediately and the CLI transparently polls the job to completion. This is invisible to callers — the node's inputs, params, and outputs are unchanged — but it means a stalled provider can no longer drop the connection and cause a whole-node retry storm. (`mode:"index"` stays synchronous.)
+
 **Inputs**
 
 | Slot | Kind | Required | Accepted MIMEs |
@@ -3631,6 +3633,8 @@ It then scaffolds the full pipeline: per scene, two **static-ad-grade frames** (
 
 **Overlays are agent-painted HTML, not props.** The clips are concatenated, then the `video-overlay` composition (copied next to the canvas) composites the overlay layer. The scaffold **bakes the reference's overlays into that composition's `index.html` as real, editable HTML** (each overlay is a plain element with its text, a `.pos-*` position class, and `data-start`/`data-dur` timing); a tiny generic runtime only shows/hides each element at its timestamp (with an optional `data-anim` entrance). It makes **no styling decisions** — bars, tickers, colors, fonts, and a real logo `<img>` you drop into the dir all live in the HTML/CSS you edit. Floating elements (logo bugs) are seeded as commented `<img>` stubs so an un-edited render stays clean. Drop `brand-bold.otf`/`brand-regular.otf` for on-brand type.
 
+**Re-craft the script — the hook is the #1 decision.** A reproduction is *inspiration* from a proven ad, not a clone: its structure (hook → body → CTA) carries the persuasion, and the hook is *targeting*, so a competitor's hook often does **not** transfer. `metadata.todo.script_recraft` tags each scene with its `narrative_role` (from the deconstruct, else inferred) and carries the original line **flagged** so it is never shipped as-is — and the per-scene `recraft` instruction is **role-aware**: the **hook** scene's entry carries the diagnose → decide (keep/adapt/rebuild) → criteria (statement not question, benefit by ~2s, first frame legible **sound-off** in ~1s, no bait-and-switch) inline and routes to the skill's `references/hook-craft.md`. A dedicated top-level **`metadata.todo.hook`** key foregrounds it as the highest-leverage beat, mapped onto scene-0's artifacts (`s0_start` first frame, scene-0 overlay text, `s0_clip` line, micro-hook, hook-ramp).
+
 The emitted canvas is validated (`validateCanvasDeep`) before it's written, so it always runs. It also carries a **`metadata.video`** timing plan that `baker canvas validate` proves **statically, before any billed render**: no two voiceover turns overlap, the audio length ≈ the video length, and every single-on-camera-speaker scene is a native talking head (its clip carries `generate_audio` and is wired to an `audio_voice_convert` node). The full editable checklist is embedded as **`metadata.todo`** (with a step-by-step guide in `metadata.description`). stdout returns `{ ok, canvas_path, prompt_path, models, stats, checklist }`.
 
 ```bash

package/dist/{chunk-NBNUNCY7.js → chunk-KIL2ZJST.js}

@@ -770,13 +770,48 @@ function shouldRetry(err) {
 }
 
 // src/engine/client/backend-client.ts
+function isAsyncJob(res) {
+  return typeof res.job_id === "string";
+}
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var JOB_POLL_INTERVAL_MS = 3e3;
+var JOB_POLL_MAX_MS = 20 * 60 * 1e3;
 var BackendClient = class {
   http;
   constructor(opts) {
     this.http = new HttpClient(opts);
   }
-  exec(req, signal) {
-    return this.http.postJson("/api/canvas/nodes/exec", req, signal);
+  async exec(req, signal) {
+    const res = await this.http.postJson("/api/canvas/nodes/exec", req, signal);
+    if (isAsyncJob(res)) {
+      return await this.pollJob(res.job_id, signal);
+    }
+    return res;
+  }
+  async pollJob(jobId, signal) {
+    const deadline = Date.now() + JOB_POLL_MAX_MS;
+    const path16 = `/api/canvas/jobs/${encodeURIComponent(jobId)}`;
+    while (true) {
+      if (signal?.aborted) {
+        throw new BackendHttpError({ kind: "network", cause: signal.reason ?? new Error("aborted") });
+      }
+      const job = await this.http.getJson(path16, signal);
+      if (job.status === "completed") return job.result;
+      if (job.status === "failed") {
+        throw new BackendHttpError({
+          kind: "provider",
+          status: job.error.status ?? 502,
+          provider: job.error.provider,
+          code: job.error.code ?? "provider_error",
+          message: job.error.message ?? "deconstruct failed",
+          retryable: job.error.retryable ?? false
+        });
+      }
+      if (Date.now() > deadline) {
+        throw new BackendHttpError({ kind: "timeout", message: `job ${jobId} did not finish in time` });
+      }
+      await sleep(JOB_POLL_INTERVAL_MS);
+    }
   }
   presignAssetUpload(sha256, mime, signal) {
     return this.http.postJson(
@@ -5970,4 +6005,4 @@ export {
   defaultRegistry,
   createEngineFromEnv
 };
-//# sourceMappingURL=chunk-NBNUNCY7.js.map
+//# sourceMappingURL=chunk-KIL2ZJST.js.map