#!/usr/bin/env python3
"""beat_snap.py — align beat boundaries to VO word onsets (Whisper) + emit words-flat.

VO-FIRST is the whole design: render the VO, transcribe it to word-level timestamps, then
re-snap every beat boundary to the nearest word ONSET so a beat's on-screen turn lands
exactly when the VO says it. This ports the re-snap step from the Clinikally run.

Two outputs, written into the work dir:
  - whisper/words-flat.json : [{text, start, end}, ...] (what compose.py's captions read)
  - beat-manifest.json      : the config beats with re-snapped start/end/duration.

Whisper word-timestamps come from fal-ai/whisper (chunk_level=word). Prefer the
PROXY-ROUTED path so the call bills the Ads agent (never a raw FAL_KEY): the orchestrator
hosts the rendered VO via MCP `get_upload_url` → `get_download_url` and passes the presigned
url as `--vo-url` (transcribed through `media_proxy.fal_whisper`). Already have the words?
pass `--words-file words.json` and beat_snap skips transcription entirely. Legacy: a raw
`FAL_KEY` in the env still works via `fal_client`. Fully offline: `--no-whisper` keeps the
config durations un-snapped (NOTE: no words ⇒ no karaoke captions). On-card text is the
source of truth, so brand-name homophones in the transcript are fine.

Usage:
  beat_snap.py --config config.json --work-dir DIR --vo-url <presigned-url>   # proxy (preferred)
  beat_snap.py --config config.json --work-dir DIR --words-file words.json    # pre-fetched
  beat_snap.py --config config.json --work-dir DIR --vo vo.mp3                 # legacy FAL_KEY
  beat_snap.py --config config.json --work-dir DIR --no-whisper               # offline

ENV: GW_PROJECT_ID (attributes proxy spend to the ad project); FAL_KEY only for the legacy path.
"""
import argparse, json, os
from pathlib import Path


def transcribe_proxy(vo_url):
    """Proxy-routed Whisper (bills the Ads agent). Needs media_proxy.py on sys.path —
    the orchestrator fetches it with the create-vo-elevenlabs / media-proxy capability."""
    from media_proxy import fal_whisper
    return fal_whisper(vo_url)


def transcribe_fal(vo_path):
    """Legacy: a raw FAL_KEY in the env (NOT proxy-routed — does not bill the Ads agent)."""
    import fal_client
    if "FAL_KEY" not in os.environ and "FAL_API_KEY" in os.environ:
        os.environ["FAL_KEY"] = os.environ["FAL_API_KEY"]
    url = fal_client.upload_file(str(vo_path))
    res = fal_client.subscribe("fal-ai/whisper", arguments={
        "audio_url": url, "task": "transcribe", "language": "en", "chunk_level": "word"})
    words = []
    for ch in res.get("chunks", []):
        ts = ch.get("timestamp") or [None, None]
        words.append({"text": ch.get("text", "").strip(), "start": ts[0], "end": ts[1]})
    return words


def ffprobe_dur(path):
    import subprocess
    r = subprocess.run(["ffprobe", "-v", "error", "-show_entries", "format=duration",
                        "-of", "csv=p=0", str(path)], capture_output=True, text=True)
    return float(r.stdout.strip())


def nearest_onset(t, words, tol=0.6):
    """Snap `t` to the closest word start within `tol` seconds; else return t unchanged."""
    best, bd = t, tol
    for w in words:
        if w.get("start") is None:
            continue
        d = abs(w["start"] - t)
        if d < bd:
            best, bd = w["start"], d
    return best


