@koda-sl/baker-cli 0.123.0-dev.70bf43ce4 → 0.123.0-dev.8e4328629

package/README.md

@@ -1142,7 +1142,7 @@ Notes:
 - All write commands take `--file <json>` payloads; explicit flags override file keys. `baker schema ads.linkedin.campaigns.create` for exact args.
 - Money flags (`--bid`, `--daily-budget`, `--total-budget`) require `--currency`.
 - Creative media comes from the Baker library (`--image-id`/`--video-id` from `baker images`/`baker videos` — uploaded to LinkedIn at publish) or as LinkedIn URNs (`--image-urn`/`--video-urn`). Formats: `image|video|text|spotlight|follower|document|carousel|conversation|tla|jobs`; complex formats take `--file` with the full content object; conversation ads take `--file` with the message flow (`{message: {subject, body, senderName?, buttons[]}}` — buttons `NESTED` (with `nestedMessage`) or `LANDING_PAGE` (with `landingPageUrl`), ≤25 messages, bodies ≤500 chars, labels ≤25). Limits: headline ≤70, text-ad 25/75, intro soft-truncates at 600 chars. TLA sponsors an existing post via `--post-urn`.
-- Lead forms are file-first (`lead-forms create --file form.json`). Required: name, headline (≤60), privacyPolicyUrl, questions[] (≤12; playbook: ≤4 for completion). Each question is a predefined profile field (`{ name, predefinedField: "EMAIL" }` — Contact/Work/Company/Education/Demographic library) or a custom question (`{ name, questionType: "SINGLE_LINE_TEXT" | "MULTIPLE_CHOICE", options?: [...] }`; ≤3 custom, MULTIPLE_CHOICE needs 2–30 options). Also supported: `locale {country,language}`, `formImageId`/`formImageUrn` (banner), `privacyPolicyText`, `consents[]` (≤5 disclosure checkboxes `{text, required}`), `hiddenFields[]` (≤20 `{name, value}` tracking fields), `legalDisclaimer`, `thankYou {message, cta, landingUrl | appointmentUrl}` (Calendly/Chili Piper booking link). The staged preview emits non-blocking best-practice warnings when a form has no qualifying question, no confirmation message/action, or no consent checkbox.
+- Lead forms are file-first (`lead-forms create --file form.json`). Required: name, headline (≤60), privacyPolicyUrl, questions[] (≤12; playbook: ≤4 for completion). Each question is a predefined profile field (`{ name, predefinedField: "EMAIL" }` — Contact/Work/Company/Education/Demographic library) or a custom question (`{ name, questionType: "SINGLE_LINE_TEXT" | "MULTIPLE_CHOICE", options?: [...] }`; ≤3 custom, MULTIPLE_CHOICE needs 2–30 options). Also supported: `locale {country,language}`, `formImageId`/`formImageUrn` (banner), `consents[]` (≤5 disclosure checkboxes `{text, required}`), `hiddenFields[]` (≤20 `{name, value}` tracking fields), `legalDisclaimer`, `thankYou {message, cta, landingUrl | appointmentUrl}` (Calendly/Chili Piper booking link). The staged preview emits non-blocking best-practice warnings when a form has no qualifying question, no confirmation message/action, or no consent checkbox.
 
 #### `audit` — playbook diagnostic
 
@@ -2672,6 +2672,18 @@ baker canvas run my-canvas.json --parallel 8
 #     browsable outputs — pass --no-record too if you want nothing persisted.
 baker canvas run my-canvas.json --remote-cache off --no-record
 
+# 2d. Regenerate a node whose prompt is fine (force a fresh roll). The engine is
+#     content-addressed: re-running an UNCHANGED node returns the identical cached
+#     render, never a new draw. To re-roll a node without editing its prompt (a
+#     color drifted, a face came out wrong), force it fresh two ways — NEVER
+#     restructure the canvas (repointing output / deleting nodes) to trick the cache:
+#       • One-shot flag — forces the named nodes + everything downstream fresh this
+#         run, leaving every other node cached (unknown ids fail loudly before billing):
+baker canvas run my-canvas.json --regenerate gen_4x5,gen_9x16
+#       • Persistent — add/bump a node's `regenerate` field in the canvas JSON
+#         (e.g. "regenerate": 2) and re-run; the fresh render is reproducible in any
+#         later session. Bump it again (3, 4, …) for each additional draw.
+
 # 3. Inspect a finished run (per-node timing, file list, optional video thumbs)
 baker canvas inspect <run_id>
 
@@ -3366,9 +3378,9 @@ Accepted ref-image MIMEs vary by model — see per-model sections below.
 
 ###### Model: `bytedance/seedance-2.0`
 
-Production-quality ad-creative model. Routed via **fal.ai** (not OpenRouter) because OpenRouter's Seedance passthrough rejects photorealistic human reference frames via ByteDance's "real person" safety filter.
+Production-quality ad-creative model. Routed via **Replicate** (`bytedance/seedance-2.0`). NOTE: ByteDance's upstream "real person" likeness filter still blocks photorealistic human reference frames on **any** reseller — the escape is a synthetic/AI presenter face or routing real faces to Veo, not the provider.
 
-Ref-image MIMEs: `image/png`, `image/jpeg`, `image/webp` (via fal.ai).
+Ref-image MIMEs: `image/png`, `image/jpeg`, `image/webp`.
 
 | Name | Type | Required | Notes |
 |---|---|---|---|
@@ -3422,7 +3434,7 @@ Ref-image MIMEs: `image/png`, `image/jpeg`, `image/webp`, `image/gif` (via OpenR
 >
 > A scaffolded canvas carries this table inline at `metadata.todo.model_constraints`.
 
-> **Content-policy blocks are deterministic, not flaky.** fal.ai/Seedance rejects any first/last frame that reads as a real-person likeness (even an AI-generated face) — surfaced as `content_policy_blocked` (HTTP 422, **non-retryable**), even when fal's proxy chain masks it as a 5xx. Retrying **never** succeeds and wastes credits. Fix the cause: switch the clip to the other curated model (Veo routes around fal's filter), or make the source frame less photorealistic.
+> **Content-policy blocks are deterministic, not flaky.** ByteDance's Seedance rejects any first/last frame that reads as a real-person likeness (even an AI-generated face) — surfaced as `content_policy_blocked` (HTTP 422, **non-retryable**). This is ByteDance's upstream filter, so it fires on **any** reseller (Replicate or otherwise) — a provider swap does **not** route around it. Retrying **never** succeeds and wastes credits. Fix the cause: use a **synthetic/AI-generated** (non-identifiable) presenter face, or route a real face to **Veo** (`person_generation: allow_adult`), or make the source frame less photorealistic.
 
 ---
 
@@ -3473,7 +3485,7 @@ None.
 
 ##### `video_lipsync`
 
-Lip-sync a video to an audio track via VEED (fal.ai).
+Lip-sync a video to an audio track via Sync Labs `sync/lipsync-2` (Replicate).
 
 **Inputs**
 
@@ -3500,7 +3512,7 @@ Lip-sync a video to an audio track via VEED (fal.ai).
 
 ##### `video_background_remove`
 
-Strip a video's background → alpha WebM/H264. Powered by fal.ai VEED.
+Strip a video's background → transparent alpha WebM (VP9) or MOV (ProRes 4444). Powered by `sprited/birefnet-video` (Replicate).
 
 **Inputs**
 
@@ -3676,7 +3688,7 @@ Place and mix several audio clips onto one timeline — a music bed plus timed v
 
 ##### `image_background_remove`
 
-Strip background → transparent PNG (or mask). Powered by fal.ai BiRefNet v2.
+Strip background → transparent PNG. Powered by `men1scus/birefnet` (Replicate). (Note: mask-only output is no longer produced.)
 
 **Inputs**
 
@@ -3927,20 +3939,20 @@ Validate, then execute the graph. Blocks until done. Logs one line per node. Ret
 
 #### `baker canvas scaffold-video <video> [flags]`
 
