@koda-sl/baker-cli 0.550.0 → 0.552.0

package/dist/scaffold-video-Y7X34F3N.js

@@ -0,0 +1,885 @@
+import {
+  stampCompositionDims
+} from "./chunk-5MBPIONY.js";
+import {
+  isValidScaffoldSlug,
+  resolveCastAvatars
+} from "./chunk-KXVJJQG6.js";
+import {
+  SHIPPED_CAPTIONS_DIR,
+  SHIPPED_OVERLAY_COMPOSITION_DIR,
+  fail,
+  fileExists,
+  loadAssetText,
+  parseElements,
+  resolveModel
+} from "./chunk-MZPS46OR.js";
+import {
+  readDefinitionPlatforms,
+  syncCreativeDefinitionBestEffort
+} from "./chunk-ZR3BISO2.js";
+import "./chunk-GUEFMO3G.js";
+import "./chunk-X45ABI5E.js";
+import {
+  REBUILD_FILE,
+  annotateBlueprintWithElements,
+  avatarsNotCast,
+  buildCreativeDefinition,
+  buildOverlayHtml,
+  cachedJev,
+  canvasDims,
+  castAvatarsOnElements,
+  computeSourceSha,
+  definitionPlatformsOf,
+  genAspectsFor,
+  languageCodeNamed,
+  readBlueprintSpeech,
+  renderStyleProjectionFromValue,
+  resolveAspect,
+  resolveFormats,
+  scaffoldVideoCanvas,
+  slimBlueprintForSelection,
+  spokenLanguage,
+  titleFromSlug,
+  videoReport,
+  voiceGenderModel,
+  writeSceneFiles
+} from "./chunk-26ALFAKU.js";
+import "./chunk-353QTP3X.js";
+import "./chunk-EKX37C3T.js";
+import "./chunk-OOGGID5L.js";
+import "./chunk-RKNSYZX3.js";
+import "./chunk-ZR5H5CZI.js";
+import "./chunk-J5RABWAF.js";
+import "./chunk-O3HSNUTL.js";
+import "./chunk-2YYOFA2A.js";
+import "./chunk-XGEJTRNF.js";
+import "./chunk-U73TWJRK.js";
+import "./chunk-MPQ5HUAO.js";
+import "./chunk-NNSDAAPZ.js";
+import {
+  holdUnbilledSpend
+} from "./chunk-6VVSAVMC.js";
+import {
+  findWorkspaceRoot,
+  resolveRelativeCanvasPaths
+} from "./chunk-3XJM5HX6.js";
+import {
+  ValidationError,
+  createEngineFromEnv,
+  defaultRegistry,
+  validateCanvasDeep
+} from "./chunk-Y5IMWZZN.js";
+import "./chunk-TMYLRI3S.js";
+import "./chunk-Z5AO4Y6W.js";
+import "./chunk-V4GSW4NH.js";
+import "./chunk-DGCUPJZD.js";
+import "./chunk-JGAF356Q.js";
+import "./chunk-NNQCVHVJ.js";
+import "./chunk-EZ6GOPHI.js";
+import {
+  AD_IMAGE_MODEL,
+  BLUEPRINT_ANALYSIS_MODEL,
+  DEFAULT_VIDEO_GENERATE_MODEL,
+  MODEL_ROLES,
+  SEEDANCE_DURATIONS,
+  VIDEO_DECONSTRUCT_MODEL
+} from "./chunk-MCJ5I5LR.js";
+import "./chunk-2WZI36D3.js";
+import "./chunk-65Y3RCWP.js";
+import {
+  askJevQuestions
+} from "./chunk-YUA6VVET.js";
+import {
+  MAX_ASSET_BYTES,
+  sha256Hex
+} from "./chunk-YKXSJGMA.js";
+import "./chunk-DF7IGB3K.js";
+import {
+  fetchExternalBytes
+} from "./chunk-PA5PS5KO.js";
+import "./chunk-RCNAKWK7.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-NSBNIPIW.js";
+import "./chunk-MSMTG6OC.js";
+import "./chunk-OQ7CLFEL.js";
+import "./chunk-S3TBE37M.js";
+import "./chunk-O4OPH3ZE.js";
+import "./chunk-VYEFXIEM.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/canvas/scaffold-video.ts
+import { cp, mkdir, readFile as readFile3, rm as rm2, writeFile } from "fs/promises";
+import { tmpdir as tmpdir2 } from "os";
+import path2 from "path";
+import { defineCommand } from "citty";
+
+// src/engine/scaffold/lib/model-router.ts
+var SEEDANCE = MODEL_ROLES.videoRouterWorkhorse.model;
+var VEO = MODEL_ROLES.videoRouterRealFace.model;
+var VEO_FAST = MODEL_ROLES.videoRouterRealFaceEconomy.model;
+var KLING = MODEL_ROLES.videoRouterMotion.model;
+var GEMINI_OMNI = MODEL_ROLES.videoDefault.model;
+function routeVideoModel(input) {
+  const budget = input.budget ?? "standard";
+  const signals = [];
+  if (input.hasRealFace) {
+    signals.push({ model: VEO, weight: 1200, because: "real human likeness \u2192 Veo (dodges the real-person filter)" });
+  }
+  if (input.needsMotionTransfer) {
+    signals.push({ model: KLING, weight: 800, because: "motion-transfer / dynamic multi-shot \u2192 Kling" });
+  }
+  if (input.needsIdentity && !input.hasRealFace) {
+    signals.push({ model: SEEDANCE, weight: 300, because: "identity/product consistency \u2192 Seedance workhorse" });
+  }
+  signals.push({ model: GEMINI_OMNI, weight: 100, because: "default \u2014 native audio in one call" });
+  const scores = { [SEEDANCE]: 0, [VEO]: 0, [VEO_FAST]: 0, [KLING]: 0, [GEMINI_OMNI]: 0 };
+  let top = signals[0];
+  for (const s of signals) {
+    scores[s.model] = (scores[s.model] ?? 0) + s.weight;
+    if ((scores[s.model] ?? 0) >= (scores[top.model] ?? 0)) top = s;
+  }
+  let model = top.model;
+  let reason = top.because;
+  if (model === VEO && budget === "economy") {
+    model = VEO_FAST;
+    reason = `${reason}, on the economy fast tier`;
+    scores[VEO_FAST] = scores[VEO] ?? 0;
+  }
+  return { model, reason, scores };
+}
+
+// src/engine/nodes/local/lib/sceneDetect.ts
+import { execFile } from "child_process";
+import { mkdtemp, readdir, readFile, rm } from "fs/promises";
+import { tmpdir } from "os";
+import { join } from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var PYSCENEDETECT_THRESHOLD = 18;
+var PYSCENEDETECT_MIN_SCENE_LEN_S = 0.25;
+var PYSCENEDETECT_RECHECK_THRESHOLD = 27;
+var PYSCENEDETECT_RECHECK_MIN_SCENE_LEN_S = 0.6;
+function isLikelyOverSegmented(cuts, opts = {}) {
+  const minCuts = opts.minCuts ?? 6;
+  const maxMedianGap = opts.medianGapS ?? 2;
+  const sorted = [...cuts].filter((c) => Number.isFinite(c) && c > 0).sort((a, b) => a - b);
+  if (sorted.length < minCuts) return false;
+  const gaps = [];
+  let prev = 0;
+  for (const c of sorted) {
+    gaps.push(c - prev);
+    prev = c;
+  }
+  gaps.sort((a, b) => a - b);
+  const mid = Math.floor(gaps.length / 2);
+  const median = gaps.length % 2 ? gaps[mid] : (gaps[mid - 1] + gaps[mid]) / 2;
+  return median < maxMedianGap;
+}
+function mergeRecheckCuts(firstPass, recheck, isolationS = 0.75) {
+  const kept = [...new Set(recheck)].sort((a, b) => a - b);
+  const extras = [...new Set(firstPass)].filter((c) => kept.every((k) => Math.abs(k - c) >= isolationS)).sort((a, b) => a - b);
+  const isolated = extras.filter((c, i) => {
+    const prev = extras[i - 1];
+    const next = extras[i + 1];
+    return (prev === void 0 || c - prev >= isolationS) && (next === void 0 || next - c >= isolationS);
+  });
+  return [.../* @__PURE__ */ new Set([...kept, ...isolated])].sort((a, b) => a - b);
+}
+function timecodeToSeconds(tc) {
+  const m = tc.trim().match(/^(\d+):(\d{1,2}):(\d{1,2}(?:\.\d+)?)$/);
+  if (!m) return null;
+  const h = Number.parseInt(m[1] ?? "", 10);
+  const min = Number.parseInt(m[2] ?? "", 10);
+  const s = Number.parseFloat(m[3] ?? "");
+  if (!Number.isFinite(h) || !Number.isFinite(min) || !Number.isFinite(s)) return null;
+  return h * 3600 + min * 60 + s;
+}
+function parsePySceneDetectCsvCuts(csv) {
+  const firstLine = csv.split(/\r?\n/, 1)[0] ?? "";
+  if (!/^\s*Timecode List:/i.test(firstLine)) return [];
+  const cuts = [];
+  for (const cell of firstLine.split(",").slice(1)) {
+    const t = timecodeToSeconds(cell);
+    if (t !== null && t > 0) cuts.push(Math.round(t * 1e3) / 1e3);
+  }
+  return [...new Set(cuts)].sort((a, b) => a - b);
+}
+async function runSceneDetectOnce(filePath, threshold, minSceneLenS, timeoutMs) {
+  const outDir = await mkdtemp(join(tmpdir(), "baker-scenedetect-"));
+  try {
+    await execFileAsync(
+      "scenedetect",
+      [
+        "--input",
+        filePath,
+        "--output",
+        outDir,
+        "detect-content",
+        "--threshold",
+        String(threshold),
+        "--min-scene-len",
+        String(minSceneLenS),
+        "list-scenes",
+        "--quiet"
+      ],
+      { encoding: "utf-8", maxBuffer: 32 * 1024 * 1024, timeout: timeoutMs }
+    );
+    const csvName = (await readdir(outDir)).find((f) => f.toLowerCase().endsWith(".csv"));
+    if (!csvName) return [];
+    return parsePySceneDetectCsvCuts(await readFile(join(outDir, csvName), "utf-8"));
+  } finally {
+    await rm(outDir, { recursive: true, force: true });
+  }
+}
+async function detectSceneCutsPySceneDetect(filePath, opts = {}) {
+  const pinned = opts.threshold !== void 0;
+  const threshold = opts.threshold ?? PYSCENEDETECT_THRESHOLD;
+  const minSceneLenS = opts.minSceneLenS ?? PYSCENEDETECT_MIN_SCENE_LEN_S;
+  const timeoutMs = opts.timeout_ms ?? 12e4;
+  const cuts = await runSceneDetectOnce(filePath, threshold, minSceneLenS, timeoutMs);
+  if (!pinned && isLikelyOverSegmented(cuts)) {
+    const rechecked = await runSceneDetectOnce(
+      filePath,
+      PYSCENEDETECT_RECHECK_THRESHOLD,
+      PYSCENEDETECT_RECHECK_MIN_SCENE_LEN_S,
+      timeoutMs
+    );
+    return mergeRecheckCuts(cuts, rechecked);
+  }
+  return cuts;
+}
+
+// src/commands/canvas/gitignore.ts
+import { appendFile, readFile as readFile2 } from "fs/promises";
+import path from "path";
+function missingGitignoreEntries(existing, entries) {
+  const present = new Set(
+    existing.split("\n").map((l) => l.trim().replace(/\/+$/, "")).filter((l) => l.length > 0 && !l.startsWith("#"))
+  );
+  return entries.filter((e) => !present.has(e.trim().replace(/\/+$/, "")));
+}
+async function ensureGitignore(dir, entries) {
+  const file = path.join(dir, ".gitignore");
+  let existing;
+  try {
+    existing = await readFile2(file, "utf8");
+  } catch {
+    return;
+  }
+  const missing = missingGitignoreEntries(existing, entries);
+  if (missing.length === 0) return;
+  const prefix = existing.endsWith("\n") || existing.length === 0 ? "" : "\n";
+  await appendFile(file, `${prefix}
+# Baker canvas (engine cache + scaffold working files)
+${missing.join("\n")}
+`);
+}
+
+// src/commands/canvas/scaffold-video.ts
+var SELECT_SYSTEM = 'You identify the RECURRING, identity-critical visual elements of a video ad from its deconstruction blueprint \u2014 the people, animals, products, and logos that must stay consistent every time they appear, so a faithful reproduction grounds each in ONE real reference image reused across every frame it appears in. Output ONLY a JSON object of the form { "elements": [ ... ] }, no prose.';
+var SELECT_PROMPT = `VIDEO DECONSTRUCTION BLUEPRINT (video-deconstruct/1):
+{{blueprint}}
+
+List ONLY the elements worth keeping consistent across frames \u2014 the ones a reproduction must ground in a real asset:
+- each recurring person from global.cast (a presenter/actor/persona) -> type "person"
+- a recurring animal/pet/character with a stable identity -> type "animal"
+- a showcased product, package, card, or device the ad sells or demonstrates -> type "product"
+- the advertiser brand logo/wordmark (from global.branding) -> type "logo"
+- a recurring trust/rating/certification badge -> type "badge"
+- the dominant recording set/location the scenes share (e.g. the same living room, car interior, kitchen) -> type "location"
+
+DROP one-off background extras and incidental props \u2014 but the shared set/location is NOT generic scenery: pin it as ONE "location" element so the room stays identical across scenes. A person in global.cast is almost always recurring. Keep at most ~8.
+
+ONE PERSON, MULTIPLE LOOKS: if a single individual plays MULTIPLE personas or wardrobes (e.g. a creator as a skeptic in one outfit and a believer in another, or a before/after), emit ONE element PER look (so each outfit gets its own real reference image) and link the extra looks to the first via "same_as" \u2014 they are the SAME person, only the wardrobe/state differs, so the face must stay identical.
+
+For each kept element return: { "type": one of person|animal|product|logo|badge|location, "label": a short UPPER_SNAKE_CASE name (e.g. HERO, CREATOR_SKEPTIC, INSURANCE_CARD, LOGO), "description": a concrete reusable description to source/shoot the real asset \u2014 for a person/animal give a NEUTRAL castable role (e.g. "hero pet-owner, woman in her 30s" or "a small beagle"), NOT the original individual's literal face/identity: we RECAST with a FRESH person/animal, so never tell the agent to reuse the original. "expression": a living subject's typical expression or null, "cast_id": the global.cast id if it maps to one else null, "same_as": the label of another element this is the SAME individual as (different wardrobe/persona) else null, "scenes": the 0-based indices of ONLY the scenes where the element is ACTUALLY VISIBLE ON SCREEN \u2014 judged from that scene's start_frame_prompt / end_frame_prompt subjects and its action_detail, NOT from who is merely speaking. A narrator heard over b-roll is NOT present in that b-roll scene; a dog-running cutaway does NOT contain the couch creator just because she talks across it. Do NOT pad the list \u2014 an element wrongly listed in a scene makes the reproduction render the wrong subject there (e.g. the creator appearing in a pure-dog b-roll). When in doubt, leave a scene OUT. Output ONLY the JSON object.`;
+async function loadTranscriptBestEffort(ref) {
+  if (!ref) return void 0;
+  try {
+    return await loadAssetText(ref, "deconstruct transcript");
+  } catch {
+    return void 0;
+  }
+}
+async function stageCaptions(outDir, transcript) {
+  const text = transcript?.trim();
+  if (!text || text === "[]") return {};
+  const compositionPath = path2.join(outDir, "tiktok-captions-composition");
+  await cp(SHIPPED_CAPTIONS_DIR, compositionPath, { recursive: true });
+  return { compositionPath };
+}
+async function detectShotCutsBestEffort(videoPath, threshold) {
+  try {
+    const cuts = await detectSceneCutsPySceneDetect(videoPath, threshold ? { threshold } : {});
+    if (cuts.length > 0) {
+      process.stderr.write(`Detected ${cuts.length} shot cut(s) via PySceneDetect: ${cuts.join(", ")}s
+`);
+    } else {
+      process.stderr.write("PySceneDetect ran but found no hard cuts; using LLM scene boundaries.\n");
+    }
+    return cuts;
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    const code = e?.code;
+    const missing = code === "ENOENT" || /ENOENT|not found|command not found/i.test(msg);
+    if (missing) {
+      process.stderr.write(
+        "WARNING: `scenedetect` (PySceneDetect) is NOT installed \u2014 falling back to LLM-only scene boundaries, which under-segments (coarse 9-15s scenes instead of the real 1-4s cuts). Install it (`pipx install scenedetect[opencv]` or `pip install scenedetect[opencv]`) for accurate shot-cut detection.\n"
+      );
+    } else {
+      process.stderr.write(`Shot-cut detection skipped (${msg}); using LLM boundaries.
+`);
+    }
+    return void 0;
+  }
+}
+var VIDEO_EXT_BY_MIME = {
+  "video/mp4": ".mp4",
+  "video/quicktime": ".mov",
+  "video/webm": ".webm",
+  "video/x-matroska": ".mkv"
+};
+function referenceVideoExt(url, contentType) {
+  const fromPath = path2.extname(new URL(url).pathname).toLowerCase();
+  if (fromPath && fromPath.length <= 5) return fromPath;
+  const mime = (contentType ?? "").split(";")[0]?.trim().toLowerCase();
+  return mime && VIDEO_EXT_BY_MIME[mime] || ".mp4";
+}
+function videoSourceReference(blueprint, fileArg) {
+  const bp = blueprint ?? {};
+  const durable = typeof bp.source?.url === "string" ? bp.source.url : void 0;
+  const original = /^https?:\/\//i.test(fileArg) ? fileArg : void 0;
+  const brand = bp.global?.branding?.brand_name;
+  return { url: durable ?? original, advertiser: typeof brand === "string" && brand.trim() ? brand.trim() : void 0 };
+}
+function videoDefinitionDescription(blueprint) {
+  const g = (blueprint ?? {}).global ?? {};
+  const notes = g.reproduction_notes;
+  if (typeof notes === "string" && notes.trim()) return notes.trim();
+  const product = g.branding?.product;
+  return typeof product === "string" && product.trim() ? product.trim() : void 0;
+}
+function framesModeReport(canvas, requested) {
+  const todo = canvas.metadata?.todo;
+  const mode = typeof todo?.frames_mode === "string" ? todo.frames_mode : requested;
+  const refused = typeof todo?.frames_reuse_refused === "string" ? todo.frames_reuse_refused : void 0;
+  return { frames_mode: mode, ...refused ? { frames_reuse_refused: refused } : {} };
+}
+async function materializeReferenceVideo(fileArg) {
+  if (!/^https?:\/\//i.test(fileArg)) return path2.resolve(fileArg);
+  let bytes;
+  let contentType;
+  try {
+    ({ buffer: bytes, contentType } = await fetchExternalBytes(fileArg, {
+      sniffChallenge: false,
+      maxBytes: MAX_ASSET_BYTES
+    }));
+  } catch (e) {
+    throw new Error(`failed to download reference video: ${e instanceof Error ? e.message : String(e)}`);
+  }
+  if (bytes.length === 0) throw new Error("reference video download was empty");
+  const dest = path2.join(
+    tmpdir2(),
+    `baker-ref-${sha256Hex(bytes).slice(0, 16)}${referenceVideoExt(fileArg, contentType)}`
+  );
+  await writeFile(dest, bytes);
+  return dest;
+}
+function resolveSeamDedup(raw) {
+  if (raw === void 0) return "head";
+  const v = String(raw);
+  if (v === "head" || v === "tail" || v === "off") return v;
+  throw new Error(`--seam-dedup must be "head", "tail", or "off" (got "${v}")`);
+}
+var VIDEO_BUDGETS = ["economy", "standard", "premium"];
+function parseBudget(raw) {
+  const v = raw === void 0 ? "standard" : String(raw);
+  if (VIDEO_BUDGETS.includes(v)) return v;
+  throw new Error(`--budget must be one of ${VIDEO_BUDGETS.join(", ")} (got "${v}")`);
+}
+function resolveModels(args) {
+  return {
+    // Flash by default (the `videoDeconstruct` role). Override with --deconstruct-model
+    // ~google/gemini-pro-latest for the densest extraction when speed matters less.
+    deconstructModel: resolveModel("video_deconstruct", args["deconstruct-model"], VIDEO_DECONSTRUCT_MODEL),
+    selectModel: resolveModel("text_generate", args["select-model"], BLUEPRINT_ANALYSIS_MODEL),
+    // The ad-frame model (matches the static-ad scaffold); the frame generators need the
+    // most faithful text/identity reproduction. Override with --image-model for a
+    // cheaper/faster pass.
+    imageModel: resolveModel("image_generate", args["image-model"], AD_IMAGE_MODEL)
+  };
+}
+function hasPhotorealCast(elements) {
+  return Array.isArray(elements) && elements.some((e) => {
+    const type = typeof e === "object" && e !== null ? e.type : void 0;
+    return type === "person" || type === "animal";
+  });
+}
+function resolveVideoModel(args, elements) {
+  if (args["video-model"]) {
+    return { videoModel: resolveModel("video_generate", args["video-model"], DEFAULT_VIDEO_GENERATE_MODEL) };
+  }
+  const photorealCast = hasPhotorealCast(elements);
+  const route = routeVideoModel({
+    hasRealFace: Boolean(args["real-face"]) || photorealCast,
+    needsIdentity: Boolean(args.identity),
+    needsMotionTransfer: Boolean(args["motion-transfer"]),
+    budget: parseBudget(args.budget)
+  });
+  const reason = photorealCast && !args["real-face"] ? `${route.reason} \u2014 detected a photoreal on-camera cast, which Seedance's real-person filter would block` : route.reason;
+  return {
+    videoModel: resolveModel("video_generate", route.model, DEFAULT_VIDEO_GENERATE_MODEL),
+    videoRouteReason: reason
+  };
+}
+function buildDeconstructCanvas(videoPath, deconstructModel, opts) {
+  const deconstructParams = { model: deconstructModel, mode: "full" };
+  if (typeof opts.maxScenes === "number") deconstructParams.max_scenes = opts.maxScenes;
+  if (opts.language) deconstructParams.language = opts.language;
+  if (opts.focus) deconstructParams.focus = opts.focus;
+  if (opts.shotCuts) deconstructParams.shot_cuts = opts.shotCuts;
+  deconstructParams.max_clip_s = SEEDANCE_DURATIONS[SEEDANCE_DURATIONS.length - 1];
+  return {
+    schema: "baker-canvas/1",
+    metadata: { name: "video deconstruct pass" },
+    nodes: [
+      { id: "src", type: "ingest", params: { source: "path", path: videoPath, expect: "video" } },
+      { id: "deconstruct", type: "video_deconstruct", inputs: { video: "$ref:src.asset" }, params: deconstructParams }
+    ],
+    output: { node: "deconstruct", output: "analysis" }
+  };
+}
+function buildSelectCanvas(selectModel, slimmedBlueprintJson) {
+  return {
+    schema: "baker-canvas/1",
+    metadata: { name: "element selection pass" },
+    nodes: [
+      {
+        id: "select",
+        type: "text_generate",
+        params: {
+          model: selectModel,
+          max_tokens: 6e3,
+          temperature: 0,
+          response_format: "json_object",
+          system: SELECT_SYSTEM,
+          prompt: SELECT_PROMPT.replace("{{blueprint}}", () => slimmedBlueprintJson)
+        }
+      }
+    ],
+    output: { node: "select", output: "text" }
+  };
+}
+async function runAnalysisPasses(deconstructCanvas, selectModel) {
+  const engine = createEngineFromEnv({ log: (line) => process.stderr.write(`${line}
+`) });
+  let credits = 0;
+  let sawCredits = false;
+  const addCredits = (stats) => {
+    const c = stats?.total_credits;
+    if (typeof c === "number") {
+      credits += c;
+      sawCredits = true;
+    }
+  };
+  let blueprint;
+  let transcript;
+  let detectedLanguage;
+  try {
+    const r1 = await engine.run(deconstructCanvas, {});
+    addCredits(r1.stats);
+    blueprint = JSON.parse(await loadAssetText(r1.outputs_by_node.deconstruct?.analysis, "deconstruct output"));
+    transcript = await loadTranscriptBestEffort(r1.outputs_by_node.deconstruct?.transcript);
+    const heard = r1.outputs_by_node.deconstruct?.transcript?.metadata?.detected_language;
+    detectedLanguage = typeof heard === "string" && heard.trim() ? heard.trim() : void 0;
+  } catch (e) {
+    if (e instanceof ValidationError) return fail("validation", JSON.stringify(e.issues));
+    if (e instanceof SyntaxError) return fail("read_outputs", e.message);
+    return fail("deconstruct", e instanceof Error ? e.message : String(e));
+  }
+  const slimJson = JSON.stringify(slimBlueprintForSelection(blueprint));
+  try {
+    const r2 = await engine.run(buildSelectCanvas(selectModel, slimJson), {});
+    addCredits(r2.stats);
+    const elements = parseElements(await loadAssetText(r2.outputs_by_node.select?.text, "selection output"));
+    return { blueprint, elements, transcript, detectedLanguage, creditsSpent: sawCredits ? credits : void 0 };
+  } catch (e) {
+    if (e instanceof ValidationError) return fail("validation", JSON.stringify(e.issues));
+    if (e instanceof SyntaxError) return fail("read_outputs", e.message);
+    return fail("deconstruct", e instanceof Error ? e.message : String(e));
+  }
+}
+var scaffoldVideoCommand = defineCommand({
+  meta: {
+    name: "scaffold-video",
+    description: "Turn a reference video into a runnable reproduction canvas in one command. Runs billed passes \u2014 video_deconstruct (the full scene-by-scene blueprint + transcript, baked to a split, editable blueprint: a global prompt.json plus one small scenes/sNN.json per scene) and an AI selection of the video's RECURRING identity elements (person/animal/product/logo) \u2014 then scaffolds a pipeline where every scene boundary is a static-ad-grade frame (the blueprint as target_blueprint, a reference legend, the real frame as anchor) and each recurring element gets ONE shared [TODO] ingest slot wired into every frame it appears in. The clips feed Seedance an ultra-detailed motion brief (action, camera, dialogue, transcript). Edit a scene's scenes/sNN.json (or prompt.json for global cast/palette/brand), fill the remaining [TODO] images, then `baker canvas run`. A person in the reference is played by an invented, realistic person generated from their description \u2014 never the source actor and never a photo of anyone real; pass `--avatar <handle>` (`baker avatars list`) when the same actor has to recur across the company's ads."
+  },
+  args: {
+    file: {
+      type: "positional",
+      required: true,
+      description: "Reference video \u2014 a local path OR an http(s) URL (e.g. a winning-ads link). A URL is downloaded for you; pass --slug or --out with it."
+    },
+    out: { type: "string", description: "Output canvas path (default <video-dir>/<name>.video.canvas.json)" },
+    slug: {
+      type: "string",
+      description: "Creative slug \u2014 writes the canvas to src/creatives/<slug>/<slug>.canvas.json (repo convention)"
+    },
+    frames: {
+      type: "string",
+      description: `"generate" (default, every frame regenerated for our ad) or "reuse" (wire the source's real frames in). Reuse applies only to a video with nobody in it \u2014 on a video showing people it is refused and every frame is generated, so the source's actors never reach our ad.`
+    },
+    ambient: {
+      type: "boolean",
+      description: "Give silent b-roll scenes native diegetic ambient mixed deep under the music bed (off by default)"
+    },
+    "seam-dedup": {
+      type: "string",
+      description: `How to dedup the frame two clips SHARE when a long shot is split for length: "head" (default, drop the second clip's first frame), "tail" (drop the first clip's last frame), or "off" (keep both).`
+    },
+    "max-scenes": { type: "string", description: "Cap the number of scenes the deconstruct emits" },
+    "shot-threshold": {
+      type: "string",
+      description: "PySceneDetect content threshold. Default is adaptive (18, auto re-checked at 27 when a continuous shot looks over-segmented); pinning a value disables the re-check. Lower = more/softer cuts, higher = fewer."
+    },
+    language: { type: "string", description: "Transcript/dialogue language hint (e.g. fr, en)" },
+    focus: { type: "string", description: "Known provenance/emphasis to ground the deconstruct" },
+    advertiser: {
+      type: "string",
+      description: "Source advertiser recorded in _definition.md (default: the brand the deconstruct identified)"
+    },
+    platforms: {
+      type: "string",
+      description: "Where the ad runs, the main platform first (meta, linkedin, tiktok, \u2026): recorded in _definition.md. Take it from the person's request or the idea."
+    },
+    platform: { type: "string", description: "Retired: use --platforms. Still recorded in _definition.md." },
+    "deconstruct-model": { type: "string", description: "Override the video_deconstruct model id" },
+    "select-model": { type: "string", description: "Override the text_generate model id for element selection" },
+    "image-model": { type: "string", description: "Override the image_generate model id for frames" },
+    "video-model": { type: "string", description: "Override the video_generate model id for clips (skips the scored router)" },
+    "real-face": {
+      type: "boolean",
+      description: "The ad has a photoreal human face on camera \u2192 the router picks Veo (dodges the ByteDance real-person filter). Set this for ANY photoreal presenter/creator/testimonial cast \u2014 the filter blocks AI-GENERATED photoreal faces too, not just real ones."
+    },
+    "motion-transfer": {
+      type: "boolean",
+      description: "Motion driven from a reference video / deliberately hyper-dynamic \u2192 the router picks Kling."
+    },
+    identity: {
+      type: "boolean",
+      description: "The same character/product must stay consistent across clips \u2192 the router picks the Seedance workhorse."
+    },
+    budget: {
+      type: "string",
+      description: 'Cost posture for the router: "economy" | "standard" | "premium" (default standard).'
+    },
+    aspect: {
+      type: "string",
+      description: `Output aspect ratio (e.g. "4:5"). Default: the source video's detected ratio. When the video model can't generate the ratio (Seedance has no 4:5) clips generate at the nearest supported ratio and are center-cropped onto the output canvas.`
+    },
+    resolution: {
+      type: "string",
+      description: `Output resolution for generated clips (e.g. "1080p"). Default 1080p \u2014 the highest the video model supports \u2014 so clips keep the keyframe sharpness instead of the model's low default.`
+    },
+    avatar: {
+      type: "string",
+      description: "Cast company avatars as the reference's people \u2014 pass this when the same actor has to recur across ads (without it, each person is invented from their description). One handle, or several comma-separated in the order the people appear (`--avatar marta` / `--avatar marta,joan`). Each recurring person grounds on that avatar's identity sheet, so the ad shows the company's own cast instead of the source ad's actors. `baker avatars list` shows who there is; checked before anything is billed."
+    }
+  },
+  async run({ args }) {
+    const fileArg = String(args.file);
+    const slug = args.slug ? String(args.slug) : void 0;
+    if (slug && !isValidScaffoldSlug(slug)) {
+      process.stderr.write(
+        `${JSON.stringify({ ok: false, error: { code: "invalid_slug", message: "--slug must be lowercase kebab (a-z, 0-9, hyphens), max 100 chars" } }, null, 2)}
+`
+      );
+      process.exit(2);
+    }
+    const isUrl = /^https?:\/\//i.test(fileArg);
+    if (isUrl && !slug && !args.out) {
+      return fail(
+        "missing_output_target",
+        "When the reference is a URL, pass --slug (writes src/creatives/<slug>/) or --out <path> so the scaffolded canvas has a home in the repo."
+      );
+    }
+    let videoPath;
+    try {
+      videoPath = await materializeReferenceVideo(fileArg);
+    } catch (e) {
+      return fail("download", e instanceof Error ? e.message : String(e));
+    }
+    const base = path2.basename(videoPath, path2.extname(videoPath));
+    const outPath = args.out ? path2.resolve(String(args.out)) : slug ? path2.join(process.cwd(), "src", "creatives", slug, `${slug}.canvas.json`) : path2.join(path2.dirname(videoPath), `${base}.video.canvas.json`);
+    const outDir = path2.dirname(outPath);
+    const blueprintPath = path2.join(outDir, "prompt.json");
+    const blueprintStylePath = path2.join(outDir, "prompt.style.json");
+    const frames = args.frames === "reuse" ? "reuse" : "generate";
+    const maxScenes = args["max-scenes"] ? Number(args["max-scenes"]) : void 0;
+    if (Number.isFinite(maxScenes)) {
+      process.stderr.write(
+        `\u26A0\uFE0F  --max-scenes ${maxScenes} caps the deconstruct: any scenes beyond ${maxScenes} are MERGED away, reducing fidelity (fewer cuts, lost beats). Omit it to reproduce every scene.
+`
+      );
+    }
+    let models;
+    try {
+      models = resolveModels(args);
+      if (args["video-model"]) resolveModel("video_generate", args["video-model"], DEFAULT_VIDEO_GENERATE_MODEL);
+    } catch (e) {
+      return fail("unknown_model", e instanceof Error ? e.message : String(e));
+    }
+    const { deconstructModel, selectModel, imageModel } = models;
+    const cast = await resolveCastAvatars(args.avatar);
+    if ("error" in cast) return fail("avatar", cast.error);
+    const { handles: avatarHandles, avatars } = cast;
+    const shotThreshold = args["shot-threshold"] ? Number(args["shot-threshold"]) : void 0;
+    const shotCuts = await detectShotCutsBestEffort(videoPath, shotThreshold);
+    const deconstructCanvas = buildDeconstructCanvas(videoPath, deconstructModel, {
+      maxScenes: Number.isFinite(maxScenes) ? maxScenes : void 0,
+      language: args.language ? String(args.language) : void 0,
+      focus: args.focus ? String(args.focus) : void 0,
+      shotCuts
+    });
+    const analysis = await runAnalysisPasses(deconstructCanvas, selectModel);
+    const { blueprint, transcript, creditsSpent } = analysis;
+    const heard = analysis.detectedLanguage;
+    const declaredLanguage = (args.language ? spokenLanguage(String(args.language))?.tag : void 0) ?? (heard ? spokenLanguage(heard)?.tag ?? languageCodeNamed(heard) : void 0);
+    const speechCache = path2.join(findWorkspaceRoot(outDir) ?? process.cwd(), "canvas", ".cache");
+    const speechSpent = [];
+    const speech = await readBlueprintSpeech(
+      blueprint,
+      declaredLanguage ? { declaredLanguage } : {},
+      {
+        ask: cachedJev(speechCache, (questions) => askJevQuestions(questions, (u) => speechSpent.push(u))),
+        genders: voiceGenderModel(speechCache, (u) => speechSpent.push(u))
+      }
+    );
+    await holdUnbilledSpend(speechCache, speechSpent).catch(() => {
+    });
+    const elements = castAvatarsOnElements(analysis.elements, avatars);
+    const uncast = avatarsNotCast(analysis.elements, avatarHandles);
+    const uncastHint = uncast.length ? {
+      hints: [
+        `NOT CAST: ${uncast.map((h) => `\`${h}\``).join(", ")} \u2014 the element selection found no more recurring people than it cast, so ${uncast.length === 1 ? "this avatar plays" : "these avatars play"} nobody in this canvas. A person shown in only one scene is not a recurring element, so those frames render whoever their scene file describes \u2014 tell the user who is cast and who is not.`
+      ]
+    } : {};
+    let routed;
+    try {
+      routed = resolveVideoModel(args, elements);
+    } catch (e) {
+      return fail("unknown_model", e instanceof Error ? e.message : String(e));
+    }
+    const { videoModel, videoRouteReason } = routed;
+    if (videoRouteReason && !args["video-model"] && !args["real-face"] && hasPhotorealCast(elements)) {
+      process.stderr.write(`\u{1F3AC} Photoreal on-camera cast detected \u2192 generating clips on ${videoModel} (dodges Seedance's real-person filter).
+`);
+    }
+    await mkdir(outDir, { recursive: true });
+    const annotated = annotateBlueprintWithElements(blueprint, elements);
+    await writeSceneFiles(outDir, annotated);
+    await writeFile(blueprintStylePath, renderStyleProjectionFromValue(annotated), "utf8");
+    let aspect;
+    try {
+      aspect = resolveAspect(
+        blueprint.source?.aspect_ratio,
+        args.aspect ? String(args.aspect) : void 0,
+        genAspectsFor(videoModel)
+      );
+    } catch (e) {
+      return fail("aspect", e instanceof Error ? e.message : String(e));
+    }
+    const outDims = canvasDims(aspect.outAr);
+    if (aspect.remapped) {
+      process.stderr.write(
+        `\u26A0\uFE0F  ${aspect.outAr} output \u2192 clips generate at ${aspect.genAr} (the video model's nearest ratio) and are center-cropped to ${aspect.outAr} (${outDims.w}\xD7${outDims.h}) \u2014 keep subjects centered in frame prompts.
+`
+      );
+    }
+    const compositionDest = path2.join(outDir, "video-overlay-composition");
+    await cp(SHIPPED_OVERLAY_COMPOSITION_DIR, compositionDest, { recursive: true });
+    await stampCompositionDims(compositionDest, outDims);
+    const indexPath = path2.join(compositionDest, "index.html");
+    const overlayHtml = buildOverlayHtml(blueprint, { captionsActive: Boolean(transcript), videoModel });
+    const indexHtml = await readFile3(indexPath, "utf8");
+    const injected = indexHtml.replace("<!--OVERLAYS-->", () => overlayHtml);
+    if (injected === indexHtml && overlayHtml.trim()) {
+      fail(
+        "composition_marker_missing",
+        `video-overlay-composition/index.html is missing the <!--OVERLAYS--> marker \u2014 cannot inject the overlay layer`
+      );
+    }
+    await writeFile(indexPath, injected, "utf8");
+    const captions = await stageCaptions(outDir, transcript);
+    if (captions.compositionPath) await stampCompositionDims(captions.compositionPath, outDims);
+    const opts = {
+      imageModel,
+      videoModel,
+      overlayCompositionPath: path2.relative(outDir, compositionDest),
+      captionsCompositionPath: captions.compositionPath ? path2.relative(outDir, captions.compositionPath) : void 0,
+      blueprintPath: path2.relative(outDir, blueprintPath),
+      blueprintStylePath: path2.relative(outDir, blueprintStylePath),
+      frames,
+      ambient: Boolean(args.ambient),
+      seamDedup: resolveSeamDedup(args["seam-dedup"]),
+      ...speech.spokenLanguage ? { spokenLanguage: speech.spokenLanguage } : {},
+      voiceGenders: speech.voiceGenders,
+      ...speech.captionCarriesOn.length ? { captionCarriesOn: speech.captionCarriesOn } : {},
+      ...args.aspect ? { aspect: String(args.aspect) } : {},
+      ...args.resolution ? { resolution: String(args.resolution) } : {}
+    };
+    let canvas;
+    let report;
+    try {
+      canvas = scaffoldVideoCanvas(blueprint, elements, opts);
+      report = videoReport(blueprint, elements, videoModel);
+    } catch (e) {
+      return fail("scaffold", e instanceof Error ? e.message : String(e));
+    }
+    if (captions.compositionPath && !canvas.nodes.some((n) => n.id === "captions")) {
+      await rm2(captions.compositionPath, { recursive: true, force: true });
+    }
+    const validation = await validateCanvasDeep(resolveRelativeCanvasPaths(canvas, outDir), defaultRegistry());
+    if (!validation.ok) {
+      const meta = canvas.metadata;
+      const todo = meta.todo ?? {};
+      todo.blocking_validation_issues = validation.issues;
+      meta.todo = todo;
+    }
+    await writeFile(outPath, `${JSON.stringify(canvas, null, 2)}
+`, "utf8");
+    await writeFile(
+      path2.join(outDir, REBUILD_FILE),
+      `${JSON.stringify({ elements, opts }, null, 2)}
+`,
+      "utf8"
+    );
+    if (!validation.ok) {
+      process.stderr.write(
+        `${JSON.stringify(
+          {
+            ok: false,
+            error: { code: "validation", issues: validation.issues },
+            canvas_path: outPath,
+            prompt_path: blueprintPath,
+            ...framesModeReport(canvas, frames),
+            note: "The canvas WAS written despite the blocking issue(s) \u2014 fix them in place, then `baker canvas validate` before running.",
+            ...uncastHint
+          },
+          null,
+          2
+        )}
+`
+      );
+      process.exit(2);
+    }
+    await ensureGitignore(process.cwd(), ["canvas/", ".context/"]);
+    const sourceRef = videoSourceReference(blueprint, fileArg);
+    if (slug) {
+      const definitionPath = path2.join(outDir, "_definition.md");
+      if (!await fileExists(definitionPath)) {
+        await writeFile(
+          definitionPath,
+          buildCreativeDefinition({
+            title: titleFromSlug(slug),
+            kind: "video",
+            ...definitionPlatformsOf(
+              args.platforms ? String(args.platforms) : void 0,
+              args.platform ? String(args.platform) : void 0
+            ),
+            formats: resolveFormats(aspect.outAr),
+            sourceReferenceUrl: sourceRef.url,
+            sourceAdvertiser: args.advertiser ? String(args.advertiser) : sourceRef.advertiser,
+            sourceKind: "video",
+            description: videoDefinitionDescription(blueprint)
+          }),
+          "utf8"
+        );
+      }
+    }
+    if (slug) {
+      await syncCreativeDefinitionBestEffort({
+        slug,
+        title: titleFromSlug(slug),
+        ...await readDefinitionPlatforms(outPath),
+        formats: [aspect.outAr],
+        canvas,
+        sourceReferenceUrl: sourceRef.url,
+        sourceSha: await computeSourceSha(outPath)
+      });
+    }
+    process.stdout.write(
+      `${JSON.stringify(
+        {
+          ok: true,
+          canvas_path: outPath,
+          prompt_path: blueprintPath,
+          source_reference: sourceRef.url,
+          composition_dir: compositionDest,
+          output: canvas.output,
+          ...uncastHint,
+          ...framesModeReport(canvas, frames),
+          models: {
+            deconstruct: deconstructModel,
+            select: selectModel,
+            image: imageModel,
+            video: videoModel,
+            ...videoRouteReason ? { video_route_reason: videoRouteReason } : {}
+          },
+          stats: {
+            scene_count: report.scene_count,
+            total_nodes: canvas.nodes.length,
+            analysis_credits_spent: creditsSpent,
+            run_estimated_credits: validation.estimatedCredits,
+            // WHY the graph has its nodes: per-scene routes + the node-type histogram
+            // (mirrors metadata.video.graph_stats in the canvas).
+            graph: canvas.metadata?.video?.graph_stats
+          },
+          checklist: {
+            edit_prompt: `The blueprint is split so you edit ONE small file at a time \u2014 never a giant one. Per-scene content (a scene's dialogue, action, frame prompts, overlays) lives in \`scenes/sNN.json\` \u2014 edit the single scene you want to change. Global cast/palette/brand/copy lives in \`${path2.basename(blueprintPath)}\`. \`baker canvas validate\`/\`run\` re-assemble the blueprint and re-flow every edited scene back into the render (and regenerate ${path2.basename(blueprintStylePath)}, the projection each frame's target_blueprint reads) \u2014 so your scene edits reach the render automatically. Never hand-edit the inlined node prompts in the canvas or the derived ${path2.basename(blueprintStylePath)}; both are regenerated.`,
+            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
+            })),
+            sfx_count: report.sfx_count,
+            overlay_count: report.overlay_count,
+            has_music: report.has_music,
+            scenes_clamped_to_clip_max: report.clamped_scenes,
+            oversize_scenes: report.oversize_scenes,
+            overstuffed_scenes: report.overstuffed_scenes,
+            // Steer the edit toward disciplined prompting + on-brand MOTION, not just
+            // on-brand color. The overlays inherit the reference's motion unless the
+            // operator restyles easing/transition/accent from the brand's motion language.
+            prompt_discipline: "Rewrite each scene with the six-decision structure (Route / Spec / Beats / Copy / Technique / Negatives): quote exact copy, give every beat a timestamp, and name the moves. Pull easing, transition (cut vs fade), pacing, and the accent moment from BRAND.md \xA7 Brand in Motion so the overlays move like THIS brand \u2014 not the reference's. If BRAND.md has no Brand-in-Motion section, seed it with brand-build first. See the creative-canvas-ads skill: references/prompt-anatomy.md + references/hyperframes/.",
+            // Photoreal on-camera casts auto-route to Veo above, so this only fires
+            // when `--video-model bytedance/seedance-2.0` was EXPLICITLY forced despite
+            // a person/animal cast — overriding that safety route. Warn that every such
+            // clip will hit ByteDance's real-person filter and burn a wasted attempt.
+            ...report.elements.some((e) => e.type === "person" || e.type === "animal") && /seedance/i.test(videoModel) ? {
+              content_policy_risk: "You FORCED Seedance (`--video-model bytedance/seedance-2.0`) on an ad with a photoreal on-camera cast. ByteDance's real-person filter will reject those clips (content_policy_blocked, E005) \u2014 no prompt change clears it. Each clip auto-recovers on Veo at render time so the run still completes, but you burn a wasted Seedance attempt per clip. Drop `--video-model` to let the scaffold route the cast to Veo up front, or make the frames less photorealistic."
+            } : {},
+            note: "Fill each el_* [TODO] \u2014 a person needs none (invented from their description, or cast with `--avatar <handle>`), never a photo of a real person; anything else with ONE real source image (reused across every frame that element appears in) \u2014 confirm each voice_select casting, then `baker canvas validate` and `baker canvas run`. Running generates many billed image/video/audio assets \u2014 it is not free."
+          }
+        },
+        null,
+        2
+      )}
+`
+    );
+  }
+});
+export {
+  hasPhotorealCast,
+  referenceVideoExt,
+  resolveVideoModel,
+  scaffoldVideoCommand
+};
+//# sourceMappingURL=scaffold-video-Y7X34F3N.js.map