def main():
    ap = argparse.ArgumentParser(description="Snap beats to VO word onsets.")
    ap.add_argument("--config", required=True)
    ap.add_argument("--work-dir", required=True)
    ap.add_argument("--vo", help="VO mp3 (defaults to config.vo) — legacy raw-FAL_KEY path")
    ap.add_argument("--vo-url", help="presigned PUBLIC url of the rendered VO → proxy Whisper (preferred)")
    ap.add_argument("--words-file", help="pre-fetched words-flat.json → skip transcription")
    ap.add_argument("--no-whisper", action="store_true",
                    help="skip transcription; keep config durations (offline; NO captions)")
    a = ap.parse_args()

    cfg = json.load(open(a.config))
    work = Path(a.work_dir)
    (work / "whisper").mkdir(parents=True, exist_ok=True)
    beats = cfg["beats"]
    vo = a.vo or cfg.get("vo")

    words = []
    if a.words_file:
        words = json.load(open(a.words_file))
        print(f"[whisper] loaded {len(words)} words from {a.words_file}")
    elif a.no_whisper:
        print("[whisper] skipped — using config beat durations un-snapped")
    elif a.vo_url:
        print("[whisper] transcribing via proxy (bills the Ads agent)")
        words = transcribe_proxy(a.vo_url)
        print(f"[whisper] {len(words)} words: " + " ".join(w["text"] for w in words)[:200])
    elif vo and os.path.exists(vo) and ("FAL_KEY" in os.environ or "FAL_API_KEY" in os.environ):
        print(f"[whisper] transcribing {vo} via legacy FAL_KEY (not proxy-billed)")
        words = transcribe_fal(vo)
        print(f"[whisper] {len(words)} words: " + " ".join(w["text"] for w in words)[:200])
    else:
        print("[whisper] no --vo-url / --words-file / FAL_KEY — durations un-snapped, no captions")

    (work / "whisper" / "words-flat.json").write_text(json.dumps(words, indent=2))

    # Re-snap: walk cumulative starts; snap each boundary to the nearest word onset.
    out_beats, t = [], 0.0
    for i, b in enumerate(beats):
        start = nearest_onset(t, words) if words else t
        dur = float(b["duration"])
        end = start + dur
        # snap the NEXT boundary too, so the beat can flex to the onset that follows.
        if words and i + 1 < len(beats):
            nb = nearest_onset(t + dur, words)
            if nb > start + 0.4:  # keep a sane minimum beat length
                end = nb
        nb_out = dict(b)
        nb_out["start"] = round(start, 3)
        nb_out["end"] = round(end, 3)
        nb_out["duration"] = round(end - start, 3)
        out_beats.append(nb_out)
        t = end

    manifest = dict(cfg)
    manifest["beats"] = out_beats
    manifest["total_duration_s"] = round(t, 3)
    (work / "beat-manifest.json").write_text(json.dumps(manifest, indent=2))
    print(f"[manifest] {len(out_beats)} beats, total {t:.2f}s -> {work/'beat-manifest.json'}")


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""compose.py — the deterministic FREE assembler for the myth-vs-fact ad.

Ports the validated assembly recipe from the Clinikally "acne myths" run
(working/build_master.py), generalized + portable (config-driven, no hardcoded paths):

  1. Concat the per-beat mp4s (already rendered by render_beats.py, all at the same fps)
     into a silent master. A framerate mismatch makes the concat demuxer silently drop
     frames, so every beat MUST be the configured fps (render_beats.py enforces + warns).
  2. Mix VO + optional music: music at -20 dB under the VO with a ~0.8s tail fade,
     `amix inputs=2 duration=first normalize=0` (normalize=1 pumps the bed under the VO).
     VO-only path skips the mix. Explicit `-map` so the silent placeholder AAC on the
     beat mp4s never wins the picker.
  3. Burn the karaoke .ass captions LAST onto the silent video + mixed audio -> master mp4.

This capability makes NO paid calls. All inputs come via --config + the work dir; the
recipe gates the paid VO / music / Whisper calls to their own capabilities.

Usage:
  compose.py --config config.json --work-dir /path/to/work --out master.mp4
             [--vo vo.mp3] [--music music.mp3] [--captions captions.ass]

