@koda-sl/baker-cli 0.39.29 → 0.66.2

package/dist/engine/scaffold/video.js

@@ -0,0 +1,709 @@
+// Pure transform: a `video-deconstruct/1` blueprint + an AI-selected list of the
+// video's RECURRING identity elements → a runnable `baker-canvas/1` reproduction
+// canvas. No IO — the command layer runs the deconstruct + element-selection
+// passes, bakes the blueprint to `prompt.json`, calls this, validates, and writes.
+//
+// This is the video analogue of `staticAd.ts`, extended for time: every scene
+// boundary is a static-ad-grade `image_generate` (the baked blueprint as
+// `target_blueprint`, a dynamic reference legend, the real extracted frame as a
+// composition anchor), and any recurring element — a person, animal, product, or
+// logo — gets ONE shared `ingest` slot wired into every frame it appears in, so
+// the same actor is grounded by the same source image across the whole video.
+// The per-scene clip (`video_generate`) is fed an ultra-detailed motion brief
+// composed from the scene's action, camera, dialogue, and transcript.
+import { z } from "zod";
+import { ELEVENLABS_MAX_MUSIC_LENGTH_MS } from "../models/registry.js";
+const SEEDANCE_DURATIONS = [4, 5, 6, 8, 10, 12, 15];
+const FIXED_TTS_MODEL = "elevenlabs/eleven_v3";
+const FIXED_SFX_MODEL = "elevenlabs/eleven_text_to_sound_v2";
+const FIXED_MUSIC_MODEL = "elevenlabs/music-v1";
+const MUSIC_BED_GAIN_DB = -12;
+// Aspect ratios both image_generate and the default video model (Seedance) accept.
+const SHARED_ASPECT_RATIOS = new Set(["1:1", "16:9", "9:16", "4:3", "3:4", "21:9"]);
+const EDGES = ["start", "end"];
+/** Snap an arbitrary scene length to the nearest Seedance-allowed clip duration (≤15s). */
+export function snapToSeedance(durationS) {
+    if (!Number.isFinite(durationS) || durationS <= 0)
+        return SEEDANCE_DURATIONS[0];
+    let best = SEEDANCE_DURATIONS[0];
+    let bestDelta = Math.abs(durationS - best);
+    for (const d of SEEDANCE_DURATIONS) {
+        const delta = Math.abs(durationS - d);
+        // On a tie, prefer the longer clip so we don't truncate scene content.
+        if (delta < bestDelta || (delta === bestDelta && d > best)) {
+            best = d;
+            bestDelta = delta;
+        }
+    }
+    return best;
+}
+// --- Tolerant blueprint schema: pick only the fields the scaffold consumes. ---
+const FrameAsset = z.object({ url: z.string().optional() }).loose().optional();
+const DialogueLine = z
+    .object({
+    speaker: z.string().optional(),
+    line: z.string().optional(),
+    start_s: z.number().optional(),
+    voice_description: z.string().optional(),
+})
+    .loose();
+const Sfx = z
+    .object({
+    at_s: z.number().optional(),
+    duration_s: z.number().optional(),
+    sound_effect_prompt: z.string().optional(),
+    description: z.string().optional(),
+})
+    .loose();
+const CameraMotion = z.object({ movement: z.string().optional(), detail: z.string().optional() }).loose();
+const TranscriptWord = z.object({ text: z.string().optional() }).loose();
+const Scene = z
+    .object({
+    start_s: z.number().optional(),
+    end_s: z.number().optional(),
+    duration_s: z.number().optional(),
+    summary: z.string().optional(),
+    action_detail: z.string().optional(),
+    camera_motion: CameraMotion.optional(),
+    start_frame_prompt: z.string().optional(),
+    end_frame_prompt: z.string().optional(),
+    motion_prompt: z.string().optional(),
+    dialogue: z.array(DialogueLine).optional(),
+    sfx: z.array(Sfx).optional(),
+    overlays: z.array(z.unknown()).optional(),
+    floating_elements: z.array(z.unknown()).optional(),
+    transcript_slice: z.array(TranscriptWord).optional(),
+    start_frame_asset: FrameAsset,
+    end_frame_asset: FrameAsset,
+})
+    .loose();
+const VideoBlueprint = z
+    .object({
+    source: z.object({ aspect_ratio: z.string().optional(), duration_s: z.number().optional() }).loose().optional(),
+    global: z
+        .object({
+        music: z
+            .object({
+            present: z.boolean().optional(),
+            music_prompt: z.string().optional(),
+            // Populated by the deconstruct when AudD (Shazam-style) recognizes the
+            // reference track. We never reuse it — only style the regenerated bed.
+            identified_track: z
+                .object({ title: z.string().optional(), artist: z.string().optional() })
+                .loose()
+                .nullish(),
+        })
+            .loose()
+            .optional(),
+        cast: z.array(z.object({ id: z.string().optional(), description: z.string().optional() }).loose()).optional(),
+        voiceover: z.object({ voice_description: z.string().optional() }).loose().optional(),
+    })
+        .loose()
+        .optional(),
+    scenes: z.array(Scene).min(1),
+})
+    .loose();
+// --- A recurring identity element chosen by the selection pass. ---
+// `appears_in`/`scenes` say which scene(s) — and optionally which edge — it is
+// visually present in; that drives which frames reference its shared source image.
+const AppearsItem = z.union([z.number(), z.object({ scene: z.number(), edge: z.string().optional() }).loose()]);
+const RecurringElement = z
+    .object({
+    // person | animal | product | logo | badge | other
+    type: z.string(),
+    label: z.string().optional(),
+    description: z.string().optional(),
+    expression: z.string().nullable().optional(),
+    // When the element maps to a global cast entry, its stable id (for annotation).
+    cast_id: z.string().nullable().optional(),
+    // Scenes the element appears in. Either a bare list of scene indices (both
+    // edges) or per-{scene,edge} entries. Both forms are accepted and merged.
+    scenes: z.array(z.number()).optional(),
+    appears_in: z.array(AppearsItem).optional(),
+})
+    .loose();
+const RecurringElements = z.array(RecurringElement);
+/** lower_snake_case id that satisfies the canvas NodeIdRe; falls back to a stable default. */
+function sanitizeId(raw, fallback) {
+    const id = raw
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "");
+    return /^[a-z]/.test(id) ? id : `${fallback}_${id}`.replace(/_+$/g, "") || fallback;
+}
+/** UPPER_SNAKE reference label, deduped across elements (HERO, HERO_2, ...). */
+function labelFor(el, used) {
+    const base = (el.label ?? el.type ?? "ELEMENT")
+        .toUpperCase()
+        .replace(/[^A-Z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "") || "ELEMENT";
+    let label = base;
+    let n = 2;
+    while (used.has(label))
+        label = `${base}_${n++}`;
+    used.add(label);
+    return label;
+}
+/** Assign each element its deduped reference label, in order — one source of truth shared by every consumer. */
+function assignElementLabels(elements) {
+    const used = new Set();
+    return elements.map((el) => ({ el, label: labelFor(el, used) }));
+}
+/** Normalize an element's scene/edge presence into scene index → set of edges it appears on. */
+function presenceOf(el) {
+    const map = new Map();
+    const add = (scene, edge) => {
+        if (!Number.isInteger(scene) || scene < 0)
+            return;
+        let set = map.get(scene);
+        if (!set) {
+            set = new Set();
+            map.set(scene, set);
+        }
+        if (edge)
+            set.add(edge);
+        else
+            for (const e of EDGES)
+                set.add(e);
+    };
+    for (const s of el.scenes ?? [])
+        add(s, null);
+    for (const a of el.appears_in ?? []) {
+        if (typeof a === "number")
+            add(a, null);
+        else if (a && typeof a === "object") {
+            const edge = a.edge === "start" || a.edge === "end" ? a.edge : null;
+            add(a.scene, edge);
+        }
+    }
+    return map;
+}
+function aspectRatioParam(blueprint) {
+    const ar = blueprint.source?.aspect_ratio;
+    return ar && SHARED_ASPECT_RATIOS.has(ar) ? ar : undefined;
+}
+/**
+ * Document the recurring elements in the baked prompt.json: add a top-level
+ * `reference_elements` summary (label/type/description/scenes), and stamp
+ * `reference_image: LABEL` onto the matching `global.cast[*]` entry by id — so
+ * the human editing the JSON sees which wired slot grounds which persona. Clones
+ * the input (never mutates the caller's object).
+ */
+export function annotateBlueprintWithElements(blueprintInput, elementsInput) {
+    if (!blueprintInput || typeof blueprintInput !== "object")
+        return blueprintInput;
+    const elements = RecurringElements.parse(elementsInput);
+    const clone = JSON.parse(JSON.stringify(blueprintInput));
+    const cast = (clone.global?.cast ?? null);
+    const summary = [];
+    for (const { el, label } of assignElementLabels(elements)) {
+        const scenes = [...presenceOf(el).keys()].sort((a, b) => a - b);
+        summary.push({ reference_image: label, type: el.type, description: el.description ?? null, scenes });
+        if (el.cast_id && Array.isArray(cast)) {
+            const entry = cast.find((c) => c?.id === el.cast_id);
+            if (entry && typeof entry === "object")
+                entry.reference_image = label;
+        }
+    }
+    clone.reference_elements = summary;
+    return clone;
+}
+/** What the generator should do with each reference, by element type — emphasizes cross-frame consistency. */
+function roleForType(type) {
+    switch (type.toLowerCase()) {
+        case "logo":
+            return "the brand wordmark/logo; reproduce it exactly, do not redraw or restyle it.";
+        case "badge":
+            return "a trust/rating badge; reproduce it exactly, do not invent ratings or seals.";
+        case "product":
+            return "the showcased product; keep this exact product identity consistent across every frame. Ignore any caption text printed on this reference.";
+        case "person":
+        case "animal":
+            return "a recurring hero subject; keep this exact identity (face, hair, wardrobe, markings) consistent across EVERY frame of the video. Ignore any caption text printed on this reference.";
+        default:
+            return "a recurring identity element; reproduce it faithfully and keep it consistent across every frame. Ignore any caption text printed on it.";
+    }
+}
+function todoPath(el, label) {
+    const desc = el.description ? ` — ${el.description}` : "";
+    const expr = el.expression ? `, with a ${el.expression} expression` : "";
+    return `[TODO: drop one real source image for ${label} (${el.type})${desc}${expr} — reused across every frame it appears in]`;
+}
+/** Compute one shared ingest slot per recurring element (id, label, presence map). */
+function buildElementSlots(elements) {
+    const usedIds = new Set(["prompt", "spine", "overlaid", "audio_mix", "final", "music_bed"]);
+    const slots = [];
+    assignElementLabels(elements).forEach(({ el, label }, i) => {
+        let id = sanitizeId(`el_${label}`, `el_${i}`);
+        while (usedIds.has(id))
+            id = `${id}_${i}`;
+        usedIds.add(id);
+        slots.push({
+            id,
+            ref: `$ref:${id}.asset`,
+            label,
+            type: el.type,
+            description: el.description,
+            presence: presenceOf(el),
+        });
+    });
+    return slots;
+}
+/** The element slots whose presence includes this scene/edge. */
+function slotsForFrame(slots, sceneIndex, edge) {
+    return slots.filter((s) => s.presence.get(sceneIndex)?.has(edge));
+}
+/** The element slots present anywhere in this scene (either edge) — for the motion brief. */
+function slotsForScene(slots, sceneIndex) {
+    return slots.filter((s) => s.presence.has(sceneIndex));
+}
+/**
+ * Build the static-ad-grade prompt for one boundary frame.
+ *
+ * The prompt is SELF-CONTAINED and is the per-frame editable surface: the FRAME
+ * DESCRIPTION is inlined verbatim from the blueprint's `{edge}_frame_prompt`, so
+ * editing this one node's `params.prompt` changes ONLY this frame — no other
+ * frame and no shared file is touched. The blueprint (`{{target_blueprint}}`) is
+ * kept ONLY as a demoted, shared style reference (global cast identity, palette,
+ * typography mood, aspect ratio) — never as the source of this frame's content.
+ */
+function buildFramePrompt(edge, sceneIndex, framePrompt, present, hasAnchor) {
+    const EDGE = edge.toUpperCase();
+    const legend = [
+        ...present.map((s) => `- ${s.label} — ${roleForType(s.type)}`),
+        ...(hasAnchor
+            ? [
+                "- ORIGINAL_FRAME — use ONLY for composition, framing, pose, and proportions of THIS frame. IGNORE its overlay text, captions, and any brand that is being swapped.",
+            ]
+            : []),
+    ].join("\n");
+    const description = framePrompt?.trim() ||
+        `the ${edge} frame of scene ${sceneIndex + 1} — describe the full composition, subjects, setting, action, lighting, and palette here. (Edit this line to change ONLY this frame.)`;
+    return [
+        `Render the ${EDGE} frame of scene ${sceneIndex + 1} as a single still image. This prompt is self-contained and edit-per-frame: change the FRAME DESCRIPTION below to alter ONLY this frame. EXCLUDE all overlay text, captions, stickers, and watermarks — they are composited on top later.`,
+        "",
+        "REFERENCE IMAGES (in the order provided):",
+        legend,
+        "",
+        "FRAME DESCRIPTION (this frame's editable prompt):",
+        description,
+        "",
+        "Keep every recurring element identical to its reference image across all frames. Use the GLOBAL STYLE REFERENCE only for shared cast identity, palette, typography mood, and aspect ratio — do NOT copy another scene's composition from it; this frame's content is the FRAME DESCRIPTION above.",
+        "",
+        "GLOBAL STYLE REFERENCE (shared across frames; not this frame's content):",
+        "{{target_blueprint}}",
+    ].join("\n");
+}
+/**
+ * Emit the node(s) for one scene boundary frame and return the ref to wire into
+ * video_generate: ingest the real frame (when present), then either reuse it
+ * directly (faithful mode) or regenerate it static-ad-style — the baked blueprint
+ * as target_blueprint, the shared recurring-element images + the real frame as
+ * references, and a per-element legend.
+ */
+function buildFrameRef(edge, url, framePrompt, present, ctx, nodes) {
+    const refId = `s${ctx.sceneIndex}_${edge}_ref`;
+    if (url)
+        nodes.push({ id: refId, type: "ingest", params: { source: "url", url, expect: "image" } });
+    if (ctx.reuse && url)
+        return `$ref:${refId}.asset`;
+    const reference = [...present.map((s) => s.ref), ...(url ? [`$ref:${refId}.asset`] : [])];
+    const genParams = {
+        model: ctx.imageModel,
+        image_size: "2K",
+        prompt: buildFramePrompt(edge, ctx.sceneIndex, framePrompt, present, Boolean(url)),
+    };
+    if (ctx.ar)
+        genParams.aspect_ratio = ctx.ar;
+    const genNode = {
+        id: `s${ctx.sceneIndex}_${edge}`,
+        type: "image_generate",
+        // `params.prompt` is this frame's authoritative, edit-per-frame description.
+        // `target_blueprint` is kept only as a demoted shared style reference (global
+        // cast/palette/typography), so editing one frame never touches another.
+        inputs: { target_blueprint: "$ref:prompt.asset", ...(reference.length > 0 ? { reference } : {}) },
+        params: genParams,
+    };
+    nodes.push(genNode);
+    return `$ref:s${ctx.sceneIndex}_${edge}.images#0`;
+}
+/** Compose the ultra-detailed motion brief handed to the video model for one scene. */
+function buildSeedancePrompt(scene, sceneIndex, present) {
+    const parts = [];
+    const summary = scene.summary?.trim();
+    parts.push(summary ? `Scene ${sceneIndex + 1}: ${summary}` : `Scene ${sceneIndex + 1}`);
+    if (scene.action_detail)
+        parts.push(`Action: ${scene.action_detail}`);
+    const cm = scene.camera_motion;
+    if (cm) {
+        const camera = [cm.movement, cm.detail].filter(Boolean).join(" — ");
+        if (camera)
+            parts.push(`Camera: ${camera}`);
+    }
+    if (scene.motion_prompt)
+        parts.push(`Motion: ${scene.motion_prompt}`);
+    if (present.length > 0) {
+        parts.push(`Keep these consistent with their references: ${present.map((s) => `${s.label} (${s.description ?? s.type})`).join("; ")}`);
+    }
+    const lines = (scene.dialogue ?? []).map((d) => d.line?.trim()).filter((l) => Boolean(l));
+    if (lines.length > 0)
+        parts.push(`Spoken: ${lines.map((l) => `"${l}"`).join(" ")}`);
+    const transcript = (scene.transcript_slice ?? [])
+        .map((w) => w.text?.trim())
+        .filter(Boolean)
+        .join(" ")
+        .trim();
+    if (transcript)
+        parts.push(`Transcript: ${transcript}`);
+    return parts.join("\n");
+}
+/** Build the per-scene visual chain (frames + clip) and return the clip ref ids. */
+function buildSceneVisuals(blueprint, slots, opts, nodes) {
+    const ar = aspectRatioParam(blueprint);
+    const reuse = opts.frames === "reuse";
+    const clipRefs = [];
+    blueprint.scenes.forEach((scene, i) => {
+        const ctx = { sceneIndex: i, ar, reuse, imageModel: opts.imageModel };
+        const firstFrame = buildFrameRef("start", scene.start_frame_asset?.url, scene.start_frame_prompt, slotsForFrame(slots, i, "start"), ctx, nodes);
+        const lastFrame = buildFrameRef("end", scene.end_frame_asset?.url, scene.end_frame_prompt, slotsForFrame(slots, i, "end"), ctx, nodes);
+        const clipParams = {
+            model: opts.videoModel,
+            prompt: buildSeedancePrompt(scene, i, slotsForScene(slots, i)),
+            duration: snapToSeedance(scene.duration_s ?? 5),
+        };
+        if (ar)
+            clipParams.aspect_ratio = ar;
+        nodes.push({
+            id: `s${i}_clip`,
+            type: "video_generate",
+            inputs: { first_frame: firstFrame, last_frame: lastFrame },
+            params: clipParams,
+        });
+        clipRefs.push(`$ref:s${i}_clip.video`);
+    });
+    return clipRefs;
+}
+/**
+ * The music-bed generation prompt. When the deconstruct identified the real
+ * reference track (via AudD), style the regenerated bed after its vibe — but
+ * NEVER reproduce it (that would be a copyright lift); we generate original music
+ * that matches the mood/tempo/energy.
+ */
+function musicBedPrompt(blueprint, musicPrompt) {
+    const track = blueprint.global?.music?.identified_track;
+    const title = track?.title?.trim();
+    if (!title)
+        return musicPrompt;
+    const by = track?.artist?.trim() ? ` by ${track.artist.trim()}` : "";
+    return `${musicPrompt}\n\nReference vibe: the original used "${title}"${by} (identified via AudD). Match its mood, tempo, and energy with ORIGINAL music — do not reproduce the track.`;
+}
+/** Build voiceover (tts), SFX, and music nodes; return the audio tracks to mix. */
+function buildAudio(blueprint, nodes) {
+    const tracks = [];
+    // One voice_select per distinct speaker, cast from its description.
+    const voiceNodeBySpeaker = new Map();
+    const speakerDescription = (speaker) => {
+        for (const scene of blueprint.scenes) {
+            for (const line of scene.dialogue ?? []) {
+                if ((line.speaker ?? "voiceover") === speaker && line.voice_description)
+                    return line.voice_description;
+            }
+        }
+        const cast = blueprint.global?.cast?.find((c) => c.id === speaker);
+        return cast?.description ?? blueprint.global?.voiceover?.voice_description ?? `${speaker} voice`;
+    };
+    const ensureVoiceNode = (speaker) => {
+        const existing = voiceNodeBySpeaker.get(speaker);
+        if (existing)
+            return existing;
+        const id = sanitizeId(`voice_${speaker}`, `voice_${voiceNodeBySpeaker.size}`);
+        nodes.push({ id, type: "voice_select", params: { description: speakerDescription(speaker) } });
+        voiceNodeBySpeaker.set(speaker, id);
+        return id;
+    };
+    const scriptBySpeaker = new Map();
+    const orderedSpeakers = [];
+    for (const scene of blueprint.scenes) {
+        for (const line of scene.dialogue ?? []) {
+            if (!line.line)
+                continue;
+            const speaker = line.speaker ?? "voiceover";
+            const start = line.start_s ?? scene.start_s ?? 0;
+            const existing = scriptBySpeaker.get(speaker);
+            if (existing) {
+                existing.lines.push(line.line);
+                existing.start = Math.min(existing.start, start);
+            }
+            else {
+                scriptBySpeaker.set(speaker, { lines: [line.line], start });
+                orderedSpeakers.push(speaker);
+            }
+        }
+    }
+    const usedVoIds = new Set();
+    orderedSpeakers.forEach((speaker, idx) => {
+        const script = scriptBySpeaker.get(speaker);
+        if (!script)
+            return;
+        const voiceNode = ensureVoiceNode(speaker);
+        let id = sanitizeId(`vo_${speaker}`, `vo_${idx}`);
+        while (usedVoIds.has(id))
+            id = `${id}_${idx}`;
+        usedVoIds.add(id);
+        nodes.push({
+            id,
+            type: "tts",
+            inputs: { voice_ref: `$ref:${voiceNode}.voice_id` },
+            // Join lines with a space: each line keeps its own terminal punctuation, so
+            // sentence boundaries (and the pauses they imply) survive into one read.
+            params: { model: FIXED_TTS_MODEL, text: script.lines.join(" "), voice: "{{voice_ref}}" },
+        });
+        tracks.push({ slot: id, ref: `$ref:${id}.audio`, start_s: script.start });
+    });
+    // SFX: one node per scene sound-effect event.
+    blueprint.scenes.forEach((scene, i) => {
+        (scene.sfx ?? []).forEach((sfx, k) => {
+            const text = sfx.sound_effect_prompt ?? sfx.description;
+            if (!text)
+                return;
+            const id = `s${i}_sfx${k}`;
+            const params = { model: FIXED_SFX_MODEL, text };
+            // Clamp to the provider range so the emitted canvas self-validates.
+            if (typeof sfx.duration_s === "number")
+                params.duration_seconds = Math.min(Math.max(sfx.duration_s, 0.5), 30);
+            nodes.push({ id, type: "sound_effect", params });
+            tracks.push({ slot: `sfx_s${i}_${k}`, ref: `$ref:${id}.audio`, start_s: sfx.at_s ?? scene.start_s ?? 0 });
+        });
+    });
+    const musicPrompt = blueprint.global?.music?.music_prompt;
+    if (musicPrompt) {
+        const totalMs = Math.round((blueprint.source?.duration_s ?? lastSceneEnd(blueprint)) * 1000);
+        // Clamp to the validated range so very long sources still scaffold; the
+        // audio_timeline pads/trims the bed to the real length anyway.
+        const musicMs = Math.min(Math.max(totalMs, 3000), ELEVENLABS_MAX_MUSIC_LENGTH_MS);
+        nodes.push({
+            id: "music_bed",
+            type: "music",
+            params: { model: FIXED_MUSIC_MODEL, prompt: musicBedPrompt(blueprint, musicPrompt), music_length_ms: musicMs },
+        });
+        // Music first so it sits under the voices in the mix.
+        tracks.unshift({ slot: "music", ref: "$ref:music_bed.audio", start_s: 0, gain_db: MUSIC_BED_GAIN_DB });
+    }
+    return tracks;
+}
+function lastSceneEnd(blueprint) {
+    let end = 0;
+    for (const s of blueprint.scenes)
+        end = Math.max(end, s.end_s ?? 0);
+    return end > 0 ? end : 8;
+}
+/** ffmpeg argv: concatenate N video-only clips into one. */
+function concatArgs(count) {
+    const inputs = [];
+    let labels = "";
+    for (let i = 0; i < count; i++) {
+        inputs.push("-i", `{{in.c${i}}}`);
+        labels += `[${i}:v]`;
+    }
+    return [...inputs, "-filter_complex", `${labels}concat=n=${count}:v=1:a=0[v]`, "-map", "[v]", "{{out.video}}"];
+}
+/**
+ * Assemble a full video reproduction canvas. The baked blueprint as the editable
+ * `prompt`, one shared `ingest` per recurring element, then the visual spine
+ * (per-scene boundary frames → clips → concat), an optional burned-in overlay
+ * pass, and an optional audio mix (music + voiceover + SFX) muxed under the video.
+ */
+export function scaffoldVideoCanvas(input, elementsInput, opts) {
+    const blueprint = VideoBlueprint.parse(input);
+    const elements = RecurringElements.parse(elementsInput);
+    const nodes = [];
+    // The editable "prompt": the baked deconstruct blueprint, ingested as JSON and
+    // fed into every frame generator via target_blueprint.
+    nodes.push({
+        id: "prompt",
+        type: "ingest",
+        params: { source: "path", path: opts.blueprintPath ?? "./prompt.json", expect: "json" },
+    });
+    // One shared ingest per recurring identity element, wired into every frame it appears in.
+    // buildElementSlots preserves input order, so slots[i] corresponds to elements[i].
+    const slots = buildElementSlots(elements);
+    slots.forEach((slot, i) => {
+        nodes.push({
+            id: slot.id,
+            type: "ingest",
+            params: { source: "path", path: todoPath(elements[i], slot.label), expect: "image" },
+        });
+    });
+    const clipRefs = buildSceneVisuals(blueprint, slots, opts, nodes);
+    // Concatenate the per-scene clips into the visual spine.
+    const concatInputs = {};
+    clipRefs.forEach((ref, i) => {
+        concatInputs[`c${i}`] = ref;
+    });
+    nodes.push({
+        id: "spine",
+        type: "ffmpeg",
+        inputs: concatInputs,
+        params: { args: concatArgs(clipRefs.length), outputs: { video: { kind: "video", ext: "mp4" } } },
+    });
+    let videoRef = "$ref:spine.video";
+    let videoNode = "spine";
+    // Burned-in overlay pass (text overlays + floating-element placeholders).
+    const overlays = blueprint.scenes.flatMap((s) => s.overlays ?? []);
+    const floating = blueprint.scenes.flatMap((s) => s.floating_elements ?? []);
+    if (overlays.length > 0 || floating.length > 0) {
+        nodes.push({
+            id: "overlaid",
+            type: "hyperframe_render",
+            inputs: { background: videoRef },
+            params: { composition: opts.overlayCompositionPath, overlays, floating_elements: floating },
+        });
+        videoRef = "$ref:overlaid.video";
+        videoNode = "overlaid";
+    }
+    // Audio: mix music + voiceover + SFX onto the timeline, then mux under video.
+    const tracks = buildAudio(blueprint, nodes);
+    if (tracks.length > 0) {
+        const mixInputs = {};
+        for (const t of tracks)
+            mixInputs[t.slot] = t.ref;
+        nodes.push({
+            id: "audio_mix",
+            type: "audio_timeline",
+            inputs: mixInputs,
+            params: {
+                tracks: tracks.map((t) => ({
+                    slot: t.slot,
+                    start_s: t.start_s,
+                    ...(t.gain_db !== undefined ? { gain_db: t.gain_db } : {}),
+                })),
+                total_ms: Math.round((blueprint.source?.duration_s ?? lastSceneEnd(blueprint)) * 1000),
+            },
+        });
+        nodes.push({
+            id: "final",
+            type: "ffmpeg",
+            inputs: { video: videoRef, audio: "$ref:audio_mix.audio" },
+            params: {
+                args: [
+                    "-i",
+                    "{{in.video}}",
+                    "-i",
+                    "{{in.audio}}",
+                    "-map",
+                    "0:v:0",
+                    "-map",
+                    "1:a:0",
+                    "-c:v",
+                    "copy",
+                    "-c:a",
+                    "aac",
+                    "-shortest",
+                    "{{out.video}}",
+                ],
+                outputs: { video: { kind: "video", ext: "mp4" } },
+            },
+        });
+        videoNode = "final";
+    }
+    return {
+        schema: "baker-canvas/1",
+        metadata: {
+            name: "video reproduction",
+            description: VIDEO_GUIDE,
+            todo: buildVideoTodo(videoReport(input, elementsInput), overlays.length, floating.length, opts),
+        },
+        nodes,
+        output: { node: videoNode, output: "video" },
+    };
+}
+/** The step-by-step next-steps guide embedded in the canvas (and printed by the command). */
+const VIDEO_GUIDE = [
+    "Scaffolded by `baker canvas scaffold-video` — a runnable reproduction of your reference video. Each scene is two AI-generated boundary frames (start/end) animated into a clip, concatenated, overlaid with timed text, and mixed with voiceover + SFX + music. Edit it, supply the real assets, then run.",
+    "",
+    "WHAT TO DO NEXT:",
+    "1. Edit each frame's prompt IN PLACE. Every `s<i>_start` / `s<i>_end` node has its OWN self-contained `params.prompt` (the FRAME DESCRIPTION) — editing one changes only that frame. Rewrite the cast, product, claims, palette into the ad you want.",
+    "2. Drop ONE real source image at each `el_*` ingest `[TODO]` path. Each recurring element (person/product/logo) is reused across every frame it appears in, so the same identity stays consistent.",
+    "3. Confirm the `voice_select` casting (one per speaker). The voiceover is ONE continuous `tts` per speaker — punctuation, ALL-CAPS, and spacing are read verbatim by eleven_v3 for emphasis/pauses, so edit `params.text` to shape delivery.",
+    "4. Text overlays are composited on top (not baked into frames) by the `overlaid` node — edit the `overlays` array there. For on-brand type, drop `brand-bold.otf` / `brand-regular.otf` into the `video-overlay-composition/` dir (referenced via @font-face); otherwise a system font is used. You don't always need text — it's often cleaner to overlay it than bake it in.",
+    "5. `baker canvas validate` then `baker canvas run`. Running generates many billed image/video/audio assets — it is not free.",
+    "",
+    "Tip: `prompt.json` is the deconstruction provenance + the demoted GLOBAL STYLE REFERENCE each frame reads for shared palette/cast cohesion. It is NOT the per-frame editing surface — the frame nodes are.",
+].join("\n");
+/** Build the structured, in-canvas checklist mirroring the command's stdout report. */
+function buildVideoTodo(report, overlayCount, floatingCount, opts) {
+    return {
+        edit_frames_in_place: "Each s<i>_start / s<i>_end node has its own editable params.prompt (FRAME DESCRIPTION). Edit per frame; the blueprint is only a shared style reference.",
+        frames_mode: opts.frames ?? "generate",
+        recurring_elements_to_supply: report.elements,
+        voices_to_confirm: report.dialogue.map((d) => ({
+            scene: d.scene,
+            speaker: d.speaker,
+            voice_description: d.voice_description,
+            line: d.line,
+        })),
+        voiceover_note: "One continuous tts per speaker; same voice locked via voice_select.voice_id. Use punctuation / ALL CAPS / line breaks in params.text for emphasis and pacing (read verbatim).",
+        text_overlays: {
+            count: overlayCount,
+            note: "Composited by the `overlaid` node, animated per the blueprint (fade/pop/slide/typewriter/karaoke). Edit the `overlays` array. Drop brand-*.otf into video-overlay-composition/ for on-brand type.",
+        },
+        floating_elements: {
+            count: floatingCount,
+            note: floatingCount > 0
+                ? "Rendered as labeled placeholders. Replace with the real logo/sticker/cutout art (recurring logos are better handled as an el_* element baked into frames)."
+                : "none detected",
+        },
+        sound_effects: { count: report.sfx_count },
+        music: {
+            present: report.has_music,
+            note: report.has_music
+                ? "Original bed regenerated from the deconstruct prompt (styled after the AudD-identified track when available); ducked under the voices."
+                : "no music bed scaffolded",
+        },
+        scenes_clamped_to_15s: report.clamped_scenes,
+        run_warning: "`baker canvas run` generates many billed image/video/audio assets — validate first, it is not free.",
+    };
+}
+/** Human-facing checklist the command prints — what needs review/assets after scaffolding. */
+export function videoReport(input, elementsInput) {
+    const blueprint = VideoBlueprint.parse(input);
+    const elements = RecurringElements.parse(elementsInput);
+    const dialogue = [];
+    const clamped = [];
+    let sfxCount = 0;
+    let overlayCount = 0;
+    blueprint.scenes.forEach((scene, i) => {
+        for (const line of scene.dialogue ?? []) {
+            if (line.line) {
+                dialogue.push({
+                    scene: i,
+                    speaker: line.speaker ?? "voiceover",
+                    line: line.line,
+                    voice_description: line.voice_description ?? null,
+                });
+            }
+        }
+        sfxCount += (scene.sfx ?? []).length;
+        overlayCount += (scene.overlays ?? []).length;
+        const original = scene.duration_s ?? 5;
+        const clip = snapToSeedance(original);
+        if (original > 15)
+            clamped.push({ scene: i, original_s: original, clip_s: clip });
+    });
+    return {
+        scene_count: blueprint.scenes.length,
+        elements: assignElementLabels(elements).map(({ el, label }) => ({
+            label,
+            type: el.type,
+            description: el.description ?? null,
+            scenes: [...presenceOf(el).keys()].sort((a, b) => a - b),
+            asset_todo: todoPath(el, label),
+        })),
+        dialogue,
+        sfx_count: sfxCount,
+        overlay_count: overlayCount,
+        clamped_scenes: clamped,
+        has_music: Boolean(blueprint.global?.music?.music_prompt),
+    };
+}
+//# sourceMappingURL=video.js.map