-Turn a reference video into a **runnable, self-validated reproduction canvas** in one command — the video counterpart of `scaffold-static-ad`. It runs **billed passes** up front:
+Turn a reference video into a **runnable, self-validated reproduction canvas** in one command — the video counterpart of `scaffold-static-ad`. The `<video>` positional is a **local path OR an http(s) URL** (a `baker winning-ads` `media_url`, a library URL, any reel link) — a URL is downloaded for you (no manual `curl` first), so pass `--slug`/`--out` with it to give the canvas a home. It runs **billed passes** up front:
 
-1. **`video_deconstruct`** (`~google/gemini-pro-latest`, full mode) — reverse-engineers the video into a scene-by-scene blueprint + word-level transcript, written next to the canvas as **`prompt.json`**. Each scene's `start_frame_prompt`/`end_frame_prompt` are inlined into the frame nodes (see below); `prompt.json` then rides along as the shared **global style reference** (palette, cast cohesion) and as provenance.
+1. **`video_deconstruct`** (`~google/gemini-pro-latest`, full mode) — reverse-engineers the video into a scene-by-scene blueprint + word-level transcript, written next to the canvas as **`prompt.json`** (the human-editable source of truth). Each scene's `start_frame_prompt`/`end_frame_prompt` are inlined into the frame nodes (see below); the shared **global style reference** every frame reads via `target_blueprint` is a **slim projection** written alongside as **`prompt.style.json`** (`global` cast/palette/brand + `reference_elements` only, no per-scene array). A 33-scene blueprint is ~200 KB — inlining it into every one of a dozen frame prompts was pure waste and let a frame blend in another scene's content; the slim is ~5 KB. Edit `prompt.json` and re-scaffold to refresh the style projection.
 2. **recurring-element selection** (`~google/gemini-flash-latest`) — picks only the **recurring, identity-critical** elements (each `global.cast` person, a recurring animal, a showcased product, the brand logo) and the scene indices each appears in. One real reference image grounds each element across **every** frame it appears in, so the same actor stays consistent the whole video. This selection runs as a **second pass over a slimmed blueprint** (cast/branding + each scene's frame prompts only) — a long ad's full blueprint can exceed the engine's inline-prompt limit, so the heavy per-scene detail (dialogue, overlays, transcript) the selector never reads is dropped before the prompt.
 
 Before the deconstruct it runs a **local shot-cut pass** on the source file with **[PySceneDetect](https://www.scenedetect.com)** (`scenedetect` CLI, `detect-content` — the battle-tested HSV content detector, installed in the canvas sandbox) and passes the cut timestamps as `video_deconstruct`'s `shot_cuts`. The deconstruct snaps its scene boundaries onto those real cuts and **splits any scene that spans one**, so a scene's frames can never straddle a hard cut (the failure where a scene's start frame was the couch and its end frame the b-roll). Two knobs tuned for fast social ads: the content **threshold defaults to 18** (PySceneDetect's own default of 27 misses soft reframes) and the **minimum scene length is dropped to 0.25s** (its default ~0.6s merges away rapid montage flashes) — so super-fast cuts survive and become cheap still-holds downstream. The threshold is **adaptive**: if the first pass looks like a continuous shot shredded into many close micro-cuts (a talking-head selfie's natural motion), it re-runs at PySceneDetect's own default of 27 and **merges the two passes** — the high-threshold set is the base, and the low pass's *isolated* extras (real soft blur-morph transitions that vanish at 27) are added back while clustered extras (motion shred) stay dropped. Pinning **`--shot-threshold N`** disables the re-check (lower = more cuts). The backend snap window is likewise **adaptive** (up to 1s onto an unambiguous nearest cut, shrinking around dense cut pairs so a boundary never jumps past the wrong cut), any scene spanning an interior cut is split, and the residual-sliver coalesce is **cut-aware**: a drift sliver folds backward across its non-cut edge and never re-merges across a real cut. If `scenedetect` is unavailable it warns loudly and degrades to LLM-only boundaries.
 
 A shot longer than the video model's per-clip ceiling (Seedance's 15s, passed as `video_deconstruct`'s `max_clip_s`) is split into equal **continuation sub-scenes** that share their splice boundary exactly — so a long shot is reproduced in **full** (no truncation) and joins seamlessly. Each sub-scene carries `continues_previous`.
 
-It then scaffolds the full pipeline like an **editing timeline**: each clip gets a **static-ad-grade start AND end keyframe** (`image_generate`, each with its **own self-contained `params.prompt`** — edit a frame node to change only that frame; `prompt.json` wired as the **authoritative shared `target_blueprint`**, plus a per-element reference legend). Each keyframe is **fully recast** to the dropped `el_*` reference images. The original extracted frame is kept LAST as a **pure composition anchor** (framing / camera angle / shot size / pose) whenever identity is safely locked — i.e. a frame with no person/animal, OR every cast member present is **sheet-backed** (a multi-view turnaround owns identity, so the anchor can reproduce the source's framing without dictating the face). Since every base element is now sheet-backed by default, cast frames keep their framing anchor too — this is what reproduces the source's composition (a side-profile stays a side-profile, the camera angle holds scene to scene) instead of drifting to a fresh guess. The anchor's legend forbids taking identity/text/palette from it. It is dropped only when a cast member rests on a weak lone-snapshot reference (e.g. a `same_as` second-look slot), where the original frame could re-leak the source actor. Both keyframes feed `video_generate` (`first_frame`+`last_frame`, so Seedance interpolates real in-shot motion; ultra-detailed motion brief; duration snapped to the nearest allowed clip length). Every keyframe grounds **only on its own extracted frame + `el_*` slots** — no reference to any other generated frame — so all images render **in parallel** (no cascade). Source-frame URLs are **deduped** (each ingested once). `--frames reuse` wires the real source frame straight in.
+It then scaffolds the full pipeline like an **editing timeline**: each clip gets a **static-ad-grade start AND end keyframe** (`image_generate`, each with its **own self-contained `params.prompt`** — edit a frame node to change only that frame; the slim `prompt.style.json` wired as the **shared `target_blueprint`** style reference, plus a per-element reference legend). Each keyframe is **fully recast** to the dropped `el_*` reference images. The original extracted frame is kept LAST as a **pure composition anchor** (framing / camera angle / shot size / pose) whenever identity is safely locked — i.e. a frame with no person/animal, OR every cast member present is **sheet-backed** (a multi-view turnaround owns identity, so the anchor can reproduce the source's framing without dictating the face). Since every base element is now sheet-backed by default, cast frames keep their framing anchor too — this is what reproduces the source's composition (a side-profile stays a side-profile, the camera angle holds scene to scene) instead of drifting to a fresh guess. The anchor's legend forbids taking identity/text/palette from it. It is dropped only when a cast member rests on a weak lone-snapshot reference (e.g. a `same_as` second-look slot), where the original frame could re-leak the source actor. Both keyframes feed `video_generate` (`first_frame`+`last_frame`, so Seedance interpolates real in-shot motion; ultra-detailed motion brief; duration snapped to the nearest allowed clip length). Every keyframe grounds **only on its own extracted frame + `el_*` slots** — no reference to any other generated frame — so all images render **in parallel** (no cascade). Source-frame URLs are **deduped** (each ingested once). `--frames reuse` wires the real source frame straight in.
 
 **Composited scenes (split-screen / picture-in-picture / keyed presenter).** Real ads aren't always one full-frame shot — a frame can be **persistently divided** (b-roll on top, a presenter talking on the bottom) or **layer a presenter** over background footage (boxed in a corner, or green-screen keyed). The deconstruct now reports this per scene as `scene.composition` (`layout: split_screen | pip | keyed_overlay`, with one `region` per stream — each its own clean-plate frame + motion brief, the talking-head region flagged `is_presenter`). The scaffold reproduces a composited scene by building **one clip per region** (`s<i>_r0_*`, `s<i>_r1_*`, …) and compositing them with ffmpeg: a split-screen `vstack`/`hstack` (stack direction read from the region **panels**, so a top/bottom split always stacks vertically), or a picture-in-picture `overlay` of the presenter inset at its corner. A **keyed** presenter is first cut to transparency by `video_background_remove` (`s<i>_key`), then overlaid. The presenter region carries the native lip-synced voice; b-roll/render panels stay silent. To change a layout, edit `composition` in `prompt.json` and re-scaffold, or hand-edit the `s<i>_composite` ffmpeg args. Plain full-frame scenes (the default) are unaffected.
 
-**Typed region kinds & real screen surfaces.** Each composition region now carries a `kind` — `camera` (filmed footage, re-generated), `screen_capture` (app/site/document screen recording), `static_graphic` (designed text/graphic panel), or `generated` (3D/motion graphics) — plus an optional `nested` list for video-in-video (a Loom-style camera bubble inside a screen share). `kind` is authoritative for routing (prose keywords remain the fallback for older blueprints): `screen_capture`/`static_graphic` regions are **never generated by the video model** — the scene renders as a clean background plate (its clip prompt is scrubbed of all screen narration and forbids rendering UI) and the real surface is composited on the overlay layer. The route is decided **once per persistent layout run** (consecutive scenes sharing one composition signature), so a layout that runs unbroken across many scenes can't flip between pipelines on wording differences. A persistent surface seeds **ONE grouped stub** in `video-overlay-composition/index.html` spanning its whole window, with a per-scene **state timeline** — build one continuous screen recording/mockup, not one screenshot per scene. A `screen_capture` region also carries `surface_id`: a source video routinely **splices two unrelated screen recordings** under one persistent layout (a live app-processing capture, then an unrelated pre-made demo note) — the deconstruct assigns a stable id while the SAME recording continues and a new one when the on-screen content genuinely changes, so the run splits into **separate stubs** at the splice instead of asking for one screenshot that can't cover both. `baker canvas validate` additionally warns (`VIDEO_UI_IN_PROMPT`) if any clip prompt still narrates a screen surface, and (`VIDEO_BRANDMARK_IN_PROMPT`) if a generate prompt asks the model to paint a brand logo/wordmark (generation garbles marks; source the real one with `baker images logo` and composite it on the overlay layer).
+**Typed region kinds & real screen surfaces.** Each composition region now carries a `kind` — `camera` (filmed footage, re-generated), `screen_capture` (app/site/document screen recording), `static_graphic` (designed text/graphic panel), or `generated` (3D/motion graphics) — plus an optional `nested` list for video-in-video (a Loom-style camera bubble inside a screen share). `kind` is authoritative for routing (prose keywords remain the fallback for older blueprints): `screen_capture`/`static_graphic` regions are **never generated by the video model** — the scene renders as a clean background plate (its clip prompt is scrubbed of all screen narration and forbids rendering UI) and the real surface is composited on the overlay layer. The route is decided **once per persistent layout run** (consecutive scenes sharing one composition signature), so a layout that runs unbroken across many scenes can't flip between pipelines on wording differences. A persistent surface seeds **ONE grouped stub** in `video-overlay-composition/index.html` spanning its whole window, with a per-scene **state timeline** — build one continuous screen recording/mockup, not one screenshot per scene. A `screen_capture` region also carries `surface_id`: a source video routinely **splices two unrelated screen recordings** under one persistent layout (a live app-processing capture, then an unrelated pre-made demo note) — the deconstruct assigns a stable id while the SAME recording continues and a new one when the on-screen content genuinely changes, so the run splits into **separate stubs** at the splice instead of asking for one screenshot that can't cover both. Full-frame screen scenes reuse the same `surface_id`: consecutive full-frame UI beats of one screen (e.g. a 3-scene import flow) share **ONE `s<i>_screen_ref` ingest** — the operator supplies that screenshot once instead of dropping the same capture into a dozen identical `[TODO]`s (distinct surfaces stay distinct). `baker canvas validate` additionally warns (`VIDEO_UI_IN_PROMPT`) if any clip prompt still narrates a screen surface, and (`VIDEO_BRANDMARK_IN_PROMPT`) if a generate prompt asks the model to paint a brand logo/wordmark (generation garbles marks; source the real one with `baker images logo` and composite it on the overlay layer).
 
 **Designed graphics are rebuilt, not generated.** A `static_graphic` surface (a newspaper-collage panel, a meme card, a marketing composition) seeds a **GRAPHIC PANEL** stub — rebuild it as brand HTML or drop the design asset; it never gets the "screenshot the live page" instruction (there is no live page). A **full-frame** designed-graphic scene (the deconstruct emits one full-frame `static_graphic` region for meme/collage/motion-graphic beats) routes to a real design plate the same way screens do — no `image_generate`/`video_generate` — and dialogue over an all-graphic scene is voiceover by definition (nobody is on screen to lip-sync). A region typed `generated` whose own prose reads like a UI/designed panel is treated as a surface candidate too (the frame-grounded continuity checker delivers the verdict and corrects the kind), so one mistyped kind can't re-open the Seedance-paints-UI hole. Floating FX elements (hearts, sparkles, badges) ride the overlay layer: their narration is **scrubbed from clip briefs** and a categorical no-decorations directive is added, so the model can't bake a second, uneditable copy under the real composited one.
 
@@ -3952,13 +3964,13 @@ It then scaffolds the full pipeline like an **editing timeline**: each clip gets
 
 **Montage flashes held as stills — unless the picture really moves.** A rapid-cut beat shorter than ~2s with no spoken line is a **flash** — Seedance's shortest clip is 4s, so generating one (then trimming away most of it) burns credits for motion no viewer perceives. The scaffold instead **holds one keyframe as a still** for the scene length (a cheap ffmpeg loop, no billed `video_generate`), same look at a fraction of the cost. The deconstruct now stamps each scene's **`motion_level`** (`static` / `subtle` / `dynamic`): a **dynamic** flash (pouring chocolate, hands working, walking) keeps a **real trimmed clip** — freezing a moving montage turns it into a slideshow — while genuinely static beats (a logo card, a pinned photo, a product still) keep the cheap hold. Talking/ambient beats always keep a real clip (they need motion + native audio). The deconstruct also stamps each dialogue line's **`on_camera`** flag — a voice playing over b-roll, a graphic, or a mere *photo* of the speaker stays voiceover, so the scaffold never lip-syncs a scene with no speaking face (the polaroid close-up failure).
 
-**The phrase model (voice cut at pauses, not at visual cuts).** The voice is grouped into **phrases** — runs of continuous speech with no real pause, which may span several visual scenes. A phrase is voiced ONCE (so a sentence the deconstruct split at a visual cut never breaks mid-word): if the speaker is **shown** anywhere in the phrase it's a single Seedance clip (`s<anchor>_clip`, native lip-sync + audio) re-voiced to the brand voice; if the speaker is **never shown** it's one ElevenLabs `tts` read. The picture is then assembled **scene by scene**: a scene that shows the speaker **slices its window** out of the phrase clip (`s<i>_seg`, an ffmpeg `-ss`/`-t` cut — video and audio come from the *same* clip, so lip-sync holds), and a **b-roll cutaway** gets its own silent clip while the phrase's voice plays underneath. "Shown" is decided by the **presenter element's per-scene presence**, not just who's speaking — a scene where a cast member narrates over b-roll (their element absent) is treated as a cutaway, so the talking head never appears where the original cut away. A presenter run longer than the **gateway-safe ~10s clip ceiling splits at a scene boundary** into contiguous takes (each its own clip + convert), so a sliced window never reads past its clip. (Seedance's *API* max is 15s, but the generation gateway frequently times out — **HTTP 524** — before it can deliver a clip longer than ~10s, so the scaffold never asks for one that long; 10s is a Seedance-allowed duration, so the split clip still snaps cleanly.) A b-roll cutaway *inside* a phrase lands at an **approximate** time (Seedance exposes no word timing) — nudge the scene boundary if it's off its beat.
+**One clip per shot — separated at complete breaks.** A video is a sequence of clear **shots** with **complete breaks** (hard cuts) between them, and that is what the scaffold separates by: **two adjacent presenter shots at a hard cut become TWO clips**, never glued into one invented take just because the speech runs continuously across the cut. Each presenter shot is one Seedance clip (`s<anchor>_clip`, native lip-sync + audio) re-voiced to the brand voice. What is **NOT** split: a **voiceover** narration stays ONE ElevenLabs `tts` read across the b-roll it plays over, and a **b-roll cutaway** between two on-camera moments leaves the presenter shot continuous — the shown scenes aren't adjacent (the insert sits between them), so the clip covers both on-camera windows (sliced as `s<i>_seg`, an ffmpeg `-ss`/`-t` cut — video+audio from the *same* clip so lip-sync holds) while the cutaway plays its own silent clip over the continuing voice. "Shown" is decided by the **presenter element's per-scene presence**, not just who's speaking — a scene where a cast member narrates over b-roll (their element absent) is a cutaway, so the talking head never appears where the original cut away. A single shot longer than the **gateway-safe ~10s clip ceiling** (Seedance's *API* max is 15s, but the gateway often times out — **HTTP 524** — past ~10s) **splits into contiguous takes joined by a shared boundary frame**; the spine then **seam-dedups** that duplicated frame so the concat doesn't freeze on it (`--seam-dedup head|tail|off`, default `head` = drop the second clip's first frame). Timbre stays consistent across all the separate shot clips because every clip's native audio is re-voiced in **one merged per-speaker pass** (not per clip). A b-roll cutaway *inside* a phrase lands at an **approximate** time (Seedance exposes no word timing) — nudge the scene boundary if it's off its beat.
 
 **A starting point, not a locked render.** The canvas mirrors the reference's structure to give you a faithful scaffold, but `metadata.todo.full_flexibility` makes explicit that the agent has **full editing freedom**: add / delete / reorder / split / merge scenes, re-prompt any frame or motion brief, change a scene's layout (full-frame ↔ composite), or rewrite any line — the content-addressed cache re-bills only what changes, and `baker canvas validate` re-checks timing/lip-sync after any edit.
 
 **Sequenced audio.** Dialogue is a back-and-forth on one absolute timeline, so each **contiguous same-speaker turn** becomes its own `tts` placed at its real `start_s` — turns alternate and never stack (the earlier design concatenated each speaker's whole monologue at their earliest timestamp, so two voices played in parallel for the entire video). Each speaker is locked to one shared `voice_select` voice; a `sound_effect` per SFX and a `music` bed (conditioned on the **ad's own script + emotional arc** so the bed supports the message, styled after the AudD-identified track when available, ducked under the voices, and started at the reference's `music.starts_at_s` rather than always at 0) round out the mix (`audio_timeline`). The final mux normalizes the soundtrack to **−14 LUFS (stereo)** so the output plays loud in every player — the raw mix is quiet mono, which reads as "no sound."
 
-**Native talking heads + one voice per person (no post-hoc lip-sync).** Seedance 2.0 generates lip-synced speech **natively** — a presenter phrase puts the full phrase in the clip's prompt with `generate_audio`, so lips and voice are generated together (no `video_lipsync`/veed). Each presenter phrase's audio is extracted and re-voiced through a **per-phrase** `audio_voice_convert` (ElevenLabs Voice Changer; one per phrase keeps each ≤15s clip under the converter's length cap) to the brand voice — timing preserved so the lips stay matched. There is **ONE voice per person**: a single `voice_select` is reused for all that person's phrases, and the deconstruct's `voiceover` label folds into the sole on-camera presenter (so on-camera and off-camera narration are the same voice, not two). A scene with **two speakers both on screen** can't be one clip — both lines become `tts` over a plain scene clip. But a scene with **one on-camera speaker trading lines with an OFF-camera voice** (an interviewer, a heard-but-not-shown assistant) keeps the on-camera speaker **native** (lip-synced) and reads the off-camera line as `tts` — "on screen" is decided by the speaker's element presence, so a heard-but-unshown voice no longer drops the whole scene to a silent clip. Every `tts` node is stamped with the spoken track's **`language_code`** when the blueprint states a language (cast localization note / voiceover persona / voice description), so numbers and units are read in the target tongue instead of ElevenLabs' English default (the "6900 read in English" bug). For **NATIVE (Seedance) lines** — which carry no language tag — the scaffold additionally **spells numerals into target-language words** across every part of the clip prompt Seedance can vocalize (the spoken line, the scene summary/action/motion, the transcript), so a French "6930 ?" becomes "six mille neuf cent trente ?" and is never read as English digits. Spelling covers **every language the blueprint can resolve** (fr, es, en, de, it, pt, nl, pl, ar, ja, ko, hi — via `n2words`); a language outside that set leaves digits (the `tts` path still localizes them via `language_code`).
+**Native talking heads + one voice per person (no post-hoc lip-sync).** Seedance 2.0 generates lip-synced speech **natively** — a presenter phrase puts the full phrase in the clip's prompt with `generate_audio`, so lips and voice are generated together (no `video_lipsync`/veed). Each presenter phrase's audio is extracted (the spoken window only) and the extracts are merged **per speaker** onto one timeline, then re-voiced through a **single** `audio_voice_convert` (`<voice>_conv`, ElevenLabs Voice Changer) to the brand voice — one STS pass over the whole track instead of a convert node per clip, so it's fewer nodes, fewer calls, and a more consistent brand timbre (composite scenes already share this path); timing is preserved so the lips stay matched. There is **ONE voice per person**: a single `voice_select` is reused for all that person's phrases, and the deconstruct's `voiceover` label folds into the sole on-camera presenter (so on-camera and off-camera narration are the same voice, not two). A scene with **two speakers both on screen** can't be one clip — both lines become `tts` over a plain scene clip. But a scene with **one on-camera speaker trading lines with an OFF-camera voice** (an interviewer, a heard-but-not-shown assistant) keeps the on-camera speaker **native** (lip-synced) and reads the off-camera line as `tts` — "on screen" is decided by the speaker's element presence, so a heard-but-unshown voice no longer drops the whole scene to a silent clip. Every `tts` node is stamped with the spoken track's **`language_code`** when the blueprint states a language (cast localization note / voiceover persona / voice description), so numbers and units are read in the target tongue instead of ElevenLabs' English default (the "6900 read in English" bug). For **NATIVE (Seedance) lines** — which carry no language tag — the scaffold additionally **spells numerals into target-language words** across every part of the clip prompt Seedance can vocalize (the spoken line, the scene summary/action/motion, the transcript), so a French "6930 ?" becomes "six mille neuf cent trente ?" and is never read as English digits. Spelling covers **every language the blueprint can resolve** (fr, es, en, de, it, pt, nl, pl, ar, ja, ko, hi — via `n2words`); a language outside that set leaves digits (the `tts` path still localizes them via `language_code`).
 
 **Same-shot lip-sync caution.** A single held shot can carry only ONE lip-synced clip (voiceover turns must not overlap, and Seedance generates one clip per shot), so when the on-camera speaker has further turns in that shot (a rapid "3000? … 4000?" with an off-camera "Plus" between), the first turn is native and the rest play as `tts` over the same clip — where the mouth no longer matches those words. This is inherent to reproducing sparse same-shot dialogue, not a wiring fault; the scaffold lists the affected scenes/lines in **`metadata.video.lip_sync_caution`** (advisory, never gated) so you can cut away to b-roll over those lines or rely on the burned-in captions that already show them.
 
@@ -3974,7 +3986,9 @@ It then scaffolds the full pipeline like an **editing timeline**: each clip gets
 
 **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, 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), **no re-crafted line physically overruns its clip** (`VIDEO_SPEECH_OVERRUN` — est. speech > ~1.6× the clip duration fails validate, since Seedance crams or dies on it), and **every clip agrees on one aspect ratio** (`VIDEO_ASPECT_MISMATCH`). 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 }`.
+**The inspiration video is preserved.** Like `scaffold-static-ad` keeps its reference image, the video command now auto-writes a **`_definition.md`** (so the creative joins the `creatives` collection) recording the source it was built from: `sourceKind: video`, `sourceAdvertiser` (the brand the deconstruct identified, or `--advertiser`), `platform` (`--platform`, default `meta`), and **`sourceReferenceUrl`** — the **durable, content-addressed R2 URL** the deconstruct already uploaded the source to (`prompt.json`'s `source.url`), which the dashboard's Inspiration card plays inline. Unlike the static flow it does **not** commit the video into `references/`: a reference clip can be up to 2 GiB and the video canvas never re-ingests the source at run time (it uses the extracted frame URLs), so a git copy would be pure bloat — the durable R2 URL is the reference. The `_definition.md` is preserved on re-scaffold, and the same `sourceReferenceUrl` is synced to the backend so the creative shows "built from this ad."
+
+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, 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), **no re-crafted line physically overruns its clip** (`VIDEO_SPEECH_OVERRUN` — est. speech > ~1.6× the clip duration fails validate, since Seedance crams or dies on it), and **every clip agrees on one aspect ratio** (`VIDEO_ASPECT_MISMATCH`). When a **photoreal on-camera cast** generates on **Seedance**, the checklist carries a **`content_policy_risk`** note: ByteDance's real-person-likeness filter can reject a photoreal AI face with a **non-retryable 422** (`content_policy_blocked`) that **no prompt reframe clears** — the escapes are regenerating on Veo (`--video-model google/veo-3.1-fast`) or a less-photoreal frame. Surfaced before the billed run so a face-heavy ad isn't discovered broken mid-render. 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
 baker canvas scaffold-video ./reference-ad.mp4 --focus "competitor UGC ad for <brand>"
@@ -3990,6 +4004,7 @@ baker canvas run ./reference-ad.video.canvas.json
 | `--slug <slug>` | — | Creative slug (lowercase kebab): writes the canvas to `src/creatives/<slug>/<slug>.canvas.json` — the repo convention that attaches every run to the creative's dashboard generation history. `--out` wins over `--slug`. |
 | `--frames <mode>` | `generate` | `generate` emits ONE recast keyframe per scene (the original frame is dropped so the dropped `el_*` assets drive identity); `reuse` wires the real extracted first+last frames straight into the clips (faithful, cheaper, no recast). |
 | `--ambient` | off | Give silent **b-roll** scenes native diegetic ambient (Seedance `generate_audio`), mixed deep under the music bed. Talking scenes already carry voice; check levels don't muddy the mix before keeping it. |
+| `--seam-dedup <mode>` | `head` | How to dedup the boundary frame two clips SHARE when a long shot is split for length (the second clip's first frame IS the first clip's last frame, so a plain concat freezes on it for a frame). `head` drops the second clip's first frame, `tail` drops the first clip's last frame, `off` keeps both. Only touches shared-frame continuation joins — a hard cut between two shots shares no frame. |
 | `--max-scenes <n>` | all source scenes | **Cost lever that reduces fidelity** — caps the deconstruct, MERGING away every scene beyond the cap (fewer cuts, lost beats). Prints a warning when set; omit it to reproduce every scene. |
 | `--language <code>` | auto | Transcript/dialogue language hint (e.g. `fr`, `en`). |
 | `--focus <text>` | — | Known provenance/emphasis to ground the deconstruct. |
@@ -4012,10 +4027,10 @@ The two scaffold passes are billed (the full `video_deconstruct` is the heavy on
 Turn a source/inspiration image into a **runnable, self-validated static-ad canvas** — the static counterpart of `scaffold-video`. Like the video scaffold, this runs **billed Gemini passes** up front:
 
 1. **`image_describe`** (`~google/gemini-pro-latest`) — reverse-engineers the image into a blueprint JSON, written next to the canvas as **`prompt.json`**. This is the editable "prompt": you rewrite it by hand into the ad you want (palette, copy, claims, subjects). It feeds the generator directly — there is **no automatic brand-transform step**. The blueprint also names the **`winning_mechanisms`** — the special sauce that makes the ad a candidate winner, each tagged `kind` (verbal: rhyme/pun/rhythm; visual: unexpected crop, visual gag, juxtaposition, pattern interrupt, before/after; structural: hook order/reveal) with a `device` and `why_it_works` — so your rewrite rebuilds the mechanism that makes the ad win instead of adapting only the surface and losing it.
-2. **element selection** (`~google/gemini-flash-latest`) — picks the **main, identity-critical** elements (the brand logo, a showcased product, a trust badge) **plus any foreground/hero person or animal** — the emotional focal point — even a generic one, because a free-generated face/muzzle reads as AI and grows artifacts; the emotional hero always gets a real-reference slot. Background extras are dropped. Each is stamped back onto its blueprint entry as a `reference_image` label so the JSON self-documents which slot grounds which subject.
+2. **element selection** (`~google/gemini-flash-latest`) — picks the **main, identity-critical** elements (the brand logo, a showcased product, a trust badge) **plus any foreground/hero person or animal** — the emotional focal point — even a generic one, because a free-generated face/muzzle reads as AI and grows artifacts; the emotional hero always gets a real-reference slot. When the advertiser's logo appears in **more than one lockup** (a square/icon **mark** and a horizontal **wordmark**), each is emitted as its **own** element (e.g. `LOGO_MARK`, `LOGO_WORDMARK`) so you drop the right file in each slot instead of stretching one logo to cover both. The describe pass also records the ad's **typography** under a `fonts` block (each typeface's classification, a best-guess family, and its weight/case) so you know exactly what to drop at the brand-font slot. Background extras are dropped. Each element is stamped back onto its blueprint entry as a `reference_image` label so the JSON self-documents which slot grounds which subject.
 3. **global layout** (`~google/gemini-flash-latest`) — produces a structured `layout` block in `prompt.json`: the column/row grid, each region's `x_pct`/`y_pct` bounds, panel splits, background/shape, and every text block's relative size/weight/case/alignment. This is what gives the generator a precise composition to rebuild.
 
-It then scaffolds a canvas that ingests `prompt.json`, wires **one `[TODO]` ingest slot per detected element** (plus an optional brand-font → type-specimen) into `image_generate`, and wires the original image in for composition only. The canvas is validated before it's written. stdout returns `{ ok, canvas_path, prompt_path, models, layout_regions, stats, checklist }` — the **checklist** lists every real asset to drop in.
+It then scaffolds a canvas that ingests `prompt.json`, wires **one `[TODO]` ingest slot per detected element** (plus an optional brand-font → type-specimen) into `image_generate`, and wires the original image in for composition only. Each **person/animal hero** is additionally fused into a generated **multi-view reference sheet** (`image_reference_sheet`, a turnaround built from the one dropped photo) that the render grounds on instead of the lone flat snapshot — the same identity lock the video scaffold uses, so the face/muzzle stays consistent and artifact-free from a single reference. Pass `--skip-actor-sheets` to ground straight on the dropped photo. The canvas is validated before it's written. stdout returns `{ ok, canvas_path, prompt_path, models, layout_regions, stats, checklist }` — the **checklist** lists every real asset to drop in (and which heroes get a sheet).
 
 ```bash
 baker canvas scaffold-static-ad ./reference-ad.png --context "competitor ad for <brand>, <category>, <market>"
@@ -4036,6 +4051,7 @@ baker canvas run ./static-ad.canvas.json
 | `--gen-model <id>` | registry default (`openai/gpt-5.4-image-2`) | Override the `image_generate` model. |
 | `--aspect <ratio>` | inferred from the image, else `9:16` | Force the output aspect ratio. |
 | `--skip-font` | off | Skip the brand-font → type-specimen slot. |
+| `--skip-actor-sheets` | off | Ground each person/animal on its lone dropped photo instead of a generated multi-view reference sheet. |
 
 Scaffolding runs (and bills) the two vision passes; **running** the result generates a billed image. `baker canvas validate` does not check that the `[TODO]` paths exist — supply the real files before `run`.
 
@@ -4559,6 +4575,7 @@ This CLI is designed for AI agent consumption. Key patterns:
 - **0.105.0**: `baker images ...`, `baker videos ...`, and `baker testimonials ...` commands now type their `/api/{images,videos,testimonials}/...` request/response payloads from the shared `@baker/api` contract package instead of hand-written local interfaces. No command, flag, or output-shape changes.
 - **0.106.0**: `baker ads linkedin` gains staged write commands — `campaign-groups`/`campaigns`/`creatives` create|update|pause|resume|(archive|)duplicate, `audiences create|upload`, `conversions create|update`, `lead-forms create|update`, plus `draft [remove|clear]` for review/undo. Ops validate at stage time, apply on chat publish, and run simulated (`urn:li:simulated:*`) unless LinkedIn writes are enabled for the company.
 - **0.116.0**: `lead-forms create` models the full Campaign Manager form — `locale`, form banner image (`formImageId`/`formImageUrn`), predefined profile-field questions (validated enum) vs custom questions (`SINGLE_LINE_TEXT`/`MULTIPLE_CHOICE` with `options`, ≤3 custom), `privacyPolicyText`, disclosure `consents[]` (≤5), tracking `hiddenFields[]` (≤20), and `thankYou` confirmation CTA + landing/appointment link. Staged preview surfaces best-practice warnings (no qualifying question, no confirmation, no consent). No breaking flag changes.
+- **0.121.0**: `lead-forms create` drops the `privacyPolicyText` field — LinkedIn's versioned lead-form API has no privacy-policy-text slot, so it was silently discarded on publish. Use `legalDisclaimer` (shown under the form) or `consents[]` (disclosure checkboxes) instead. (Companion backend fix: staged lead-form questions were serialized in a shape LinkedIn dropped — they now publish correctly, and the staged preview lists each question.)
 - **0.119.0**: `draft amend`/`draft show` land on both `baker ads google` and `baker ads linkedin` — a generic JSON-merge-patch to update any staged op in place plus a full-payload receipt, replacing remove+recreate as the correction path. Google gains `assets update` and `asset-groups create|update` (Performance Max asset groups are now their own entity — `ads create --format performanceMaxAssetGroup` never worked and is gone); `ads create --format video` moves from a bare YouTube id to `--video-assets` refs (**breaking flag change** — stage the video as an asset first); `--format demandGen` gains `--image-assets`/`--square-image-assets`/`--logo-image-assets` and flag-building for headlines/descriptions. LinkedIn's `draft list` now renders a readable Campaign group ▸ Campaign ▸ Creative tree by default (`--json` for raw), `creatives update` gains `--campaign` (re-parent while staged), and `campaigns update` passes create-only fields (`--group`/`--type`/`--locale`/`--associated-entity`) through when amending a `li_temp_*` staged create instead of always stripping them.
 
 ## Publishing

package/dist/{chunk-VSVGPYJK.js → chunk-43KBQLP5.js}

@@ -780,7 +780,9 @@ function failedJobError(error) {
     retryable: error.retryable ?? false
   });
 }