Requires: ffmpeg/ffprobe on PATH.
"""
import argparse, json, os, subprocess, sys
from pathlib import Path


def run(cmd):
    r = subprocess.run(cmd, capture_output=True, text=True)
    if r.returncode:
        sys.stderr.write((r.stderr or "")[-2000:] + "\n")
        sys.exit(f"FAILED: {' '.join(str(c) for c in cmd[:6])} ...")
    return r


def ffprobe_dur(path):
    r = subprocess.run(["ffprobe", "-v", "error", "-show_entries", "format=duration",
                        "-of", "csv=p=0", str(path)], capture_output=True, text=True)
    return float(r.stdout.strip())


def concat_silent(beats, frames_dir, work, fps):
    lst = work / "concat.txt"
    lst.write_text("\n".join(f"file '{(frames_dir / f'beat-{b['n']}.mp4').resolve()}'"
                             for b in beats) + "\n")
    out = work / "master-silent.mp4"
    run(["ffmpeg", "-y", "-loglevel", "error", "-f", "concat", "-safe", "0",
         "-i", str(lst), "-c", "copy", str(out)])
    pk = subprocess.check_output(
        ["ffprobe", "-v", "error", "-select_streams", "v:0", "-count_packets",
         "-show_entries", "stream=nb_read_packets", "-of", "csv=p=0", str(out)]).decode().strip()
    dur = ffprobe_dur(out)
    print(f"[concat] {out} packets={pk} dur={dur:.2f}s expected~{dur*fps:.0f} frames")
    return out


def mix_audio(vo, music, work, music_db, tail_fade, video_dur=None):
    """Mix VO (+ optional music) → an m4a as long as the VIDEO. The final `burn` uses
    -shortest, so if the audio is shorter than the video (the normal case — the end card
    holds a beat past the last spoken word) the end-card hold gets silently truncated.
    Pad the audio to `video_dur` so the hold survives. `apad` runs BEFORE amix's
    duration=first collapses length, so the padded VO drives the output length."""
    out = work / "mixed-audio.m4a"
    # apad the VO bus to the full video length (harmless no-op when video_dur is None).
    pad = f",apad=whole_dur={video_dur:.3f}" if video_dur else ""
    if music and os.path.exists(music):
        vo_dur = ffprobe_dur(vo)
        fc = (f"[0:a]apad=whole_dur={video_dur:.3f}[vo];" if video_dur else "[0:a]anull[vo];")
        fc += (f"[1:a]volume={music_db}dB,"
               f"afade=t=out:st={max(0, (video_dur or vo_dur) - tail_fade):.2f}:d={tail_fade}[m];"
               f"[vo][m]amix=inputs=2:duration=first:normalize=0[a]")
        run(["ffmpeg", "-y", "-loglevel", "error", "-i", str(vo), "-i", str(music),
             "-filter_complex", fc, "-map", "[a]",
             "-c:a", "aac", "-b:a", "192k", "-ar", "44100", str(out)])
        print(f"[mix] {out} (VO + music@{music_db}dB, padded to {video_dur or vo_dur:.2f}s)")
    else:
        run(["ffmpeg", "-y", "-loglevel", "error", "-i", str(vo),
             "-af", f"anull{pad}", "-c:a", "aac", "-b:a", "192k", "-ar", "44100", str(out)])
        print(f"[mix] {out} (VO only, padded to {video_dur:.2f}s)" if video_dur
              else f"[mix] {out} (VO only)")
    return out


def burn(silent, audio, captions, out):
    ass = str(Path(captions).resolve()) if captions and os.path.exists(captions) else None
    if ass:
        vf = f"[0:v]ass='{ass}'[v]"
        run(["ffmpeg", "-y", "-loglevel", "error",
             "-i", str(silent), "-i", str(audio),
             "-filter_complex", vf, "-map", "[v]", "-map", "1:a:0",
             "-c:v", "libx264", "-pix_fmt", "yuv420p", "-crf", "18", "-preset", "medium",
             "-c:a", "aac", "-b:a", "192k", "-shortest", "-movflags", "+faststart", str(out)])
    else:
        # no captions -> just mux the mixed audio over the silent video
        run(["ffmpeg", "-y", "-loglevel", "error",
             "-i", str(silent), "-i", str(audio),
             "-map", "0:v:0", "-map", "1:a:0",
             "-c:v", "copy", "-c:a", "aac", "-b:a", "192k",
             "-shortest", "-movflags", "+faststart", str(out)])
    print(f"[final] {out} dur={ffprobe_dur(out):.2f}s")
    return out


def main():
    ap = argparse.ArgumentParser(description="Assemble the myth-vs-fact master.")
    ap.add_argument("--config", required=True)
    ap.add_argument("--work-dir", required=True)
    ap.add_argument("--out", required=True)
    ap.add_argument("--vo", help="VO mp3 (defaults to config.vo)")
    ap.add_argument("--music", help="music bed (defaults to config.music)")
    ap.add_argument("--captions", help="captions .ass (defaults to work-dir/captions.ass)")
    a = ap.parse_args()

    cfg = json.load(open(a.config))
    work = Path(a.work_dir)
    work.mkdir(parents=True, exist_ok=True)
    frames_dir = work / "frames"
    fps = int(cfg.get("fps", 25))

    # Prefer the re-snapped manifest if beat_snap.py ran; else the raw config beats.
    manifest_path = work / "beat-manifest.json"
    beats = json.load(open(manifest_path))["beats"] if manifest_path.exists() else cfg["beats"]

    vo = a.vo or cfg.get("vo")
    if not vo or not os.path.exists(vo):
        sys.exit(f"VO not found: {vo} (pass --vo or set config.vo)")
    music = a.music or cfg.get("music")
    captions = a.captions or str(work / "captions.ass")
    mix_cfg = cfg.get("mix", {})
    music_db = mix_cfg.get("music_db", -20)
    tail_fade = mix_cfg.get("tail_fade", 0.8)

    silent = concat_silent(beats, frames_dir, work, fps)
    # Pad audio to the silent video's real length so -shortest keeps the full end-card hold.
    audio = mix_audio(vo, music, work, music_db, tail_fade, video_dur=ffprobe_dur(silent))
    final = burn(silent, audio, captions, a.out)

    md = ffprobe_dur(final)
    expected = sum(float(b["duration"]) for b in beats)
    print(f"WROTE {final}  {md:.2f}s (expected ~{expected:.2f}s, delta {md - expected:+.2f}s)")


if __name__ == "__main__":
    main()

{
  "_comment": "Illustrative worked config — the values are the validated Clinikally 'acne myths' run, brand-neutralised. The recipe binds a NEW brand's own copy / VO / palette / end-card here. Every /abs/or/working/... path is a placeholder to REPLACE with an absolute path or a runtime work-dir path. Pipeline: (1) beat_snap.py re-snaps every beat boundary to the RENDERED VO's Whisper word onsets (writes beat-manifest.json + whisper/words-flat.json into the work dir); (2) render_beats.py renders each beat to frames/beat-NN.mp4 via Playwright at `fps`; (3) make_captions.py emits captions.ass from the manifest + words; (4) compose.py concats the beats + mixes VO/music + burns captions. VO-FIRST: render the VO, then beat_snap, then render_beats.",

  "fps": 25,
  "width": 1080,
  "height": 1920,

  "vo": "/abs/or/working/voice/vo.mp3",
  "music": "/abs/or/working/music/music.mp3",
  "mix": { "music_db": -20, "tail_fade": 0.8 },

  "brand_name": "Brand",
  "display_font": "DM Serif Display",

  "palette": {
    "bg": "#F4F1F7",
    "myth_strike": "#C0392B",
    "fact_accent": "#108474",
    "headline_ink": "#411A1F",
    "accent": "#5E3FA0"
  },

  "end_card_png": "/abs/or/working/assets/end_card.png",
  "end_card_fade": 0.35,

  "caption_style": {
    "font": "Inter",
    "size": 58,
    "primary": "&H001F1A41",
    "outline_colour": "&H00F7F1F4",
    "back_colour": "&H66F7F1F4",
    "border_style": 3,
    "outline": 10,
    "marginv": 150
  },

  "_suppress_note": "The proof beat + end card carry their own low-area text; captions there collide. beats flagged captions:false and any role:end-card are auto-suppressed; suppress_beats adds more by beat n.",
  "suppress_beats": ["06", "08"],

  "beats": [
    {
      "n": "01", "role": "hook", "duration": 3.97, "captions": true,
      "eyebrow": "3 ACNE \"TIPS\"",
      "hook_line": "Tips a dermatologist would never give.",
      "emphasis": "never",
      "strike_word": "TIPS",
      "cues": { "strike": [2.89, 3.40], "wordmark": [3.45, 3.85] }
    },
    {
      "n": "02", "role": "myth-fact", "duration": 3.44, "captions": true,
      "myth_index": "01",
      "myth_line": "“Pop it and it clears faster.”",
      "fact_line": "Popping pushes bacteria deeper — [scars + dark marks.]",
      "cues": { "strike": [1.36, 1.96], "fact": [2.14, 2.59] }
    },
    {
      "n": "03", "role": "myth-fact", "duration": 4.84, "captions": true,
      "myth_index": "02",
      "myth_line": "“Lemon / toothpaste dries it out.”",
      "fact_line": "DIY burns your skin barrier — [redness, worse marks.]",
      "cues": { "strike": [0.82, 1.42], "fact": [1.42, 1.91] }
    },
    {
      "n": "04", "role": "myth-fact", "duration": 3.54, "captions": true,
      "myth_index": "03",
      "myth_line": "“Scrub harder, wash more.”",
      "fact_clauses": [
        { "text": "Over-washing strips your oil" },
        { "text": "skin overproduces to fight back" },
        { "text": "more breakouts.", "hot": true }
      ],
      "cues": { "strike": [0.82, 1.42], "clauses": [1.42, 2.24, 2.72] }
    },
    {
      "n": "05", "role": "turn", "duration": 4.44, "captions": true,
      "turn_slate": "What actually works is [boring.]",
      "turn_sub": "Ingredients with [real clinical evidence.]",
      "cues": { "head": [0.10, 0.70], "sub": [2.18, 2.78] }
    },
    {
      "n": "06", "role": "proof", "duration": 5.06, "captions": false,
      "proof_eyebrow": "What works — with evidence",
      "proof_items": [
        { "name": "Salicylic acid", "badge": "Rx-grade" },
        { "name": "Benzoyl peroxide", "badge": "Rx-grade" },
        { "name": "Adapalene", "badge": "Rx-grade" }
      ],
      "proof_footnote": "Prescription-grade — [matched to your skin by a doctor.]",
      "cues": { "items": [0.00, 0.92, 2.00], "footnote": [2.58, 3.10] }
    },
    {
      "n": "07", "role": "punch", "duration": 1.12, "captions": true,
      "punch_line": "Stop guessing."
    },
    {
      "n": "08", "role": "end-card", "duration": 3.11, "captions": false
    }
  ]
}

#!/usr/bin/env python3
"""make_captions.py — emit a libass .ass karaoke caption file from Whisper words.

