@koda-sl/baker-cli 0.522.0 → 0.524.0-dev.3eb5500a1

package/dist/chunk-GXDFLDFK.js

@@ -0,0 +1,843 @@
+import {
+  AD_PLACEMENTS
+} from "./chunk-F3CZFUXZ.js";
+import {
+  hasOpenRouterKey,
+  openRouterKey
+} from "./chunk-GGUQP6KI.js";
+
+// src/engine/creative-rules/select.ts
+import { createHash } from "crypto";
+function platformFamily(name) {
+  const platform = AD_PLACEMENTS.find((p) => p.id === name)?.platform ?? name;
+  return platform.startsWith("google_") ? "google" : platform;
+}
+function runsOn(scoped, runs) {
+  return runs.some((run) => scoped.some((name) => name === run || platformFamily(name) === platformFamily(run)));
+}
+var RULES_CHARS = 12e3;
+var STRENGTH_ORDER = { never: 0, must: 1, prefer: 2 };
+function holdsFor(rule, target) {
+  const { kinds, products, platforms } = rule.scope;
+  if (kinds?.length && target.kind && !kinds.includes(target.kind)) return false;
+  if (products?.length && target.product && !products.includes(target.product)) return false;
+  const runs = target.platforms?.length ? target.platforms : target.platform ? [target.platform] : [];
+  if (platforms?.length && runs.length > 0 && !runsOn(platforms, runs)) return false;
+  return true;
+}
+function byStrength(a, b) {
+  return STRENGTH_ORDER[a.strength] - STRENGTH_ORDER[b.strength] || Number(a.origin === "declared") - Number(b.origin === "declared") || (b.source.date ?? "").localeCompare(a.source.date ?? "");
+}
+function selectRules(rules, target, waived = []) {
+  const held = rules.filter((r) => r.status === "active" && !waived.includes(r.id) && holdsFor(r, target)).sort(byStrength);
+  const picked = [];
+  let used = 0;
+  for (const rule of held) {
+    used += rule.text.length + (rule.source.quote?.length ?? 0);
+    if (used > RULES_CHARS && picked.length > 0) break;
+    picked.push(rule);
+  }
+  return picked;
+}
+function rulesDigest(rules) {
+  const canonical = [...rules].map((r) => [r.id, r.strength, r.applies, r.text, r.check ?? null]).sort((a, b) => String(a[0]).localeCompare(String(b[0])));
+  return createHash("sha256").update(JSON.stringify(canonical)).digest("hex").slice(0, 12);
+}
+var RULES_OPEN = "<company_rules>";
+var RULES_CLOSE = "</company_rules>";
+function rulesBlock(rules, intro) {
+  if (rules.length === 0) return "";
+  const lines = rules.map((r) => {
+    const quote = r.source.quote && r.source.quote !== r.text ? ` (their words: "${r.source.quote}")` : "";
+    return `- [${r.strength}] ${r.id}: ${r.text}${quote}`;
+  });
+  const lead = intro ?? "The company's standing rules for its ads: a never or a must is a requirement, a prefer is its taste.";
+  return [RULES_OPEN, lead, ...lines, RULES_CLOSE].join("\n");
+}
+function withoutRulesBlocks(text) {
+  if (!text.includes(RULES_OPEN)) return text;
+  return text.replace(new RegExp(`\\s*${RULES_OPEN}[\\s\\S]*?${RULES_CLOSE.replace("/", "\\/")}`, "g"), "");
+}
+function withoutRulesDeep(value) {
+  if (typeof value === "string") return withoutRulesBlocks(value);
+  if (Array.isArray(value)) return value.map(withoutRulesDeep);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, withoutRulesDeep(v)]));
+  }
+  return value;
+}
+var BRIEF_RULES = 8;
+function briefRules(rules) {
+  return rules.filter(
+    (r) => r.origin === "learned" ? r.applies === "picture" || r.applies === "cast" || r.applies === "logo" : r.applies === "cast" || r.applies === "logo"
+  ).slice(0, BRIEF_RULES);
+}
+
+// src/engine/nodes/local/lib/render-review.ts
+import { execFile } from "child_process";
+import { mkdtemp, readdir, readFile, rm } from "fs/promises";
+import { tmpdir } from "os";
+import path from "path";
+import { promisify } from "util";
+import { z } from "zod";
+
+// src/engine/nodes/local/lib/rules-findings.ts
+var SEEN_IN_A_STILL = /* @__PURE__ */ new Set(["copy", "picture", "cast", "logo", "any"]);
+var reviewedRules = (rules) => rules.filter((r) => r.origin === "learned" && SEEN_IN_A_STILL.has(r.applies));
+function buildRulesReviewPrompt(opts) {
+  const ids = reviewedRules(opts.rules).map((r) => r.id);
+  return [
+    `These are the finished sizes of ONE ad, in this order: ${opts.formats.join(", ")}.`,
+    `Check the ad against each of the company's rules above (${ids.join(", ")}). A rule is broken only when you can plainly see it broken on the ad as it is: its words as they print, what the picture shows, who appears, the logo. A rule about something this ad does not show is not broken. Never report anything that is not one of these rules.`,
+    'For each rule broken, give its id exactly, the size you see it on, and in under twenty words what on the ad breaks it. Reply with only this JSON: {"broken":[{"rule":"<rule id>","format":"4:5","what":"..."}]}; {"broken":[]} when the ad keeps every rule.'
+  ].join("\n");
+}
+function rulesSystem(rules) {
+  return rulesBlock(
+    reviewedRules(rules),
+    "You check finished ads against the company's own standing rules for every ad. A never or a must is a requirement; a prefer is its taste. The rules, each with its id:"
+  );
+}
+var ELEMENT = {
+  copy: "copy",
+  logo: "logo",
+  picture: "picture",
+  cast: "picture",
+  any: "picture",
+  voice: "other",
+  sound: "other",
+  subtitles: "other"
+};
+function classifyRuleFindings(json, rules) {
+  const broken = json?.broken;
+  if (!Array.isArray(broken)) return [];
+  return broken.flatMap((raw) => {
+    const entry = raw ?? {};
+    const rule = rules.find((r) => r.id === entry.rule);
+    const what = typeof entry.what === "string" ? entry.what.trim() : "";
+    if (!rule || !what) return [];
+    const format = typeof entry.format === "string" && entry.format.trim() ? `${entry.format.trim()}: ` : "";
+    const kind = {
+      item: "rule",
+      element: ELEMENT[rule.applies],
+      defect: "other",
+      edges: [],
+      rule: rule.id
+    };
+    return [
+      {
+        severity: rule.strength === "prefer" ? "warning" : "blocking",
+        what: `${format}breaks ${rule.id} (${rule.text}): ${what}`,
+        kind
+      }
+    ];
+  });
+}
+var HEARD = /* @__PURE__ */ new Set(["voice", "sound", "subtitles", "copy", "any"]);
+var heardRules = (rules) => rules.filter((r) => r.origin === "learned" && HEARD.has(r.applies));
+
+// src/engine/nodes/local/lib/render-review.ts
+var RENDER_REVIEW_MODEL = "~google/gemini-pro-latest";
+var RENDER_REVIEW_FRAMES = 12;
+var RENDER_REVIEW_WIDTH = 1024;
+var RENDER_WATCH_MODEL = "~google/gemini-flash-latest";
+function usageFrom(model, body) {
+  const usage = body?.usage;
+  if (!usage) return null;
+  const positive = (value) => typeof value === "number" && Number.isFinite(value) && value > 0 ? value : null;
+  return {
+    model,
+    inputTokens: usage.prompt_tokens ?? 0,
+    outputTokens: usage.completion_tokens ?? 0,
+    costUsd: positive(usage.cost) ?? positive(usage.cost_details?.upstream_inference_cost) ?? 0
+  };
+}
+var WATCH_MAX_BYTES = 60 * 1024 * 1024;
+var STATIC_REVIEW_ITEMS = [
+  "text",
+  "logo",
+  "layout",
+  "safe_zone",
+  "picture",
+  "subject",
+  "person",
+  "people",
+  "one_idea",
+  "thumbnail",
+  "concept",
+  "viewer",
+  "proof",
+  "sizes",
+  "native",
+  "rule",
+  "other"
+];
+var FINDING_ELEMENTS = ["copy", "button", "logo", "scene_text", "picture", "other"];
+var FINDING_DEFECTS = ["cut", "missing", "unreadable", "other"];
+var FRAME_EDGES = ["top", "bottom", "left", "right"];
+function sceneAt(windows, atS) {
+  return windows.find((w) => atS >= w.startS && atS < w.endS)?.file;
+}
+function reviewFrameTimes(durationS, frames) {
+  const n = Math.max(2, frames);
+  const last = Math.max(0, durationS - 0.15);
+  const step = last / (n - 1);
+  return Array.from({ length: n }, (_, i) => Math.round(i * step * 100) / 100);
+}
+function buildFrameGrabArgs(video, atS, out) {
+  return [
+    "-v",
+    "error",
+    "-ss",
+    String(atS),
+    "-i",
+    video,
+    "-frames:v",
+    "1",
+    "-vf",
+    `scale=${RENDER_REVIEW_WIDTH}:-2`,
+    out,
+    "-y"
+  ];
+}
+var FrameReview = z.object({
+  /** Something in shot that could not happen, or is being done wrong. */
+  impossible: z.array(z.string()).default([]),
+  /** Objects present in frame that belong to no part of the scene. */
+  strays: z.array(z.string()).default([])
+});
+var ReelReview = z.object({
+  /** Whether the people the script treats as one person stay one person. */
+  cast_is_consistent: z.boolean().default(true),
+  cast_note: z.string().default(""),
+  /** Whether the advertiser's mark is visible anywhere. */
+  brand_mark_visible: z.boolean().default(false),
+  /** Whether the last frames close the ad rather than trailing off. */
+  ends_on_a_close: z.boolean().default(false),
+  ending_note: z.string().default(""),
+  /** Whether the ad ever cuts away from the presenter to show anything. */
+  shows_more_than_a_face: z.boolean().default(true),
+  shows_note: z.string().default("")
+});
+function buildFrameReviewPrompt(opts) {
+  const subject = opts.subject ? ` The advertiser is ${opts.subject}.` : "";
+  return `This is ONE frame from a video advertisement.${subject}
+
+Answer only about what is visible in THIS frame. Do not judge whether the ad is good, and do not comment on style, mood or lighting.
+
+1. IMPOSSIBLE OR WRONG. Is anything shown that could not physically happen, or that shows the job being done incorrectly? Judge the PROCEDURE, not only the physics: equipment resting where it would never rest, a component fitted to nothing, someone handling a part in a way that would damage it, an object at the wrong scale beside a person, a body with a limb missing or duplicated.
+2. STRAYS. Is any object present that belongs to no part of the scene \u2014 floating, unattached, or cut off from whatever should hold it?
+
+Report only what you can actually see. An empty list is the right answer for a clean frame. Keep each item under twelve words.
+
+Reply with only this JSON: {"impossible":[],"strays":[]}`;
+}
+function buildReelReviewPrompt(opts) {
+  const subject = opts.subject ? ` The advertiser is ${opts.subject}.` : "";
+  const script = opts.script ? `
+
+The voiceover says, in order:
+${opts.script}` : "";
+  return `These frames are sampled in order from one video advertisement.${subject}` + script + `
+
+Answer only about what is visible.
+
+1. CAST. Do the people stay the same people? If the script speaks about one customer and the frames show different faces in that role, say so and count them.
+2. BRAND. Is the advertiser's logo or wordmark visible in ANY frame? Answer yes only if you can actually see a mark \u2014 a colour is not a mark.
+3. ENDING. Do the final frames close the advertisement \u2014 a call to action, a mark, a card \u2014 or does the picture simply carry on and stop?
+4. WHAT IT SHOWS. Does the advertisement ever cut away from the person to show the thing it is selling, or its result? Answer false if every frame is the same person with only the framing changed, and nothing is ever shown.
+
+Reply with only this JSON:
+{"cast_is_consistent":true,"cast_note":"","brand_mark_visible":false,"ends_on_a_close":false,"ending_note":"","shows_more_than_a_face":true,"shows_note":""}`;
+}
+function parseReviewJson(raw) {
+  const fenced = raw.match(/```(?:json)?\s*([\s\S]*?)```/);
+  const body = (fenced?.[1] ?? raw).trim();
+  const start = body.indexOf("{");
+  const end = body.lastIndexOf("}");
+  if (start === -1 || end === -1 || end < start) return null;
+  const json = body.slice(start, end + 1);
+  for (const candidate of [json, json.replace(UNCLOSED_NUMBERS, "[$1]}")]) {
+    try {
+      return JSON.parse(candidate);
+    } catch {
+    }
+  }
+  return boxListOf(json.replace(UNCLOSED_NUMBERS, "[$1]}"));
+}
+var UNCLOSED_NUMBERS = /\[(\s*-?\d+(?:\.\d+)?(?:\s*,\s*-?\d+(?:\.\d+)?)*)\s*\}/g;
+var BOX_LIST = /^\{\s*"items"\s*:\s*\[/;
+function closingQuote(text, open) {
+  for (let i = open + 1; i < text.length; i++) {
+    if (text[i] === "\\") i++;
+    else if (text[i] === '"') return i;
+  }
+  return text.length;
+}
+function objectsIn(text) {
+  const out = [];
+  let end = 0;
+  let depth = 0;
+  let from = 0;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (ch === '"') i = closingQuote(text, i);
+    else if (ch === "{") {
+      if (depth === 0) from = i;
+      depth++;
+    } else if (ch === "}" && depth > 0) {
+      depth--;
+      if (depth === 0) {
+        out.push(text.slice(from, i + 1));
+        end = i + 1;
+      }
+    }
+  }
+  return { objects: out, end, open: depth > 0 };
+}
+function boxListOf(json) {
+  const list = json.match(BOX_LIST);
+  if (!list) return null;
+  const seen = /* @__PURE__ */ new Set();
+  const items = [];
+  const body = json.slice(list[0].length);
+  const scan = objectsIn(body);
+  if (scan.open || !body.slice(scan.end).includes("]")) return null;
+  for (const object of scan.objects) {
+    let item;
+    try {
+      item = JSON.parse(object);
+    } catch {
+      return null;
+    }
+    const key = JSON.stringify(item);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    items.push(item);
+  }
+  return items.length > 0 ? { items } : null;
+}
+var normalise = (s) => s.toLowerCase().replace(/[^a-z0-9 ]/g, " ").replace(/\s+/g, " ").trim();
+var ANATOMY = /\b(finger|fingers|hand|hands|thumb|limb|leg|legs|arm|arms|foot|feet|anatomy)\b/i;
+function collapseRepeats(frames) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const frame of frames) {
+    const parsed = FrameReview.safeParse(frame.json);
+    if (!parsed.success) continue;
+    for (const item of [...parsed.data.impossible, ...parsed.data.strays]) {
+      const text = item.trim();
+      const key = normalise(text);
+      if (!key) continue;
+      const hit = seen.get(key);
+      if (hit) hit.at.push(frame.at);
+      else seen.set(key, { what: text, at: [frame.at] });
+    }
+  }
+  return [...seen.values()];
+}
+function classifyFrameFindings(frames, windows = []) {
+  const seen = collapseRepeats(frames);
+  const anatomy = seen.filter((f) => ANATOMY.test(f.what));
+  const rest = seen.filter((f) => !ANATOMY.test(f.what));
+  const findings = rest.map((f) => {
+    const scene = sceneAt(windows, f.at[0]);
+    return {
+      severity: "blocking",
+      what: `At ${f.at.map((s) => `${s}s`).join(", ")}${scene ? ` (${scene})` : ""}: ${f.what}`,
+      ...scene ? { scene } : {}
+    };
+  });
+  if (anatomy.length > 0) {
+    const at = [...new Set(anatomy.flatMap((f) => f.at))].sort((a, b) => a - b);
+    findings.push({
+      severity: "blocking",
+      what: `Malformed hands or limbs in ${at.length} of ${frames.length} sampled frames (${at.map((s) => `${s}s${sceneAt(windows, s) ? ` \u2192 ${sceneAt(windows, s)}` : ""}`).join(", ")}): ${anatomy.map((f) => f.what).join(" ")} Re-render those beats \u2014 keep hands out of frame, or away from the object being held.`
+    });
+  }
+  return findings;
+}
+function buildWatchReviewPrompt(opts) {
+  const market = opts.market?.trim();
+  const heard = heardRules(opts.rules ?? []);
+  const rules = heard.length > 0 ? `${rulesBlock(heard, "5. RULES. The company holds every ad to its own rules, each with its id:")}
+For each rule this video plainly breaks, in what is said, how it sounds, its subtitles or what is shown, give its id exactly, the timestamp and what breaks it. A rule about something this video does not do is not broken.
+` : "";
+  return `Watch and LISTEN to this advertisement, then answer about the things that only exist in motion and in sound.
+1. SPOKEN VARIETY. ${market ? `The ad is set in ${market}. ` : ""}Does the speaker's accent belong there? Quote the words you heard that show it \u2014 a phonetic marker beats an impression.
+2. VOICE AND MOUTH. Does the voice belong to the mouth on screen, in timing and in person?
+3. CUTS. Do the shot changes hold, or does something jump, repeat or stutter between them?
+4. DEFECTS. List anything else wrong, each with the exact timestamp where it happens \u2014 a moment maps to the shot that produced it, and a defect without one is a complaint rather than an instruction.
+` + rules + `Answer JSON only: {"spoken_variety_matches":true|false,"variety_note":"...","voice_matches_mouth":true|false,"mouth_note":"...","cuts_are_clean":true|false,"cuts_note":"...","defects":[{"at":"MM:SS.s","kind":"cut|lipsync|audio|visual","what":"..."}]${heard.length > 0 ? ',"rules_broken":[{"rule":"<rule id>","at":"MM:SS.s","what":"..."}]' : ""}}`;
+}
+var WatchReview = z.object({
+  spoken_variety_matches: z.boolean(),
+  variety_note: z.string().default(""),
+  voice_matches_mouth: z.boolean(),
+  mouth_note: z.string().default(""),
+  cuts_are_clean: z.boolean(),
+  cuts_note: z.string().default("")
+});
+var WatchDefects = z.object({
+  defects: z.array(
+    z.object({
+      at: z.string().default(""),
+      kind: z.string().default(""),
+      what: z.string().default("")
+    })
+  ).default([])
+});
+function classifyWatchRules(json, rules, windows) {
+  const broken = json?.rules_broken;
+  if (!Array.isArray(broken)) return [];
+  return broken.flatMap((raw) => {
+    const entry = raw ?? {};
+    const at = typeof entry.at === "string" ? entry.at.trim() : "";
+    const [finding] = classifyRuleFindings({ broken: [{ ...raw, format: at }] }, heardRules(rules));
+    if (!finding) return [];
+    const moment = parseMoment(at);
+    const scene = moment === null ? void 0 : sceneAt(windows, moment);
+    return [{ ...finding, ...scene ? { scene } : {} }];
+  });
+}
+function parseMoment(at) {
+  const trimmed = at.trim();
+  const clock = /^(\d+):(\d+(?:\.\d+)?)$/.exec(trimmed);
+  if (clock) return Number(clock[1]) * 60 + Number(clock[2]);
+  const plain = Number(trimmed.replace(/s$/i, ""));
+  return Number.isFinite(plain) ? plain : null;
+}
+function classifyWatchDefects(json, windows) {
+  const parsed = WatchDefects.safeParse(json);
+  if (!parsed.success) return [];
+  return parsed.data.defects.filter((d) => d.what.trim()).map((d) => {
+    const at = parseMoment(d.at);
+    const scene = at === null ? void 0 : sceneAt(windows, at);
+    const when = d.at.trim() ? ` at ${d.at.trim()}` : "";
+    return {
+      severity: "warning",
+      what: `${d.what.trim()}${when}${d.kind.trim() ? ` (${d.kind.trim()})` : ""}.`,
+      ...scene ? { scene } : {}
+    };
+  });
+}
+var FidelityReview = z.object({
+  delivers_the_ask: z.boolean(),
+  missing: z.array(z.string()).default([]),
+  contradicted: z.array(z.string()).default([])
+});
+function buildFidelityPrompt(brief) {
+  return `Someone asked for an advertisement in these words:
+
+"""${brief.trim()}"""
+
+Watch and LISTEN to the video, then answer only this: does it deliver what they asked for? Judge the request as it was written \u2014 not what would make a good ad, and not what you would have made. Two lists: what they asked for that is NOT in the video, and what the video does that CONTRADICTS what they asked for. Quote their own words in each entry so the answer can be checked. Empty lists when it delivers.
+Answer JSON only: {"delivers_the_ask":true|false,"missing":["..."],"contradicted":["..."]}`;
+}
+function classifyFidelityFindings(json) {
+  const parsed = FidelityReview.safeParse(json);
+  if (!parsed.success) return [];
+  const r = parsed.data;
+  if (r.delivers_the_ask) return [];
+  return [...r.missing, ...r.contradicted].map((entry) => entry.trim()).filter(Boolean).map((what) => ({ severity: "blocking", what: `Not what was asked for: ${what}.` }));
+}
+function classifyWatchFindings(json) {
+  const parsed = WatchReview.safeParse(json);
+  if (!parsed.success) return [];
+  const r = parsed.data;
+  const findings = [];
+  if (!r.spoken_variety_matches) {
+    findings.push({
+      severity: "blocking",
+      what: `The voice speaks the wrong variety of the language${r.variety_note.trim() ? `: ${r.variety_note.trim()}` : ""}. A pinned voice cannot fix this \u2014 the re-voicing is speech-to-speech and carries the accent across, so state the market on the ad and let the clip prompt name the accent.`
+    });
+  }
+  if (!r.voice_matches_mouth) {
+    findings.push({
+      severity: "blocking",
+      what: `The voice does not match the mouth${r.mouth_note.trim() ? `: ${r.mouth_note.trim()}` : ""}. A person visibly speaking under a track that is not theirs reads as bad dubbing.`
+    });
+  }
+  if (!r.cuts_are_clean) {
+    findings.push({
+      severity: "warning",
+      what: `The cuts do not hold${r.cuts_note.trim() ? `: ${r.cuts_note.trim()}` : ""}.`
+    });
+  }
+  return findings;
+}
+function classifyReelFindings(json) {
+  const parsed = ReelReview.safeParse(json);
+  if (!parsed.success) return [];
+  const r = parsed.data;
+  const findings = [];
+  if (!r.cast_is_consistent) {
+    findings.push({
+      severity: "blocking",
+      what: `The cast changes between shots${r.cast_note.trim() ? `: ${r.cast_note.trim()}` : ""}. One customer played by several faces reads as stock footage. Ground the frames on one identity (\`baker avatars\`) or write the beats so the subject is never the same person twice.`
+    });
+  }
+  if (!r.brand_mark_visible) {
+    findings.push({
+      severity: "warning",
+      what: "No brand mark is visible in any frame. THIS IS NOT A RE-RENDER: the mark is drawn by the caption composition as an ordinary `<img>`, never generated as a picture \u2014 so fix the mark itself (a bad path, or an SVG whose geometry clips its own wordmark) or the `.brand-mark` / `.endcard-logo` rules in `<composition>/index.html`, then re-run. Every clip comes back from the cache and only the composition pass renders again, so it costs seconds and no generation."
+    });
+  }
+  if (!r.shows_more_than_a_face) {
+    findings.push({
+      severity: "blocking",
+      what: `The ad never shows what it is selling${r.shows_note.trim() ? `: ${r.shows_note.trim()}` : ""} \u2014 every frame is the same person with only the framing changed. Give the middle beats their own picture (the bill, the roof, the install, the house) and set \`cast: false\` on them.`
+    });
+  }
+  if (!r.ends_on_a_close) {
+    findings.push({
+      severity: "warning",
+      what: `The video does not close${r.ending_note.trim() ? `: ${r.ending_note.trim()}` : ""} \u2014 it runs on and stops. Give the last beat a call to action, and keep its shot short enough that the picture ends with the read.`
+    });
+  }
+  return findings;
+}
+function videoPathFromOutput(output) {
+  const refs = Array.isArray(output) ? output : [output];
+  let found = null;
+  for (const ref of refs) {
+    const r = ref;
+    if (!r || typeof r !== "object") continue;
+    const isVideo = r.kind === "video" || typeof r.mime === "string" && r.mime.startsWith("video/");
+    if (isVideo && typeof r.path === "string" && r.path) found = r.path;
+  }
+  return found;
+}
+function parseVolume(volumedetect, key) {
+  const raw = new RegExp(`${key}:\\s*(-?(?:inf|[\\d.]+)) dB`).exec(volumedetect)?.[1];
+  if (raw === void 0) return Number.NaN;
+  if (raw === "-inf") return Number.NEGATIVE_INFINITY;
+  return Number.parseFloat(raw);
+}
+function classifyAudio(volumedetect, hasAudioStream) {
+  if (!hasAudioStream) {
+    return [
+      {
+        severity: "blocking",
+        what: "The finished video has no audio track at all \u2014 no voice, no music, nothing. An ad that plays silent in a feed is not an ad."
+      }
+    ];
+  }
+  const mean = parseVolume(volumedetect, "mean_volume");
+  const max = parseVolume(volumedetect, "max_volume");
+  const findings = [];
+  if (mean === Number.NEGATIVE_INFINITY || max === Number.NEGATIVE_INFINITY) {
+    return [
+      {
+        severity: "blocking",
+        what: "The finished video has an audio track, but it is completely silent \u2014 digital zero from start to end. An ad that plays silent in a feed is not an ad."
+      }
+    ];
+  }
+  if (Number.isFinite(mean) && mean < -30) {
+    findings.push({
+      severity: "warning",
+      what: `The mix is very quiet (${mean} dB average). On a phone at half volume this is close to silence \u2014 check the music bed is not ducked into nothing under the voice.`
+    });
+  }
+  if (Number.isFinite(max) && max > -0.5) {
+    findings.push({
+      severity: "warning",
+      what: `The mix peaks at ${max} dB, which is at or over the ceiling \u2014 the voice will distort on a phone speaker. Bring the loudest track down a few dB.`
+    });
+  }
+  return findings;
+}
+var RENDER_REVIEW_UNAVAILABLE = "The render was NOT reviewed \u2014 no model gateway key in this environment. Watch it yourself before sending it on.";
+var RULE_FRAME_STEP = 3;
+async function framesAgainstRules(grabbed, checkStills) {
+  if (!checkStills) return [];
+  const sampled = grabbed.filter((_, i) => i % RULE_FRAME_STEP === 0);
+  const found = await checkStills(
+    sampled.map((f) => f.image),
+    sampled.map((f) => `the frame at ${f.at.toFixed(1)}s`)
+  ).catch(() => null);
+  return found ?? [
+    {
+      severity: "warning",
+      what: "The frames were not checked against the company's rules (the model did not answer): read them against `rules` in the brief yourself."
+    }
+  ];
+}
+var REVIEW_CONCURRENCY = 3;
+async function mapWithLimit(items, limit, fn) {
+  const out = new Array(items.length);
+  let next = 0;
+  await Promise.all(
+    Array.from({ length: Math.min(limit, items.length) }, async () => {
+      for (let i = next++; i < items.length; i = next++) {
+        out[i] = await fn(items[i]);
+      }
+    })
+  );
+  return out;
+}
+var execFileAsync = promisify(execFile);
+async function measureAudio(video) {
+  const streams = await execFileAsync(
+    "ffprobe",
+    ["-v", "error", "-select_streams", "a", "-show_entries", "stream=codec_type", "-of", "csv=p=0", video],
+    { timeout: 2e4 }
+  ).catch(() => null);
+  if (!streams) return [];
+  const hasAudio = streams.stdout.trim().length > 0;
+  if (!hasAudio) return classifyAudio("", false);
+  const vol = await execFileAsync("ffmpeg", ["-i", video, "-map", "0:a:0", "-af", "volumedetect", "-f", "null", "-"], {
+    timeout: 12e4,
+    maxBuffer: 8 * 1024 * 1024
+  }).catch((e) => ({ stdout: "", stderr: e.stderr ?? "" }));
+  return classifyAudio(vol.stderr ?? "", true);
+}
+async function videoDuration(video) {
+  try {
+    const { stdout } = await execFileAsync(
+      "ffprobe",
+      ["-v", "error", "-show_entries", "format=duration", "-of", "default=nw=1:nk=1", video],
+      { timeout: 2e4 }
+    );
+    const seconds = Number.parseFloat(stdout.trim());
+    return Number.isFinite(seconds) && seconds > 0 ? seconds : null;
+  } catch {
+    return null;
+  }
+}
+async function askGateway(model, parts, timeoutMs, spent, reasoning, extra = {}, system) {
+  const key = openRouterKey();
+  if (!key) return null;
+  try {
+    const response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
+      method: "POST",
+      headers: { "content-type": "application/json", authorization: `Bearer ${key}` },
+      body: JSON.stringify({
+        model,
+        messages: [...system ? [{ role: "system", content: system }] : [], { role: "user", content: parts }],
+        usage: { include: true },
+        ...reasoning ? { reasoning } : {},
+        ...extra
+      }),
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    if (!response.ok) return null;
+    const body = await response.json();
+    const usage = usageFrom(model, body);
+    if (usage) spent(usage);
+    const text = body.choices?.[0]?.message?.content;
+    return text ? parseReviewJson(text) : null;
+  } catch {
+    return null;
+  }
+}
+async function askVideo(video, prompt, spent) {
+  let bytes;
+  try {
+    bytes = await readFile(video);
+  } catch {
+    return null;
+  }
+  if (bytes.byteLength > WATCH_MAX_BYTES) return null;
+  return await askGateway(
+    RENDER_WATCH_MODEL,
+    [
+      { type: "text", text: prompt },
+      { type: "video_url", video_url: { url: `data:video/mp4;base64,${bytes.toString("base64")}` } }
+    ],
+    6e5,
+    spent
+  );
+}
+async function ask(images, prompt, spent) {
+  return await askGateway(
+    RENDER_REVIEW_MODEL,
+    [
+      { type: "text", text: prompt },
+      ...images.map(
+        (b64) => ({ type: "image_url", image_url: { url: `data:image/jpeg;base64,${b64}` } })
+      )
+    ],
+    18e4,
+    spent
+  );
+}
+async function askAboutStills(images, prompt, onSpend) {
+  if (!hasOpenRouterKey()) return null;
+  return await ask(images, prompt, (usage) => onSpend?.(usage));
+}
+async function askAboutImages(model, images, prompt, onSpend, timeoutMs = 6e4, reasoning, system, request = {}) {
+  if (!hasOpenRouterKey()) return null;
+  return await askGateway(
+    model,
+    [
+      { type: "text", text: prompt },
+      ...images.map(
+        (b64) => ({ type: "image_url", image_url: { url: `data:image/jpeg;base64,${b64}` } })
+      )
+    ],
+    timeoutMs,
+    (usage) => onSpend?.(usage),
+    reasoning,
+    request,
+    system
+  );
+}
+async function askAboutText(model, prompt, onSpend, opts = {}) {
+  if (!hasOpenRouterKey()) return null;
+  return await askGateway(
+    model,
+    [{ type: "text", text: prompt }],
+    opts.timeoutMs ?? 6e4,
+    (usage) => onSpend?.(usage),
+    void 0,
+    opts.request
+  );
+}
+async function reviewRenderedVideo(opts) {
+  if (!hasOpenRouterKey()) return null;
+  const duration = await videoDuration(opts.video);
+  if (duration === null) return null;
+  const spent = (usage) => opts.onSpend?.(usage);
+  const dir = await mkdtemp(path.join(tmpdir(), "baker-review-"));
+  try {
+    const grabbed = [];
+    for (const [i, at] of reviewFrameTimes(duration, RENDER_REVIEW_FRAMES).entries()) {
+      const out = path.join(dir, `f${String(i).padStart(2, "0")}.jpg`);
+      try {
+        await execFileAsync("ffmpeg", buildFrameGrabArgs(opts.video, at, out), { timeout: 3e4 });
+        grabbed.push({ at, image: await readFile(out, { encoding: "base64" }) });
+      } catch {
+      }
+    }
+    if (grabbed.length === 0) return null;
+    const reel = await ask(
+      grabbed.map((f) => f.image),
+      buildReelReviewPrompt({ subject: opts.subject, script: opts.script }),
+      spent
+    );
+    const framePrompt = buildFrameReviewPrompt({ subject: opts.subject });
+    const perFrame = await mapWithLimit(grabbed, REVIEW_CONCURRENCY, async (f) => ({
+      at: f.at,
+      json: await ask([f.image], framePrompt, spent)
+    }));
+    const unread = perFrame.filter((f) => f.json === null).length;
+    if (unread === perFrame.length && reel === null) return null;
+    const watch = await askVideo(
+      opts.video,
+      buildWatchReviewPrompt({
+        market: opts.market,
+        script: opts.script,
+        ...opts.rules ? { rules: opts.rules } : {}
+      }),
+      spent
+    );
+    const ruled = await framesAgainstRules(grabbed, opts.checkStills);
+    const fidelity = opts.brief?.trim() ? await askVideo(opts.video, buildFidelityPrompt(opts.brief), spent) : null;
+    const findings = [
+      ...classifyFrameFindings(perFrame, opts.windows ?? []),
+      ...classifyReelFindings(reel),
+      ...classifyWatchFindings(watch),
+      ...classifyWatchDefects(watch, opts.windows ?? []),
+      ...classifyWatchRules(watch, opts.rules ?? [], opts.windows ?? []),
+      ...ruled,
+      ...classifyFidelityFindings(fidelity),
+      // Measured, not judged: a model looking at frames cannot hear the mix.
+      ...await measureAudio(opts.video)
+    ];
+    findings.push(
+      ...unreviewedNotes({
+        watched: watch !== null,
+        fidelityAsked: Boolean(opts.brief?.trim()),
+        fidelityRead: fidelity !== null,
+        unread,
+        frames: perFrame.length
+      })
+    );
+    return findings;
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+}
+async function reviewContextBeside(canvasPath) {
+  const raw = await readFile(path.join(path.dirname(canvasPath), "prompt.json"), "utf-8").catch(() => null);
+  if (!raw) return {};
+  try {
+    const blueprint = JSON.parse(raw);
+    const global = blueprint.global ?? {};
+    const text = (value) => typeof value === "string" && value.trim() ? value.trim() : void 0;
+    return {
+      ...text(global.market) ? { market: text(global.market) } : {},
+      ...text(global.branding?.name) ? { subject: text(global.branding?.name) } : {},
+      ...text(global.transcript) ? { script: text(global.transcript) } : {}
+    };
+  } catch {
+    return {};
+  }
+}
+async function sceneWindowsBeside(canvasPath) {
+  const dir = path.join(path.dirname(canvasPath), "scenes");
+  const files = await readdir(dir).catch(() => null);
+  if (!files) return [];
+  const windows = [];
+  for (const name of files.filter((f) => f.endsWith(".json")).sort()) {
+    const raw = await readFile(path.join(dir, name), "utf-8").catch(() => null);
+    if (!raw) continue;
+    try {
+      const scene = JSON.parse(raw);
+      if (typeof scene.start_s === "number" && typeof scene.end_s === "number") {
+        windows.push({ file: `scenes/${name}`, startS: scene.start_s, endS: scene.end_s });
+      }
+    } catch {
+    }
+  }
+  return windows;
+}
+function unreviewedNotes(state) {
+  const notes = [];
+  if (!state.watched) {
+    notes.push({
+      severity: "warning",
+      what: "Nobody watched the finished video end to end \u2014 the accent, the voice against the mouth and the cuts are unchecked. The frame-by-frame review still ran."
+    });
+  }
+  if (state.fidelityAsked && !state.fidelityRead) {
+    notes.push({
+      severity: "warning",
+      what: "The video was not checked against what you asked for \u2014 only against whether it is well made. A well-made ad of the wrong brief passes every other check here."
+    });
+  }
+  if (state.unread > 0) {
+    notes.push({
+      severity: "warning",
+      what: `${state.unread} of ${state.frames} frames could not be reviewed \u2014 that part of the video is unchecked.`
+    });
+  }
+  return notes;
+}
+
+export {
+  selectRules,
+  rulesDigest,
+  rulesBlock,
+  withoutRulesDeep,
+  briefRules,
+  reviewedRules,
+  buildRulesReviewPrompt,
+  rulesSystem,
+  classifyRuleFindings,
+  RENDER_REVIEW_MODEL,
+  STATIC_REVIEW_ITEMS,
+  FINDING_ELEMENTS,
+  FINDING_DEFECTS,
+  FRAME_EDGES,
+  videoPathFromOutput,
+  RENDER_REVIEW_UNAVAILABLE,
+  askAboutStills,
+  askAboutImages,
+  askAboutText,
+  reviewRenderedVideo,
+  reviewContextBeside,
+  sceneWindowsBeside
+};
+//# sourceMappingURL=chunk-GXDFLDFK.js.map