-var JOB_POLL_INTERVAL_MS = 3e3;
+function pollInterval(attempt) {
+  return attempt < 15 ? 1e3 : 3e3;
+}
 var JOB_POLL_MAX_MS = 20 * 60 * 1e3;
 var BackendClient = class {
   http;
@@ -797,7 +799,7 @@ var BackendClient = class {
   async pollJob(jobId, signal) {
     const deadline = Date.now() + JOB_POLL_MAX_MS;
     const path16 = `/api/canvas/jobs/${encodeURIComponent(jobId)}`;
-    while (true) {
+    for (let attempt = 0; ; attempt++) {
       if (signal?.aborted) {
         throw new BackendHttpError({ kind: "network", cause: signal.reason ?? new Error("aborted") });
       }
@@ -807,7 +809,7 @@ var BackendClient = class {
       if (Date.now() > deadline) {
         throw new BackendHttpError({ kind: "timeout", message: `job ${jobId} did not finish in time` });
       }
-      await sleep(JOB_POLL_INTERVAL_MS);
+      await sleep(pollInterval(attempt));
     }
   }
   presignAssetUpload(sha256, mime, signal) {
@@ -838,6 +840,14 @@ var BackendClient = class {
   async recordRun(payload, signal) {
     await this.http.postJson("/api/canvas/runs", payload, signal);
   }
+  /**
+   * Chat-scoped blueprint sync — POST /api/creatives/definition. Lets the
+   * dashboard draw a scaffolded creative's workflow graph BEFORE the first run.
+   * Additive on the backend (never archives siblings, never sets definitionPath).
+   */
+  async syncCreativeDefinition(payload, signal) {
+    await this.http.postJson("/api/creatives/definition", payload, signal);
+  }
   getArtifact(kind, name, version, signal) {
     const path16 = version ? `/api/canvas/artifacts/${encodeURIComponent(kind)}/${encodeURIComponent(name)}/${encodeURIComponent(version)}` : `/api/canvas/artifacts/${encodeURIComponent(kind)}/${encodeURIComponent(name)}`;
     return this.http.getJson(path16, signal);
@@ -986,10 +996,10 @@ var ELEVENLABS_OUTPUT_FORMATS = [
 var ELEVENLABS_MAX_TEXT_CHARS = 45454;
 var ELEVENLABS_MAX_MUSIC_LENGTH_MS = 454545;
 var OPENROUTER_IMAGE_MIMES = ["image/png", "image/jpeg", "image/webp", "image/gif"];
-var FAL_IMAGE_MIMES = ["image/png", "image/jpeg", "image/webp"];
-var FAL_VIDEO_MIMES = ["video/mp4", "video/webm", "video/quicktime"];
+var REPLICATE_IMAGE_MIMES = ["image/png", "image/jpeg", "image/webp"];
+var REPLICATE_VIDEO_MIMES = ["video/mp4", "video/webm", "video/quicktime"];
 var DECONSTRUCT_VIDEO_MIMES = ["video/mp4", "video/webm", "video/quicktime"];
-var FAL_AUDIO_MIMES = ["audio/wav", "audio/mpeg", "audio/mp3"];
+var REPLICATE_AUDIO_MIMES = ["audio/wav", "audio/mpeg", "audio/mp3"];
 var IMAGE_GENERATE_MODELS = [
   "openai/gpt-5.4-image-2",
   "google/gemini-3.5-flash",
@@ -1207,20 +1217,23 @@ var MODEL_REGISTRY = {
   },
   video_generate: {
     "bytedance/seedance-2.0": {
-      // Routed via fal.ai (not OpenRouter) because OpenRouter's Seedance
-      // passthrough rejects photorealistic human reference frames via
-      // ByteDance's "real person" safety filter.
+      // Routed via Replicate's official `bytedance/seedance-2.0` model. NOTE:
+      // ByteDance's upstream "real person" likeness filter still blocks photoreal
+      // human reference frames on ANY reseller — the escape is a synthetic/AI
+      // presenter face or routing real faces to Veo, not the provider choice.
       label: "ByteDance Seedance 2.0",
       inputs: [],
-      optional_inputs: [{ kind: "image", mimes: FAL_IMAGE_MIMES }],
+      optional_inputs: [{ kind: "image", mimes: REPLICATE_IMAGE_MIMES }],
       required: ["prompt"],
       params: {
-        prompt: { kind: "string" },
+        // Replicate's Seedance wrapper hard-caps the prompt at 4000 chars; gate
+        // it here so an over-length prompt fails validate (free) not the billed call.
+        prompt: { kind: "string", maxLength: 4e3 },
         aspect_ratio: {
           kind: "string",
           enum: ["1:1", "3:4", "9:16", "4:3", "16:9", "21:9", "9:21"]
         },
-        resolution: { kind: "string", enum: ["480p", "720p", "1080p"] },
+        resolution: { kind: "string", enum: ["480p", "720p", "1080p", "4k"] },
         duration: { kind: "number", enum: SEEDANCE_DURATIONS },
         seed: { kind: "number" },
         generate_audio: { kind: "boolean" }
@@ -1241,7 +1254,10 @@ var MODEL_REGISTRY = {
         duration: { kind: "number", enum: [4, 6, 8] },
         seed: { kind: "number" },
         generate_audio: { kind: "boolean" },
-        person_generation: { kind: "string", enum: ["allow_all"] },
+        // Image-to-video and EU/UK/CH/MENA regions cap this at `allow_adult`;
+        // `allow_all` is text-to-video only. Allow both so an image-conditioned
+        // Veo clip (the real-face fallback) validates.
+        person_generation: { kind: "string", enum: ["allow_all", "allow_adult"] },
         enhance_prompt: { kind: "boolean" },
         conditioning_scale: { kind: "number" }
       }
@@ -1292,8 +1308,8 @@ var MODEL_REGISTRY = {
     "fal/veed-lipsync": {
       label: "VEED Lipsync (fal.ai)",
       inputs: [
-        { kind: "video", mimes: FAL_VIDEO_MIMES },
-        { kind: "audio", mimes: FAL_AUDIO_MIMES }
+        { kind: "video", mimes: REPLICATE_VIDEO_MIMES },
+        { kind: "audio", mimes: REPLICATE_AUDIO_MIMES }
       ],
       required: [],
       params: {}
@@ -1329,7 +1345,7 @@ var MODEL_REGISTRY = {
       // TARGET voice, preserving timing/prosody. Used to normalize a talking-head
       // clip's native (generator-chosen) voice into ONE consistent brand voice.
       label: "ElevenLabs Voice Changer (multilingual STS v2)",
-      inputs: [{ kind: "audio", mimes: FAL_AUDIO_MIMES }],
+      inputs: [{ kind: "audio", mimes: REPLICATE_AUDIO_MIMES }],
       required: ["voice"],
       params: {
         voice: { kind: "string" },
@@ -1356,7 +1372,7 @@ var MODEL_REGISTRY = {
     },
     "elevenlabs/video-background-music-v1": {
       label: "ElevenLabs Video Background Music v1",
-      inputs: [{ kind: "video", mimes: FAL_VIDEO_MIMES }],
+      inputs: [{ kind: "video", mimes: REPLICATE_VIDEO_MIMES }],
       required: [],
       params: {
         description: { kind: "string" },
@@ -1772,7 +1788,14 @@ var NodeDecl = z.object({
   version: z.string().min(1).optional(),
   inputs: z.record(z.string(), z.unknown()).optional(),
   params: z.record(z.string(), z.unknown()).optional(),
-  when: z.unknown().optional()
+  when: z.unknown().optional(),
+  // Regenerate knob. The engine is content-addressed: identical params + inputs
+  // return the cached render, so re-running an unchanged node NEVER re-bills or
+  // produces a new result. Bump this token (any string/number — a `2`, a `"v3"`,
+  // a note) and re-run to force THIS node to render fresh; because its new output
+  // changes downstream input hashes, everything depending on it regenerates too.
+  // This is the declarative "change a value, re-run, get a new render" affordance.
+  regenerate: z.union([z.string(), z.number()]).optional()
 }).strict();
 var OutputRef = z.object({
   node: z.string(),
@@ -3055,6 +3078,7 @@ var Engine = class {
     const counters = { cachedNodes: 0, totalCredits: 0 };
     const nodeRuns = [];
     const graph = this.pruneToOutput(canvas, buildGraph(canvas));
+    const needsBytes = computeNeedsLocalBytes(canvas, graph, this.registry);
     this.emitProgress(opts, {
       kind: "plan",
       nodes: [...graph.entries()].map(([id, deps]) => {
@@ -3062,7 +3086,7 @@ var Engine = class {
         return { node_id: id, node_type: node?.type ?? "unknown", deps: [...deps], params: node?.params };
       })
     });
-    await this.runLayers(canvas, graph, outputs, runId, writer, opts, counters, nodeRuns);
+    await this.runLayers(canvas, graph, outputs, runId, writer, opts, counters, nodeRuns, needsBytes);
     const output = pickFinalOutput(canvas, outputs);
     const stats = {
       total_nodes: canvas.nodes.length,
@@ -3087,13 +3111,13 @@ var Engine = class {
     this.log(`outputs in: ${writer.runDir}`);
     return { run_id: runId, output, outputs_by_node: outputs, stats, outputs_dir: writer.runDir, node_runs: nodeRuns };
   }
-  async runLayers(canvas, graph, outputs, runId, writer, opts, counters, nodeRuns) {
+  async runLayers(canvas, graph, outputs, runId, writer, opts, counters, nodeRuns, needsBytes) {
     const layers = topologicalLayers(graph);
     const limit = resolveConcurrency(opts.concurrency);
     for (const layer of layers) {
       const settled = await mapWithConcurrency(layer, limit, (nodeId) => {
         this.emitProgress(opts, { kind: "node_start", node_id: nodeId });
-        return this.executeOne(canvas, nodeId, outputs, runId, writer, opts).then((r) => {
+        return this.executeOne(canvas, nodeId, outputs, runId, writer, opts, needsBytes.has(nodeId)).then((r) => {
           if (r.cached) counters.cachedNodes++;
           counters.totalCredits += r.credits;
           const node = canvas.nodes.find((n) => n.id === nodeId);
@@ -3160,12 +3184,13 @@ var Engine = class {
     }
     await writer.writeManifest("_final", output);
   }
-  async executeOne(canvas, nodeId, outputs, runId, writer, opts) {
+  async executeOne(canvas, nodeId, outputs, runId, writer, opts, downloadOutputs) {
     const node = canvas.nodes.find((n) => n.id === nodeId);
     if (!node) throw new Error(`executor: missing node ${nodeId}`);
     const def = this.registry.get(node.type);
     if (!def) throw new Error(`executor: missing registry entry for type ${node.type}`);
-    const prepared = await prepareForExecution(node, outputs, def, canvas.cache_salt, this.assets);
+    const regenerateToken = resolveRegenerateToken(node, opts.regenerate, runId);
+    const prepared = await prepareForExecution(node, outputs, def, canvas.cache_salt, regenerateToken, this.assets);
     const policy = opts.cache_policy ?? "read_write";
     if (policy !== "bypass") {
       const cacheT0 = Date.now();
@@ -3183,12 +3208,14 @@ var Engine = class {
       nodeId: node.id,
       nodeType: node.type,
       cacheKey: prepared.cacheKey,
+      downloadOutputs,
       client: this.client,
       assets: this.assets,
       log: this.log,
       signal: opts.signal
     };
-    const { parsedInputs, parsedParams } = parseNodeArgs(def, prepared, node.id, node.type);
+    const preparedForExec = def.location === "local" ? { ...prepared, resolvedInputs: await this.materializeLocalInputs(prepared.resolvedInputs) } : prepared;
+    const { parsedInputs, parsedParams } = parseNodeArgs(def, preparedForExec, node.id, node.type);
     const result = await invokeExecute(def, parsedInputs, parsedParams, ctx, node.id, node.type);
     const elapsed = Date.now() - t0;
     const credits = def.cost ? def.cost({ params: parsedParams }).credits : 0;
@@ -3230,8 +3257,42 @@ var Engine = class {
       }
     }
   }
+  /**
+   * Download any URL-only asset ref reachable in a local node's inputs so the
+   * bytes are on disk before the local runner stages them. Returns a copy —
+   * refs are replaced, never mutated in place, so the producer's cached output
+   * (shared object) keeps its URL-only shape.
+   */
+  async materializeLocalInputs(inputs) {
+    const fix = async (value) => {
+      if (Array.isArray(value)) return Promise.all(value.map(fix));
+      if (value && typeof value === "object") {
+        const v = value;
+        if (typeof v.kind === "string" && typeof v.url === "string" && typeof v.sha256 === "string" && typeof v.mime === "string" && typeof v.path !== "string") {
+          this.log(`[warn    ] materializing URL-only input on demand (${v.kind}/${v.mime}) \u2014 missed graph edge`);
+          return this.assets.ingestRemote({
+            kind: v.kind,
+            url: v.url,
+            sha256: v.sha256,
+            mime: v.mime,
+            metadata: v.metadata
+          });
+        }
+        const out = {};
+        for (const [k, val] of Object.entries(v)) out[k] = await fix(val);
+        return out;
+      }
+      return value;
+    };
+    return await fix(inputs);
+  }
 };
-async function prepareForExecution(node, outputs, def, cacheSalt, assets) {
+function resolveRegenerateToken(node, forced, runId) {
+  if (forced?.has(node.id)) return `run:${runId}`;
+  if (node.regenerate !== void 0) return `node:${String(node.regenerate)}`;
+  return void 0;
+}
+async function prepareForExecution(node, outputs, def, cacheSalt, regenerateToken, assets) {
   const resolvedInputs = resolveRefs(node.inputs ?? {}, { outputs }) ?? {};
   const resolvedParams = resolveRefs(node.params ?? {}, { outputs }) ?? {};
   const slotValues = await hydrateTextSlots(resolvedInputs, assets, node.id, node.type);
@@ -3244,6 +3305,9 @@ async function prepareForExecution(node, outputs, def, cacheSalt, assets) {
       throw new NodeExecutionError(node.id, node.type, { kind: "local", cause: e });
     }
   }
+  if (regenerateToken !== void 0) {
+    extras = { ...extras ?? {}, __regenerate__: regenerateToken };
+  }
   const cacheKey = computeCacheKey({
     node_id: node.type,
     node_version: def.version,
@@ -3282,6 +3346,16 @@ function pickFinalOutput(canvas, outputs) {
   const lastOut = outputs[last.id];
   return lastOut ? Object.values(lastOut)[0] : void 0;
 }
+function computeNeedsLocalBytes(canvas, graph, registry) {
+  const typeById = new Map(canvas.nodes.map((n) => [n.id, n.type]));
+  const needs = /* @__PURE__ */ new Set();
+  for (const [consumerId, deps] of graph) {
+    const def = registry.get(typeById.get(consumerId) ?? "");
+    if (def?.location !== "local") continue;
+    for (const dep of deps) needs.add(dep);
+  }
+  return needs;
+}
 function buildGraph(canvas) {
   const graph = /* @__PURE__ */ new Map();
   for (const n of canvas.nodes) graph.set(n.id, /* @__PURE__ */ new Set());
@@ -3412,7 +3486,16 @@ async function hydrateSlotValue(value, assets, nodeId, nodeType) {
   try {
     bytes = await assets.readBytes(value.sha256, value.mime);
   } catch (e) {
-    throw new NodeExecutionError(nodeId, nodeType, { kind: "local", cause: e });
+    if (value.url) {
+      try {
+        await assets.ingestRemote({ kind: value.kind, url: value.url, sha256: value.sha256, mime: value.mime });
+        bytes = await assets.readBytes(value.sha256, value.mime);
+      } catch (e2) {
+        throw new NodeExecutionError(nodeId, nodeType, { kind: "local", cause: e2 });
+      }
+    } else {
+      throw new NodeExecutionError(nodeId, nodeType, { kind: "local", cause: e });
+    }
   }
   if (bytes.length > MAX_INLINE_TEXT_BYTES) {
     throw new NodeExecutionError(nodeId, nodeType, {
@@ -3547,7 +3630,9 @@ async function callBackendExec(args) {
         nodeVersion: args.nodeVersion,
         params: args.params,
         inputs: serialized,
-        idempotency_key: idempotencyKey
+        idempotency_key: idempotencyKey,
+        canvas_run_id: args.ctx.canvasRunId,
+        node_id: args.ctx.nodeId
       },
       args.ctx.signal
     );
@@ -3599,6 +3684,9 @@ async function ingestValue(value, ctx, declaredKind) {
   }
   if (isRawAsset(value)) {
     const kind = value.kind ?? declaredKind ?? "json";
+    if (ctx.downloadOutputs === false) {
+      return buildRef({ kind, sha: value.sha256, mime: value.mime, url: value.url, metadata: value.metadata });
+    }
     return ctx.assets.ingestRemote({
       kind,
       url: value.url,
@@ -3836,7 +3924,15 @@ var EXT_TO_MIME = {
   jpeg: "image/jpeg",
   webp: "image/webp",
   gif: "image/gif",
+  // Non-model-safe rasters `toModelSafeImage` transcodes to PNG at ingest — they
+  // must resolve to an image mime here or the kind-check rejects the local file
+  // before normalization ever runs.
   avif: "image/avif",
+  heic: "image/heic",
+  heif: "image/heif",
+  tif: "image/tiff",
+  tiff: "image/tiff",
+  bmp: "image/bmp",
   mp4: "video/mp4",
   webm: "video/webm",
   mov: "video/quicktime",
@@ -3906,15 +4002,26 @@ async function toModelSafeImage(bytes) {
     throw new Error(`bytes are not a decodable image (${e.message})`);
   }
 }
+function hasAscii(buf, offset, sig) {
+  return buf.length >= offset + sig.length && buf.toString("ascii", offset, offset + sig.length) === sig;
+}
+var HEIC_BRANDS = /* @__PURE__ */ new Set(["heic", "heix", "heim", "heis", "hevc", "hevx", "mif1", "msf1", "heif"]);
+function sniffIsoBmff(buf) {
+  if (!hasAscii(buf, 4, "ftyp")) return null;
+  const brand = buf.subarray(8, 12).toString("ascii");
+  if (brand === "avif" || brand === "avis") return "image/avif";
+  if (HEIC_BRANDS.has(brand)) return "image/heic";
+  return null;
+}
 function sniffImageMime(buf) {
   if (buf.length < 4) return null;
-  if (buf[0] === 137 && buf[1] === 80 && buf[2] === 78 && buf[3] === 71) return "image/png";
+  if (buf[0] === 137 && hasAscii(buf, 1, "PNG")) return "image/png";
   if (buf[0] === 255 && buf[1] === 216 && buf[2] === 255) return "image/jpeg";
-  if (buf[0] === 71 && buf[1] === 73 && buf[2] === 70) return "image/gif";
-  if (buf.length >= 12 && buf[0] === 82 && buf[1] === 73 && buf[2] === 70 && buf[3] === 70 && buf[8] === 87 && buf[9] === 69 && buf[10] === 66 && buf[11] === 80) {
-    return "image/webp";
-  }
-  return null;
+  if (hasAscii(buf, 0, "GIF")) return "image/gif";
+  if (hasAscii(buf, 0, "RIFF") && hasAscii(buf, 8, "WEBP")) return "image/webp";
+  if (hasAscii(buf, 0, "II*\0") || hasAscii(buf, 0, "MM\0*")) return "image/tiff";
+  if (hasAscii(buf, 0, "BM")) return "image/bmp";
+  return sniffIsoBmff(buf);
 }
 function findBoxPayload(buf, start, end, type) {
   let offset = start;
@@ -6792,6 +6899,8 @@ export {
   ulid,
   isPersistedAssetRef,
   collectAssetRefLikes,
+  REF_PREFIX,
+  parseRefExpr,
   sha256Hex,
   elementMentionKeywords,
   toModelSafeImage,
@@ -6805,4 +6914,4 @@ export {
   defaultRegistry,
   createEngineFromEnv
 };
-//# sourceMappingURL=chunk-VSVGPYJK.js.map
+//# sourceMappingURL=chunk-43KBQLP5.js.map