Ports the validated caption recipe from the Clinikally run (build_master.build_ass):
  - <=3 words per cue; close a chunk on a >0.4s word gap, a beat-window edge, OR a
    sentence-ending punctuation mark (. ? !) so the last word of one beat never merges
    with the first of the next.
  - Captions are burned ONLY during caption-allowed beat windows. SUPPRESS_BEATS (the
    proof/footnote beat + the end card) carry their own low-area text — two text layers at
    one spot both go unreadable.
  - The ASS `Format:` line MUST carry the `Name` field or every cue gets a leading-comma
    artifact.

Reads the SAME beat-manifest.json + words-flat.json that compose.py reads, so windows stay
in lockstep with the cut. Suppressed beats come from config.suppress_beats (default: the
proof beat + the end card).

Usage:
  make_captions.py --manifest beat-manifest.json --words words-flat.json --out captions.ass
                   [--config config.json]
"""
import argparse, json
from pathlib import Path


def sec_to_ass(t):
    h = int(t // 3600); m = int((t % 3600) // 60); s = t % 60
    return f"{h}:{m:02d}:{s:05.2f}"


def caption_windows(beats, suppress):
    return [(b["start"], b["end"]) for b in beats if b["n"] not in suppress]


def in_windows(t, wins):
    return any(s <= t < e for s, e in wins)


def build_ass(beats, words, suppress, style):
    wins = caption_windows(beats, suppress)
    kept = [w for w in words
            if w.get("start") is not None and w.get("end") is not None
            and in_windows((w["start"] + w["end"]) / 2, wins)]

    chunks, cur = [], []
    for w in kept:
        if cur:
            gap = w["start"] - cur[-1]["end"]
            cross = not in_windows((cur[-1]["end"] + w["start"]) / 2, wins)
            sent_end = cur[-1]["text"].rstrip().endswith((".", "?", "!"))
            if gap > 0.4 or len(cur) >= 3 or cross or sent_end:
                chunks.append(cur); cur = []
        cur.append(w)
    if cur:
        chunks.append(cur)

    font = style.get("font", "Inter")
    size = style.get("size", 58)
    prim = style.get("primary", "&H00FFFFFF")     # BGR + alpha; default white
    outline = style.get("outline_colour", "&H00141414")
    back = style.get("back_colour", "&H66000000")
    border = style.get("border_style", 3)          # 3 = opaque box
    outline_w = style.get("outline", 10)
    marginv = style.get("marginv", 150)

    L = []
    L += ["[Script Info]", "ScriptType: v4.00+", "PlayResX: 1080", "PlayResY: 1920",
          "WrapStyle: 2", "ScaledBorderAndShadow: yes", ""]
    L += ["[V4+ Styles]",
          ("Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, "
           "OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, "
           "ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, "
           "MarginR, MarginV, Encoding"),
          (f"Style: Cap,{font},{size},{prim},{prim},{outline},{back},1,0,0,0,100,100,0,0,"
           f"{border},{outline_w},0,2,90,90,{marginv},1"), ""]
    # NOTE: the Events Format line MUST include `Name` (empty field after Style) or every
    # burned cue gets a leading-comma artifact.
    L += ["[Events]",
          "Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text"]
    for ch in chunks:
        txt = " ".join(w["text"] for w in ch).strip()
        L.append(f"Dialogue: 0,{sec_to_ass(ch[0]['start'])},{sec_to_ass(ch[-1]['end'])},"
                 f"Cap,,0,0,0,,{txt}")
    return "\n".join(L) + "\n", len(chunks), len(kept)


def main():
    ap = argparse.ArgumentParser(description="Emit karaoke .ass from Whisper words.")
    ap.add_argument("--manifest", required=True)
    ap.add_argument("--words", required=True)
    ap.add_argument("--out", required=True)
    ap.add_argument("--config", help="optional config.json (for suppress_beats + caption_style)")
    a = ap.parse_args()

    manifest = json.load(open(a.manifest))
    beats = manifest["beats"]
    words = json.load(open(a.words))
    cfg = json.load(open(a.config)) if a.config else {}
    # Default suppression: any beat flagged captions:false, plus explicit config list.
    suppress = set(cfg.get("suppress_beats", []))
    suppress |= {b["n"] for b in beats if b.get("captions") is False or b.get("role") == "end-card"}
    style = cfg.get("caption_style", {})

    text, nchunks, nwords = build_ass(beats, words, suppress, style)
    Path(a.out).write_text(text)
    print(f"captions.ass written — {nchunks} chunks from {nwords} words "
          f"(suppressed beats {sorted(suppress)}) -> {a.out}")


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""render_beats.py — deterministically render each myth-vs-fact beat to an mp4.

Ports the validated Playwright + ffmpeg renderer from the Clinikally "acne myths" run,
generalized to be config-driven and portable (no hardcoded /Users or clients/ paths).

For every `mg` beat the renderer:
  1. picks the role template under hyperframes/ (hook | myth-fact | turn | proof | punch),
  2. injects the beat's spec + palette + fonts as `window.BEAT` (so ONE template renders
     any myth/fact pair — the copy + cue times all come from config),
  3. drives `window.renderAt(t)` frame-by-frame via Playwright, screenshots each frame,
  4. pipes the frames to ffmpeg at EXACTLY the configured fps (default 25/1 — a mismatch
     makes the concat demuxer silently drop frames), muxing a silent AAC placeholder track
     so the concat demuxer is happy.

The final `end-card` beat is NOT rendered from HTML — it is built from the pre-supplied
brand end_card_png (scaled/cropped to the canvas with a short fade-up). NEVER generate the
end card per run.

Animation is a PURE function of beat-local time (no setTimeout / CSS keyframes), so seeks
are frame-exact and the render is fully reproducible.

Usage:
  render_beats.py --config config.json --work-dir /path/to/work [--only 01 02]

Requires: Playwright (chromium) + ffmpeg/ffprobe.  pip install playwright && playwright install chromium
"""
import argparse, json, os, subprocess, sys, tempfile, shutil
from pathlib import Path

HERE = Path(__file__).resolve().parent
HF = HERE / "hyperframes"

# role -> template filename under hyperframes/
ROLE_TEMPLATE = {
    "hook": "beat-hook.html",
    "myth-fact": "beat-myth-fact.html",
    "turn": "beat-turn.html",
    "proof": "beat-proof.html",
    "punch": "beat-punch.html",
}


def ffprobe_rate(path):
    r = subprocess.run(
        ["ffprobe", "-v", "error", "-select_streams", "v:0",
         "-show_entries", "stream=r_frame_rate", "-of", "csv=p=0", str(path)],
        capture_output=True, text=True)
    return r.stdout.strip()


def render_html_beat(template, out_mp4, duration, beat_spec, fps, w, h):
    """Playwright: inject window.BEAT, step renderAt(t) per frame, screenshot -> ffmpeg."""
    from playwright.sync_api import sync_playwright

    # Copy the template + shared assets into an isolated dir so relative _shared.* resolve
    # and window.BEAT is injected before the page's own script runs.
    tmp = Path(tempfile.mkdtemp(prefix="mvf_"))
    frames_dir = tmp / "frames"
    frames_dir.mkdir()
    for asset in ("_shared.css", "_shared.js"):
        shutil.copy(HF / asset, tmp / asset)
    page_html = tmp / "page.html"
    src = (HF / template).read_text()
    inject = f"<script>window.BEAT = {json.dumps(beat_spec)};</script>\n"
    # inject BEFORE _shared.js so loadBeatSpec() picks up window.BEAT.
    src = src.replace('<script src="_shared.js"></script>',
                      inject + '<script src="_shared.js"></script>')
    page_html.write_text(src)

    with sync_playwright() as p:
        browser = p.chromium.launch()
        ctx = browser.new_context(viewport={"width": w, "height": h}, device_scale_factor=1)
        page = ctx.new_page()
        page.goto(f"file://{page_html}")
        page.wait_for_load_state("networkidle")
        page.evaluate("document.fonts.ready")
        page.wait_for_timeout(300)  # let web fonts settle after networkidle
        n_frames = int(round(duration * fps))
        for i in range(n_frames):
            page.evaluate(f"window.renderAt({i / fps})")
            page.screenshot(path=str(frames_dir / f"frame_{i:05d}.png"),
                            clip={"x": 0, "y": 0, "width": w, "height": h})
        browser.close()

    subprocess.run([
        "ffmpeg", "-y", "-loglevel", "error",
        "-framerate", str(fps), "-i", str(frames_dir / "frame_%05d.png"),
        "-f", "lavfi", "-t", f"{duration}", "-i",
        "anullsrc=channel_layout=stereo:sample_rate=44100",
        "-c:v", "libx264", "-pix_fmt", "yuv420p", "-crf", "18", "-preset", "medium",
        "-r", str(fps), "-c:a", "aac", "-shortest", "-movflags", "+faststart",
        str(out_mp4),
    ], check=True)
    shutil.rmtree(tmp)


def build_end_card(png, out_mp4, duration, fps, w, h, fade=0.35):
    """Static end card: scale/crop the pre-built brand PNG to the canvas + a short fade-up."""
    vf = (f"scale={w}:{h}:force_original_aspect_ratio=increase,crop={w}:{h},"
          f"format=yuv420p,fade=t=in:st=0:d={fade}")
    subprocess.run([
        "ffmpeg", "-y", "-loglevel", "error",
        "-loop", "1", "-framerate", str(fps), "-t", f"{duration}", "-i", str(png),
        "-f", "lavfi", "-t", f"{duration}", "-i",
        "anullsrc=channel_layout=stereo:sample_rate=44100",
        "-vf", vf, "-r", str(fps),
        "-c:v", "libx264", "-pix_fmt", "yuv420p", "-crf", "18", "-preset", "medium",
        "-c:a", "aac", "-shortest", "-movflags", "+faststart", str(out_mp4),
    ], check=True)


def main():
    ap = argparse.ArgumentParser(description="Render each myth-vs-fact beat to mp4.")
    ap.add_argument("--config", required=True)
    ap.add_argument("--work-dir", required=True)
    ap.add_argument("--only", nargs="*", help="render only these beat ids (e.g. 01 02)")
    a = ap.parse_args()

    cfg = json.load(open(a.config))
    fps = int(cfg.get("fps", 25))
    w = int(cfg.get("width", 1080))
    h = int(cfg.get("height", 1920))
    palette = cfg.get("palette", {})
    fonts = cfg.get("fonts", {})
    display_font = cfg.get("display_font")
    brand_name = cfg.get("brand_name", "")
    end_card_png = cfg.get("end_card_png")

    work = Path(a.work_dir)
    frames = work / "frames"
    frames.mkdir(parents=True, exist_ok=True)

    failed = []
    for b in cfg["beats"]:
        n = b["n"]
        if a.only and n not in a.only:
            continue
        role = b.get("role")
        dur = float(b["duration"])
        out = frames / f"beat-{n}.mp4"

        if role == "end-card":
            if not end_card_png or not os.path.exists(end_card_png):
                print(f"  FAILED beat-{n}: end_card_png missing ({end_card_png})")
                failed.append(n); continue
            print(f"[end-card] beat-{n} ({dur}s)")
            build_end_card(end_card_png, out, dur, fps, w, h,
                           fade=float(cfg.get("end_card_fade", 0.35)))
            continue

        template = ROLE_TEMPLATE.get(role)
        if not template:
            print(f"  FAILED beat-{n}: unknown role '{role}'")
            failed.append(n); continue

        # Build the per-beat window.BEAT spec: palette + fonts + duration + the beat's copy.
        spec = dict(b)
        spec["palette"] = palette
        spec["brand_name"] = spec.get("brand_name", brand_name)
        if display_font:
            spec["display_font"] = display_font
        if fonts:
            spec["fonts"] = fonts

        print(f"[render] beat-{n} ({role}, {dur}s) -> {template}")
        try:
            render_html_beat(template, out, dur, spec, fps, w, h)
        except Exception as e:
            print(f"  FAILED beat-{n}: {e}")
            failed.append(n); continue

        rate = ffprobe_rate(out)
        if rate != f"{fps}/1":
            print(f"  WARN beat-{n} r_frame_rate={rate} (expected {fps}/1)")

    if failed:
        print(f"\nFailed beats: {failed}")
        sys.exit(1)
    print("\nAll requested beats rendered.")


if __name__ == "__main__":
    main()

# Smoke test — render-myth-vs-fact

Verifies the free deterministic assembly end-to-end. No paid calls. Needs: Python 3,
**Playwright chromium** (for the hyperframe render), and `ffmpeg`/`ffprobe`. If
Playwright/browsers aren't installed, skip Phase A (the render) and validate the
concat/mix/caption path (Phase B) with synthetic beat mp4s + a synthetic VO.

## Setup

```bash
cd scripts
python3 -m pip install playwright && playwright install chromium   # if not present
mkdir -p /tmp/mvf-smoke
# Copy the example config and REPLACE the paths / copy for a real run:
#   - "vo"           : the RENDERED VO mp3 (measured; the timeline hangs off it)
#   - "music"        : an instrumental bed (or delete the key for VO-only)
#   - "end_card_png" : the pre-built brand end-card PNG (9:16)
#   - "palette"      : the five CSS-var tokens (bg / myth_strike / fact_accent /
#                      headline_ink / accent)
#   - "beats[]"      : the myth/fact pairs + hook / turn / punch copy + cue times
cp config.example.json /tmp/mvf-smoke/config.json
```

## Phase A — one myth→fact beat (Playwright present)

Renders a single flip card to confirm the frame-exact render + the per-line strike.

```bash
# render ONLY the myth-fact beat (id 02 in the example config)
python3 render_beats.py --config /tmp/mvf-smoke/config.json \
                        --work-dir /tmp/mvf-smoke --only 02
ffprobe -v error -select_streams v:0 \
  -show_entries stream=r_frame_rate,width,height,nb_frames \
  -show_entries format=duration -of default=nw=1 /tmp/mvf-smoke/frames/beat-02.mp4
# eyeball a mid-beat frame (FACT resolved + strike done)
ffmpeg -y -loglevel error -ss 2.4 -i /tmp/mvf-smoke/frames/beat-02.mp4 \
       -frames:v 1 /tmp/mvf-smoke/frame_check.png
```

## Phase B — beat-snap + captions + compose

VO-first: snap beats to the VO, build captions, assemble. Use `--no-whisper` (no FAL) to
run fully offline off the config durations.

```bash
# 1) beat-snap (writes beat-manifest.json + whisper/words-flat.json)
python3 beat_snap.py --config /tmp/mvf-smoke/config.json \
                     --work-dir /tmp/mvf-smoke --no-whisper     # or drop --no-whisper (needs FAL_KEY)

# 2) captions (from the manifest + words)
python3 make_captions.py --manifest /tmp/mvf-smoke/beat-manifest.json \
                         --words /tmp/mvf-smoke/whisper/words-flat.json \
                         --out /tmp/mvf-smoke/captions.ass \
                         --config /tmp/mvf-smoke/config.json

# 3) assemble the master (concat beats -> mix VO/music -> burn captions)
python3 compose.py --config /tmp/mvf-smoke/config.json \
                   --work-dir /tmp/mvf-smoke \
                   --out /tmp/mvf-smoke/master.mp4
```

For a Playwright-free assembly check, synthesize the beat mp4s + VO first:

```bash
# a 1080x1920 solid-color beat + a matching-length VO tone, per beat n in the manifest
ffmpeg -y -f lavfi -i color=c=0xF4F1F7:s=1080x1920:d=3.44 -r 25 \
  -f lavfi -t 3.44 -i anullsrc=cl=stereo:r=44100 \
  -c:v libx264 -pix_fmt yuv420p -shortest /tmp/mvf-smoke/frames/beat-02.mp4
ffmpeg -y -f lavfi -i "sine=frequency=220:duration=3.44" -ar 44100 -ac 2 /tmp/mvf-smoke/vo.mp3
# then run steps 1-3 above (a single-beat manifest)
```

## Expect

- `render_beats.py` writes `frames/beat-02.mp4`: **1080×1920, `r_frame_rate=25/1`**,
  `nb_frames == round(duration × 25)`, duration within ±0.04s. The mid-beat frame shows a
  red MYTH pill, the myth line struck through with a red bar crossing the vertical MIDDLE of
  **every** wrapped line, and the teal FACT check + payload with the `[bracketed]` phrase
  accented — NOT an underline on line 1 only, NO AI-rendered text.
- `beat_snap.py` writes `beat-manifest.json` (beats with `start`/`end`/`duration`) +
  `whisper/words-flat.json`.
- `make_captions.py` writes `captions.ass` — reports `N chunks from M words` and the
  suppressed beats. The `Events Format:` line carries the `Name` field (no leading-comma
  artifact); the proof + end-card beats are suppressed.
- `compose.py` prints the concat packet count, the mix line (`VO + music@-20dB` or
  `VO only`), and `WROTE … (expected ~Xs, delta ±…)`. `master.mp4` is 1080×1920, 25fps,
  h264+aac; duration within ±0.1s of the summed beat durations; `volumedetect` mean is well
  above silence (VO present).
- Run the `watch` skill on `master.mp4`: the red strike crosses every wrapped myth line, the
  VO is intelligible, captions are legible with no card collision, suppression is correct on
  the proof + end-card beats, framerate is uniform 25/1, no clipping, every claim is legible
  sound-off.

## Fail signals

- **Strike reads as an underline on line 1 / floats above line 2** → a single fixed-Y rule
  was used instead of `buildLineStrikes` + `strikeLines`; the per-line measure is
  load-bearing on any wrapped myth.
- **Concat drops frames / audio desyncs** → a beat mp4 isn't the configured fps.
  `render_beats.py` warns on any `r_frame_rate != <fps>/1`; re-render the offending beat.
- **Every caption has a leading comma** → the ASS `Events Format:` line is missing the
  `Name` field.
- **Captions collide with the proof footnote or the end-card text** → those beats weren't
  suppressed; add them to `suppress_beats` or set `captions:false` on the beat.
- **Music pumps under the VO** → `amix normalize=0` got flipped to `normalize=1`.
- **Master is silent** (`volumedetect` mean ≈ −90 dB) → the beat mp4s' silent placeholder
  AAC won the picker; `compose.py` maps the mixed audio explicitly — confirm `--vo` resolved.
- **End card shows AI-rendered art / smeared text** → `end_card_png` points at a generated
  image; the end card is ALWAYS the pre-built brand PNG, never generated per run.
```