""" HyperFrames HTML Composition Compiler v3.0 (`html_builder.py`) Supports: - 10 Procedural Canvas + Theme Background Presets (`--bg`, incl. `wireframe_globe`, `isometric_hud_grid`, `auto`, `cycle`) - 3 HUD Styles (`--hud-style`: `chapter_tabs`, `tech_briefing`, `minimal`) - 6 Subtitle / Caption Styles (`--caption-style`: `glass_dual`, `briefing_clean`, `pill_karaoke`, `cinema_minimal`, `neon_bar_left`, `kinetic_pop`) - 16 Visual Motion Scene Archetypes (incl. IT톡톡 Deep-Dive Briefings, Text Scramble, Real Video/Image PiP Frames, Vertical Changelog, 3D Mission Staircase, /swarm Network Graph, Pricing Matrix, Bento Grid, 3D Open-Book Flip, Spiral Notebook, etc.) """ from __future__ import annotations import html import json import math import re import shutil import subprocess import urllib.request from pathlib import Path from typing import Any from deck_video_pipeline.themes_and_presets import ( BACKGROUND_PRESETS, CANVAS_RENDERERS_JS, auto_select_background, ) from deck_video_pipeline.pronunciation_engine import balance_subtitle_lines PIPELINE_ROOT = Path(__file__).resolve().parent PRETENDARD_URL = "https://cdn.jsdelivr.net/gh/orioncactus/pretendard@v1.3.9/packages/pretendard/dist/web/variable/woff2/PretendardVariable.woff2" GSAP_URL = "https://cdn.jsdelivr.net/npm/gsap@3.14.2/dist/gsap.min.js" def _ensure_static_vendor_assets(offline: bool = True) -> tuple[Path, Path]: font_src = PIPELINE_ROOT / "assets" / "fonts" / "PretendardVariable.woff2" gsap_src = PIPELINE_ROOT / "assets" / "js" / "gsap.min.js" font_src.parent.mkdir(parents=True, exist_ok=True) gsap_src.parent.mkdir(parents=True, exist_ok=True) if offline: return font_src, gsap_src if not font_src.exists() or font_src.stat().st_size < 100_000: urllib.request.urlretrieve(PRETENDARD_URL, str(font_src)) if not gsap_src.exists() or gsap_src.stat().st_size < 10_000: urllib.request.urlretrieve(GSAP_URL, str(gsap_src)) return font_src, gsap_src def _esc(val: Any) -> str: return html.escape(str(val or ""), quote=True) def _esc_balanced_sub(val: Any, lang: str = "ko") -> str: balanced = balance_subtitle_lines(str(val or ""), lang=lang) return "
".join(_esc(part) for part in balanced.split("\n")) def _split_card_item(raw: str, idx: int) -> tuple[str, str]: if "|" in raw: parts = [x.strip() for x in raw.split("|")] return parts[0], " · ".join(parts[1:]) if "·" in raw: left, right = [x.strip() for x in raw.split("·", 1)] return left, right words = raw.strip().split() if len(words) >= 3: return " ".join(words[:2]), " ".join(words[2:]) return f"포인트 {idx + 1:02d}", raw.strip() # --------------------------------------------------------------------------- # 6 New IT톡톡 Tech-Briefing Scene Renderers (v3.0) # --------------------------------------------------------------------------- def _render_hero_3d_briefing_scene(slide: dict[str, Any], s_idx: int) -> str: sid = f"s{s_idx + 1}" hero_word = slide.get("hero_word") or slide.get("title", "TECH BRIEFING") sub_line = slide.get("subtitle") or slide.get("highlight_quote") or "" bullets = slide.get("bullets") or ["화면", "음성", "모델", "/swarm", "워크플로", "요금"] pill_colors = [ ("#34d399", "rgba(6, 78, 59, 0.78)"), ("#a78bfa", "rgba(46, 16, 101, 0.78)"), ("#38bdf8", "rgba(12, 74, 110, 0.78)"), ("#fbbf24", "rgba(120, 53, 15, 0.78)"), ("#fb7185", "rgba(136, 19, 55, 0.78)"), ("#fdba74", "rgba(124, 45, 18, 0.78)"), ("#cbd5e1", "rgba(30, 41, 59, 0.82)"), ] tags_html = [] for i, b in enumerate(bullets[:7]): label = b.split("|")[0].strip()[:12] b_col, bg_col = pill_colors[i % len(pill_colors)] tags_html.append( f'{_esc(label)}' ) src_note = ( f'
{_esc(slide["source_note"])}
' if slide.get("source_note") else "" ) return f"""
{_esc(slide.get("badge", "DEEP DIVE BRIEFING"))}

{_esc(hero_word)}

{_esc(sub_line)}
{"".join(tags_html)}
{src_note}
""" def _render_media_showcase_split_scene( slide: dict[str, Any], s_idx: int, rel_media_path: str, media_kind: str, ) -> str: sid = f"s{s_idx + 1}" bullets = slide.get("bullets") or [] quote_line = slide.get("highlight_quote") or (bullets[0] if bullets else slide.get("title", "")) hero_kw = slide.get("hero_word") or "LIVE" scramble_target = slide.get("scramble_text") or slide.get("subtitle") or (bullets[1] if len(bullets) > 1 else slide.get("title", "")) extra_desc = bullets[2] if len(bullets) > 2 else (bullets[0] if bullets and bullets[0] != quote_line else "") media_cap = slide.get("media_caption") or slide.get("source_note") or "실시간 시연 화면" if media_kind == "image" and rel_media_path: frame_body = f'' elif media_kind == "video" and rel_media_path: # Video element itself is mounted as a top-level sibling clip at exact same coordinates frame_body = '
' else: # Built-in crisp live UI preview card when no external file is attached sim_rows = "".join( f'
{_esc(b.replace("|", " · "))}
' for b in (bullets[:3] or [slide.get("title", "Live Demo")]) ) frame_body = f"""
● New Session● LIVE
{sim_rows}
""" extra_html = f'
{_esc(extra_desc.replace("|", " · "))}
' if extra_desc else "" frame_extra_cls = " video-host-hidden" if (media_kind == "video" and rel_media_path) else "" return f"""
{_esc(slide.get("badge", "FEATURE SHOWCASE"))}
“{_esc(quote_line.replace("|", " · "))}”
{_esc(hero_kw)}
{_esc(scramble_target)}
{extra_html}
{frame_body}
{_esc(media_cap)}
""" def _render_dossier_stamp_scene(slide: dict[str, Any], s_idx: int) -> str: """Documentary official folder / patent dossier card with tilted rubber stamp (설명좋아하는아저씨 스타일).""" sid = f"s{s_idx + 1}" bullets = (slide.get("bullets") or ["핵심 항목 | 세부 내용 요약"])[:4] title = slide.get("title", "공식 문서 요약") combined_hdr = (title + " " + slide.get("badge", "") + " " + slide.get("stamp_text", "")).lower() is_statement = any(k in combined_hdr for k in ["해명", "공식 입장", "statement", "우려", "논란", "없음", "불가", "반박"]) is_patent = (not is_statement) and any(k in combined_hdr for k in ["특허", "patent", "uspto", "등록"]) folder_cls = "dossier-card-white" if is_patent else "dossier-card-kraft" tab_label = slide.get("badge") if slide.get("badge") and not slide.get("badge", "").startswith("SECTION") else ( "USPTO REGISTERED PATENT" if is_patent else "OFFICIAL STATEMENT · 공식 문서 요약" ) stamp_txt = slide.get("stamp_text") or ("PATENT REGISTERED" if is_patent else "핵심 쟁점 확인") stamp_cls = "rubber-stamp stamp-blue" if is_patent else "rubber-stamp stamp-red" rows_html = [] for i, raw in enumerate(bullets): k_txt, v_txt = _split_card_item(raw, i) rows_html.append(f"""
{_esc(k_txt)} {_esc(v_txt)}
""") meta_right = slide.get("source_note") or slide.get("subtitle") or "" meta_html = f'{_esc(meta_right)}' if meta_right else "" return f"""
{_esc(tab_label)}

{_esc(title)}

{meta_html}
{"".join(rows_html)}
{_esc(stamp_txt)}
""" def _render_cinema_broll_scene( slide: dict[str, Any], s_idx: int, rel_media_path: str, media_kind: str, ) -> str: """Full-screen documentary B-Roll (image Ken-Burns or sibling video) with dark cinema vignette.""" sid = f"s{s_idx + 1}" kicker = slide.get("badge") if slide.get("badge") and not slide.get("badge", "").startswith("SECTION") else "" kicker_html = f'
{_esc(kicker)}
' if kicker else "" if media_kind == "image" and rel_media_path: bg_layer = f'' center_card = "" elif media_kind == "video" and rel_media_path: bg_layer = "" center_card = "" else: bg_layer = "" center_card = f"""
{kicker_html}

{_esc(slide.get("title", ""))}

""" return f"""
{bg_layer}
{center_card}
""" def _render_depth_cross_section_scene(slide: dict[str, Any], s_idx: int) -> str: """DeepFactLab-style cross-section depth exploration + descending yellow submersible + evidence quote card.""" sid = f"s{s_idx + 1}" bullets = slide.get("bullets") or [ "수면 0m | 해발 약 2,189m 칼데라 호수", "수심 40m | 빛과 카메라가 멈추는 한계선", "수심 384m | 설악산 대청봉보다 높은 맨 바닥", ] sticker_main = slide.get("subtitle") or slide.get("title", "수심 단면 탐사") sticker_sub = ( slide.get("badge") if slide.get("badge") and not slide.get("badge", "").startswith("SECTION") else "가상 탐사 · 설명용 단면" ) quote_raw = slide.get("highlight_quote") or (bullets[-1].replace("|", " — ") if bullets else slide.get("title", "")) src_foot = slide.get("source_note") or "설명용 단면도 · 공식 기록 요지" depth_labels = [] y_positions = [132, 232, 336, 428] for i, b in enumerate(bullets[:4]): head, desc = _split_card_item(b, i) yp = y_positions[i] depth_labels.append( f'' f'' f'' f'{_esc(head[:11])}' f'{_esc(desc[:28])}' f'' ) return f"""
{_esc(sticker_main[:28])}
{_esc(sticker_sub[:24])}
{"".join(depth_labels)}
📄 탐사 기록 · 팩트 검증
“{_esc(quote_raw[:68])}
— {_esc(src_foot)}
""" def _render_sonar_factcheck_map_scene( slide: dict[str, Any], s_idx: int, rel_media_path: str, media_kind: str, ) -> str: """DeepFactLab-style Multi-Beam Bathymetric Sonar Contour Map OR Photo Zone ①②③ Fact-Check Stage.""" sid = f"s{s_idx + 1}" bullets = (slide.get("bullets") or ["굳은 마그마 둑 | 화산 분화 흔적", "바닥 웅덩이 | 온천 용출 지점", "무너진 칼데라 벽 | 암석 퇴적 지대"])[:4] verdict_txt = slide.get("stamp_text") or slide.get("hero_word") or "기록 검증 완료" is_false_claim = any(k in (verdict_txt + " " + slide.get("title", "")).lower() for k in ["없", "아님", "거짓", "오해", "불가", "괴물", "x", "✕"]) src_foot = slide.get("source_note") or "다중빔 음향 측심 · 현장 조사 기록 재구성" if media_kind == "image" and rel_media_path: # Photo + Numbered Dashed Yellow Investigation Polygons (f_370.jpg style) zone_polys = [ ("160,150 310,120 430,275 315,330 190,260", 290, 230, 485, 305), ("365,135 520,185 605,310 510,335 420,245", 485, 250, 665, 325), ("555,105 705,145 735,230 635,245 555,180", 645, 178, 795, 225), ("265,355 595,365 695,435 550,465 280,450", 475, 412, 765, 405), ] zones_svg = [] for i in range(min(len(bullets), 4)): pts, cx, cy, ax, ay = zone_polys[i] zones_svg.append( f'' f'' f'' f'' f'{i + 1}' f'' ) legend_rows = "".join( f'
{i + 1}{_esc(b.replace("|", " · "))}
' for i, b in enumerate(bullets) ) visual_left = f"""
{"".join(zones_svg)}
""" else: # Pure SVG Multi-Beam Sonar Contour Map + Callout Pointers + Red X / Check Verdict (f_465.jpg style) callouts_cfg = [ (118, 175, 365, 228, "#b45309"), (690, 128, 520, 215, "#1d4ed8"), (128, 392, 345, 355, "#475569"), (685, 388, 545, 338, "#0f766e"), ] callouts_svg = [] for i, b in enumerate(bullets): head, _ = _split_card_item(b, i) bx, by, tx, ty, col = callouts_cfg[i % len(callouts_cfg)] lx = bx + 158 if bx < 400 else bx callouts_svg.append( f'' f'' f'' f'{_esc(head[:10])}' f'' ) mark_svg = ( f'' f'' f'' f'' f'' if is_false_claim else f'' f'' f'' f'' ) legend_rows = "".join( f'
{i + 1}{_esc(b.replace("|", " · "))}
' for i, b in enumerate(bullets) ) visual_left = f"""
{"".join(callouts_svg)} {mark_svg}
""" verdict_cls = "df-verdict-pill verdict-false" if is_false_claim else "df-verdict-pill verdict-true" return f"""
{visual_left}
{_esc(verdict_txt)}

{_esc(slide.get("title", "음향 측심 및 기록 검증"))}

{legend_rows}
{_esc(src_foot)}
""" def _make_gear_svg_path(cx: float, cy: float, r_outer: float, r_inner: float, teeth: int) -> str: pts: list[str] = [] steps = teeth * 4 for i in range(steps): ang = (2.0 * math.pi * i) / steps r = r_outer if (i % 4 in (0, 1)) else r_inner px = cx + r * math.cos(ang) py = cy + r * math.sin(ang) cmd = "M" if i == 0 else "L" pts.append(f"{cmd}{px:.1f},{py:.1f}") pts.append("Z") return " ".join(pts) def _render_archify_architecture_scene(slide: dict[str, Any], s_idx: int) -> str: """Multi-tier system architecture SVG diagram + Anime.js live route tracing (Archify style).""" sid = f"s{s_idx + 1}" bullets = slide.get("bullets") or [ "Client / Document | 사용자 입력 및 보안 문서", "Auth / Policy | 접근 제어 및 검증 게이트", "AI Orchestrator | 멀티 모델 라우팅 허브", "Compute Engine | 고속 추론 및 모션 합성", "Output Store | 1080p 결과물 및 아카이브", ] padded = list(bullets) + [ "Input Layer | 데이터 수집", "Policy Gate | 보안 검증", "Core Router | 중앙 오케스트레이터", "Render Engine | 고속 연산", "Storage & CDN | 최종 배포", ] nodes = [_split_card_item(padded[i], i) for i in range(5)] return f"""
{_esc(slide.get("badge", "SYSTEM ARCHITECTURE"))}

{_esc(slide.get("title", "시스템 아키텍처 구조"))}

TIER 01 · INGEST & EDGE TIER 02 · CORE ORCHESTRATOR TIER 03 · ENGINE & DELIVERY {_esc(nodes[0][0][:18])} {_esc(nodes[0][1][:32])} {_esc(nodes[1][0][:18])} {_esc(nodes[1][1][:32])} CENTRAL HUB {_esc(nodes[2][0][:18])} {_esc(nodes[2][1][:32])} {_esc(nodes[3][0][:18])} {_esc(nodes[3][1][:32])} {_esc(nodes[4][0][:18])} {_esc(nodes[4][1][:32])}
""" def _render_anatomy_mechanic_scene(slide: dict[str, Any], s_idx: int) -> str: """Isometric mechanical cutaway figure (interlocking gears + pin-tumbler lock + live spec panel — Anatomy style).""" sid = f"s{s_idx + 1}" bullets = (slide.get("bullets") or [ "입력 토크 전달 | 드라이브 기어가 핵심 연산 주기를 일정하게 구동", "다중 핀 정렬 | 조건 핀 3개가 정확한 임계선(Shear Line)에 일치", "잠금 해제 및 출력 | 모든 검증 통과 시 무손실 파이프라인 개방", ])[:4] gear_big = _make_gear_svg_path(0, 0, 86, 68, 12) gear_small = _make_gear_svg_path(0, 0, 58, 44, 8) spec_cards = [] for i, b in enumerate(bullets): k_t, v_t = _split_card_item(b, i) spec_cards.append(f"""
0{i + 1}
{_esc(k_t)}
{_esc(v_t)}
""") return f"""
FIG {s_idx + 1:02d} · ISOMETRIC CUTAWAY MECHANISM ● ALIGNED 100%

{_esc(slide.get("title", "핵심 작동 메커니즘"))}

{"".join(spec_cards)}
""" def _render_anime_svg_chart_scene(slide: dict[str, Any], s_idx: int) -> str: """Anime.js live pen-drawn SVG spline curve chart + circular KPI ring gauges.""" sid = f"s{s_idx + 1}" bullets = (slide.get("bullets") or [ "초기 도입 | 기준선 24%", "자동화 연동 | 처리량 58%", "모션 고도화 | 몰입도 84%", "최종 달성 | 생산성 96%", ])[:4] pts_coords = [(110, 340), (350, 255), (610, 165), (870, 78)] dots_svg = [] gauges_html = [] ring_colors = ["#38bdf8", "#34d399", "#fbbf24"] for i, raw in enumerate(bullets): k_t, v_t = _split_card_item(raw, i) m_num = re.search(r"(\d+(?:\.\d+)?)", raw) pct = min(99, max(24, int(float(m_num.group(1))))) if m_num else (42 + i * 18) cx, cy = pts_coords[min(i, len(pts_coords) - 1)] dots_svg.append(f""" {_esc(k_t[:10])} """) if i < 3: dash_total = 226 dash_fill = int(round(dash_total * pct / 100.0)) col = ring_colors[i % len(ring_colors)] gauges_html.append(f"""
{pct}%
{_esc(k_t)}
{_esc(v_t)}
""") return f"""
{_esc(slide.get("badge", "LIVE METRIC TRAJECTORY"))}

{_esc(slide.get("title", "핵심 지표 성장 추이"))}

{"".join(dots_svg)}
{"".join(gauges_html)}
""" def _render_custom_viz_stage_scene(slide: dict[str, Any], s_idx: int, project_dir: Path) -> str: """Mounts bespoke SVG/HTML diagrams produced by Anatomy, Archify, or Agent Anime.js code.""" sid = f"s{s_idx + 1}" media_dir = project_dir / "assets" / "media" media_dir.mkdir(parents=True, exist_ok=True) archify_spec = (slide.get("archify_json") or "").strip() custom_html = (slide.get("custom_html") or "").strip() custom_svg = (slide.get("custom_svg") or "").strip() # 1. Optional auto-compile via bundled viz_skills/archify/bin/archify.mjs if archify_json is provided if archify_spec and not custom_html: parts = archify_spec.split(":", 1) if ":" in archify_spec and not Path(archify_spec).exists() else ["architecture", archify_spec] diag_type, json_path_s = parts[0].strip(), parts[1].strip() json_p = Path(json_path_s).expanduser() archify_bin = PIPELINE_ROOT / "viz_skills" / "archify" / "bin" / "archify.mjs" node_bin = shutil.which("node") if json_p.exists() and archify_bin.exists() and node_bin: out_html = media_dir / f"s{s_idx + 1:02d}_archify.html" try: subprocess.run( [node_bin, str(archify_bin), "render", diag_type, str(json_p.resolve()), str(out_html)], check=True, capture_output=True, timeout=15, ) custom_html = str(out_html) except Exception as exc: print(f"[Archify Info] CLI render skipped ({exc}); using built-in architecture renderer.") stage_inner = "" if custom_html: html_p = Path(custom_html).expanduser() if html_p.exists(): dst_html = media_dir / f"s{s_idx + 1:02d}_viz.html" shutil.copy2(html_p, dst_html) stage_inner = f'' elif "{custom_html}' elif custom_svg: svg_p = Path(custom_svg).expanduser() if not custom_svg.lstrip().startswith("<") else None svg_markup = svg_p.read_text(encoding="utf-8") if (svg_p and svg_p.exists()) else custom_svg stage_inner = f'
{svg_markup}
' if not stage_inner: return _render_archify_architecture_scene(slide, s_idx) return f"""
{_esc(slide.get("badge", "CUSTOM VISUALIZATION"))}

{_esc(slide.get("title", "심화 시각화 다이어그램"))}

{stage_inner}
""" def _render_changelog_vertical_scene(slide: dict[str, Any], s_idx: int) -> str: sid = f"s{s_idx + 1}" bullets = (slide.get("bullets") or ["11.03 | v2.29 | 음성 모드 배포", "11.09 | v2.30 | 지식 업무 레이아웃"])[:6] row_colors = ["#38bdf8", "#34d399", "#2dd4bf", "#fbbf24", "#a78bfa", "#fb7185"] rows_html = [] for i, raw in enumerate(bullets): parts = [x.strip() for x in raw.split("|")] if len(parts) >= 3: dt_txt, ver_txt, desc_txt = parts[0], parts[1], " · ".join(parts[2:]) elif len(parts) == 2: dt_txt, ver_txt, desc_txt = parts[0], f"STEP {i + 1}", parts[1] else: dt_txt, ver_txt, desc_txt = f"0{i + 1}", "UPDATE", parts[0] col = row_colors[i % len(row_colors)] rows_html.append(f"""
{_esc(dt_txt)}
{_esc(ver_txt)}
{_esc(desc_txt)}
""") src_html = ( f'
{_esc(slide["source_note"])}
' if slide.get("source_note") else "" ) return f"""
{_esc(slide.get("title", "핵심 변경 기록"))}
{"".join(rows_html)}
{src_html}
""" def _render_mission_staircase_scene(slide: dict[str, Any], s_idx: int) -> str: sid = f"s{s_idx + 1}" bullets = list(slide.get("bullets") or []) while len(bullets) < 5: bullets.append(f"MISSION {len(bullets) + 1} | 단계 {len(bullets) + 1} | 실전 적용") items = bullets[:5] colors = ["#34d399", "#38bdf8", "#a78bfa", "#fbbf24", "#fb7185"] list_rows = [] blocks_html = [] for i, raw in enumerate(items): parts = [x.strip() for x in raw.split("|")] if len(parts) >= 3: m_tag, m_head, m_sub = parts[0], parts[1], parts[2] elif len(parts) == 2: m_tag, m_head, m_sub = f"MISSION {i + 1}", parts[0], parts[1] else: m_tag, m_head, m_sub = f"MISSION {i + 1}", parts[0], "" c = colors[i] list_rows.append(f"""
{_esc(m_tag)} {_esc(m_head)} {_esc(m_sub)}
""") h_px = 95 + i * 68 blocks_html.append(f"""
{_esc(m_tag)}
""") return f"""
{_esc(slide.get("title", "미션 5단계 로드맵"))}
{"".join(list_rows)}
{"".join(blocks_html)}
""" def _render_swarm_network_scene(slide: dict[str, Any], s_idx: int) -> str: sid = f"s{s_idx + 1}" bullets = list(slide.get("bullets") or []) default_nodes = ["@worker-1 | 프론트엔드", "@worker-2 | 백엔드", "@worker-3 | 데이터", "@worker-4 | 문서화", "@verifier | 품질 검증"] while len(bullets) < 5: bullets.append(default_nodes[len(bullets)]) nodes = bullets[:5] # Precomputed radial coordinates around center (520, 250) inside 920x500 graph box coords = [(190, 95), (810, 95), (150, 390), (830, 385), (500, 445)] node_colors = ["#38bdf8", "#34d399", "#a78bfa", "#2dd4bf", "#fbbf24"] lines_svg = [] nodes_html = [] for i, raw in enumerate(nodes): n_name, n_role = _split_card_item(raw, i) nx, ny = coords[i] col = node_colors[i % len(node_colors)] lines_svg.append( f'' ) nodes_html.append(f"""
{_esc(n_name)}
{_esc(n_role[:14])}
""") hero_kw = slide.get("hero_word") or "/swarm" return f"""
{_esc(hero_kw)}
{_esc(slide.get("title", "프롬프트 한 줄 → AI 팀 동시 가동"))}
{_esc(slide.get("highlight_quote") or "지휘자 · 작업자 · 검증자가 공용 보드에서 병렬 협업")}
{"".join(lines_svg)}
COORDINATOR
총괄 지휘
{"".join(nodes_html)}
""" def _render_pricing_matrix_scene(slide: dict[str, Any], s_idx: int) -> str: sid = f"s{s_idx + 1}" plans_raw = [p.strip() for p in slide.get("plans", "무료 ₩0 | Pro 월 ₩29,000 | Ultra 월 ₩119,000~").split("|") if p.strip()] while len(plans_raw) < 3: plans_raw.append(f"Plan {len(plans_raw) + 1}") plans = plans_raw[:3] plan_headers = [] h_colors = ["#94a3b8", "#38bdf8", "#fbbf24"] for pi, p_txt in enumerate(plans): words = p_txt.split() p_top = " ".join(words[:-1]) if len(words) >= 2 else f"TIER {pi + 1}" p_price = words[-1] if words else p_txt plan_headers.append(f"""
{_esc(p_top)}
{_esc(p_price)}
""") bullets = (slide.get("bullets") or [ "지식 업무 · 음성 모드 | ✓ | ✓ | ✓", "고속 경량 모델 | △ | ✓ | ✓", "멀티 에이전트 /swarm | ✕ | ✓ | ✓", "최상위 추론 오케스트레이터 | ✕ | ✕ | ✓", ])[:5] def _cell_markup(val: str) -> str: v = val.strip().upper() if v in ("✓", "O", "OK", "YES", "지원", "포함"): return '✓' if v in ("✕", "X", "NO", "미지원", "-"): return '✕' if v in ("△", "일부", "제한"): return '△' return f'{_esc(val.strip())}' rows_html = [] for ri, raw in enumerate(bullets): cols = [c.strip() for c in raw.split("|")] feat = cols[0] c1 = cols[1] if len(cols) > 1 else "✓" c2 = cols[2] if len(cols) > 2 else "✓" c3 = cols[3] if len(cols) > 3 else "✓" rows_html.append(f"""
{_esc(feat)}
{_cell_markup(c1)}
{_cell_markup(c2)}
{_cell_markup(c3)}
""") src_html = f'
{_esc(slide["source_note"])}
' if slide.get("source_note") else "" return f"""
{_esc(slide.get("title", "요금제 및 지원 기능 비교"))}
기능 구분
{"".join(plan_headers)}
{"".join(rows_html)}
{src_html}
""" # --------------------------------------------------------------------------- # Existing 10 v2.0 Scene Archetype HTML Renderers # --------------------------------------------------------------------------- def _render_arc_cards_scene(slide: dict[str, Any], s_idx: int) -> str: sid = f"s{s_idx + 1}" items = (slide.get("bullets") or ["기획 모듈 | 구조화", "모션 모듈 | 렌더링", "사운드 모듈 | 효과음"])[:9] n_items = len(items) mid = (n_items - 1) / 2.0 cards_html = [] for i, item in enumerate(items): role_short, role_desc = _split_card_item(item, i) offset = i - mid rot_y = round(offset * -7.2, 2) trans_z = round(-abs(offset) * 22.0, 1) ascii_prefix = "".join(ch for ch in role_short if ch.isascii() and ch.isalnum()) badge_word = ascii_prefix[:3].upper() if len(ascii_prefix) >= 2 else role_short[:2] cards_html.append(f"""
{_esc(badge_word)}
{_esc(role_short)}
{_esc(role_desc[:16])}
ACTIVE
""") return f"""
{_esc(slide.get("badge", "AI SYNC ENGINE"))}
{_esc(slide.get("stat_prefix", "AI 모듈"))} {int(slide.get("stat_number", n_items))} {_esc(slide.get("stat_suffix", "종"))}
{"".join(cards_html)}
""" def _render_mockup_steps_scene(slide: dict[str, Any], s_idx: int) -> str: sid = f"s{s_idx + 1}" raw_items = list(slide.get("bullets") or []) while len(raw_items) < 3: raw_items.append(f"핵심 포인트 {len(raw_items) + 1} | 자동 동기화 처리") step_items = raw_items[:3] right_cards = [] left_rows = [] for i, raw in enumerate(step_items): head, desc = _split_card_item(raw, i) right_cards.append(f"""
{i + 1:02d}
{_esc(head)}
{_esc(desc)}
""") left_rows.append(f"""
S{i + 1}
{_esc(head[:16])}
{i + 1}
""") return f"""
{_esc(slide.get("badge", "Slide Sync Monitor"))}
{"".join(left_rows)}
{"".join(right_cards)}
""" def _render_book_quote_scene(slide: dict[str, Any], s_idx: int) -> str: sid = f"s{s_idx + 1}" quote = slide.get("highlight_quote") or slide.get("title", "") bullets = slide.get("bullets") or [] left_p1 = bullets[0] if len(bullets) > 0 else "반복되는 발표 자료 제작 과정을 분석해 일관된 시각 시스템으로 정의합니다." left_p2 = bullets[1] if len(bullets) > 1 else "폰트 크기, 여백, 챕터 표시줄, 효과음 타이밍이 하나의 규칙 파일로 통합됩니다." return f"""
{_esc(slide.get("badge", "CHAPTER · CORE PRINCIPLE"))}
EDITION · WORKFLOW MANUAL
{_esc(slide.get("title", ""))}

{_esc(left_p1)}

{_esc(left_p2)}

104
KEY INSIGHT · HIGHLIGHT

{_esc(quote)}

한 번 검증된 모션과 사운드 설계는 코드 템플릿으로 자산화되어 다음 교안에서도 오차 없이 재현됩니다.

105
""" def _render_notebook_flip_scene(slide: dict[str, Any], s_idx: int) -> str: sid = f"s{s_idx + 1}" bullets = list(slide.get("bullets") or []) while len(bullets) < 4: bullets.append(f"실전 점검 항목 {len(bullets) + 1} | 발표 전 자동 동기화 확인") items = bullets[:4] rings_html = "".join('' for _ in range(7)) check_rows = [] for i, raw in enumerate(items): head, desc = _split_card_item(raw, i) check_rows.append(f"""
✓
{_esc(head)}
{_esc(desc)}
""") return f"""
01 02 03
FIELD PLAYBOOK · NOTE
{_esc(slide.get("title", ""))}
핵심 가이드

{_esc(slide.get("highlight_quote") or items[0])}

ACTIONABLE CHECKLIST
{rings_html}
VERIFICATION STEPS
{"".join(check_rows)}
""" def _render_bento_grid_scene(slide: dict[str, Any], s_idx: int) -> str: sid = f"s{s_idx + 1}" bullets = list(slide.get("bullets") or []) while len(bullets) < 4: bullets.append(f"모듈 기능 {len(bullets) + 1} | 실시간 고해상도 자동 처리") b0_h, b0_d = _split_card_item(bullets[0], 0) b1_h, b1_d = _split_card_item(bullets[1], 1) b2_h, b2_d = _split_card_item(bullets[2], 2) b3_h, b3_d = _split_card_item(bullets[3], 3) return f"""
{_esc(slide.get("badge", "CORE ARCHITECTURE"))}
{_esc(slide.get("title", b0_h))}
{_esc(b0_h)} · {_esc(b0_d)}
01
{_esc(b1_h)}
{_esc(b1_d)}
02
{_esc(b2_h)}
{_esc(b2_d)}
03
{_esc(b3_h)}
{_esc(b3_d)}
""" def _render_vs_comparison_scene(slide: dict[str, Any], s_idx: int) -> str: sid = f"s{s_idx + 1}" bullets = list(slide.get("bullets") or []) while len(bullets) < 4: bullets.append(f"비교 항목 {len(bullets) + 1} | 생산성 및 품질 대폭 향상") mid = max(1, len(bullets) // 2) left_items = bullets[:mid][:3] right_items = bullets[mid:][:3] or [bullets[-1]] left_html = "".join( f'
–{_esc(it.replace("|", " · "))}
' for it in left_items ) right_html = "".join( f'
✓{_esc(it.replace("|", " · "))}
' for it in right_items ) left_tag = slide.get("flow_left_sub") if slide.get("flow_left_sub") != "PPTX · DOCX · MD · HTML" else "CASE A · 우려 및 한계" left_head = slide.get("flow_left") if slide.get("flow_left") != "원본 교안 문서" else "기존 통념 · 주의 요인" right_tag = slide.get("flow_right_sub") if slide.get("flow_right_sub") != "HTML 렌더링 + 효과음 싱크" else "CASE B · 검증된 해법" right_head = slide.get("flow_right") if slide.get("flow_right") != "1080p 모션 MP4" else "핵심 대안 · 최종 결론" return f"""
{_esc(slide.get("title", "핵심 비교 분석"))}
{_esc(left_tag)}
{_esc(left_head)}
{left_html}
VS
{_esc(right_tag)}
{_esc(right_head)}
{right_html}
""" def _render_data_bars_scene(slide: dict[str, Any], s_idx: int) -> str: sid = f"s{s_idx + 1}" bullets = (slide.get("bullets") or ["초기 기획 | 85%", "모션 자동화 | 96%", "렌더링 속도 | 92%"])[:4] parsed_rows = [] max_num = 100.0 for idx, b in enumerate(bullets): head, desc = _split_card_item(b, idx) m = re.search(r"(\d+(?:\.\d+)?)\s*(%|배|분|초|시간|건|개|종|점|x)?", f"{head} {desc}") val = float(m.group(1)) if m else float(68 + idx * 10) unit = (m.group(2) if m and m.group(2) else "%") max_num = max(max_num, val) parsed_rows.append((head, desc, val, unit)) bars_html = [] for i, (head, desc, val, unit) in enumerate(parsed_rows): pct = max(18, min(100, int(round((val / max_num) * 100)))) disp_num = int(val) if val.is_integer() else round(val, 1) bars_html.append(f"""
0{i + 1} {_esc(head)} {_esc(desc[:26])}
{disp_num}{_esc(unit)}
""") return f"""
{_esc(slide.get("title", "핵심 성과 지표"))}
{"".join(bars_html)}
""" def _render_process_timeline_scene(slide: dict[str, Any], s_idx: int) -> str: sid = f"s{s_idx + 1}" bullets = list(slide.get("bullets") or []) while len(bullets) < 4: bullets.append(f"단계 {len(bullets) + 1} | 자동 검증 및 실행") steps = bullets[:4] nodes_html = [] for i, raw in enumerate(steps): head, desc = _split_card_item(raw, i) nodes_html.append(f"""
0{i + 1}
{_esc(head)}
{_esc(desc)}
""") return f"""
{_esc(slide.get("title", "실행 로드맵"))}
{"".join(nodes_html)}
""" def _render_terminal_flow_scene(slide: dict[str, Any], s_idx: int) -> str: sid = f"s{s_idx + 1}" cmd_str = slide.get("command", "deck2video --input lecture.pptx --sfx on") f_left = slide.get("flow_left", "원본 교안 문서") f_left_sub = slide.get("flow_left_sub", "PPTX · DOCX · MD · HTML") f_right = slide.get("flow_right", "1080p 모션 MP4") f_right_sub = slide.get("flow_right_sub", "HTML 렌더링 + 효과음 싱크") return f"""
CLI 자동화 엔진
SFX · 자막 실시간 합성
Deck2Video Motion Compiler v3.0
>
{_esc(cmd_str)}
✓ 문서 구조 파싱 완료 → 16종 모션 아키타입 매핑 → 10종 UI 효과음 믹싱 → 1080p 렌더링
INPUT
{_esc(f_left)}
{_esc(f_left_sub)}
OUTPUT
{_esc(f_right)}
{_esc(f_right_sub)}
""" def _render_metric_summary_scene(slide: dict[str, Any], s_idx: int) -> str: sid = f"s{s_idx + 1}" raw_items = list(slide.get("bullets") or []) while len(raw_items) < 3: raw_items.append(f"핵심 단계 {len(raw_items) + 1} | 원스톱 파이프라인") pillars_html = [] for i, raw in enumerate(raw_items[:3]): head, desc = _split_card_item(raw, i) pillars_html.append(f"""
{i + 1:02d}
{_esc(head)}
{_esc(desc)}
""") sub_summary = slide.get("subtitle") or slide.get("title", "핵심 요약 · 3단계 자동화") return f"""
{"".join(pillars_html)}
""" def _format_kinetic_tokens(text: str) -> str: tokens = text.split() out = [] for tok in tokens: if re.search(r"\d+|['\"“”‘’]", tok): out.append(f'{_esc(tok)}') else: out.append(_esc(tok)) return " ".join(out) def _stage_slide_media(raw_media_src: str, project_dir: Path, s_idx: int) -> tuple[str, str]: """Copies external video/image into `project_dir/assets/media/` and returns `(rel_path, kind)`.""" if not raw_media_src: return "", "none" cand = Path(raw_media_src).expanduser() if not cand.is_absolute(): for base in (Path.cwd(), PIPELINE_ROOT, PIPELINE_ROOT.parent): if (base / cand).exists(): cand = (base / cand).resolve() break if not cand.exists(): return "", "none" ext = cand.suffix.lower() media_dir = project_dir / "assets" / "media" media_dir.mkdir(parents=True, exist_ok=True) dst_name = f"s{s_idx + 1:02d}_{cand.name}" dst = media_dir / dst_name if not dst.exists() or dst.stat().st_size != cand.stat().st_size: shutil.copy2(cand, dst) if ext in (".mp4", ".webm", ".mov", ".m4v"): return f"assets/media/{dst_name}", "video" if ext in (".png", ".jpg", ".jpeg", ".webp", ".gif", ".svg"): return f"assets/media/{dst_name}", "image" return "", "none" def compile_hyperframes_project(spec: dict[str, Any], project_dir: Path, offline: bool = True) -> Path: fonts_dst = project_dir / "assets" / "fonts" js_dst = project_dir / "assets" / "js" fonts_dst.mkdir(parents=True, exist_ok=True) js_dst.mkdir(parents=True, exist_ok=True) font_src, gsap_src = _ensure_static_vendor_assets(offline=offline) if font_src.exists(): shutil.copy2(font_src, fonts_dst / "PretendardVariable.woff2") if gsap_src.exists(): shutil.copy2(gsap_src, js_dst / "gsap.min.js") player_src = PIPELINE_ROOT / "assets" / "js" / "standalone_player.js" if player_src.exists(): shutil.copy2(player_src, js_dst / "standalone_player.js") anime_src = PIPELINE_ROOT / "assets" / "js" / "anime.min.js" if anime_src.exists(): shutil.copy2(anime_src, js_dst / "anime.min.js") requested_bg = (spec.get("bg_preset") or "horizon_wave").lower().strip() all_text = " ".join(s.get("title", "") + " " + " ".join(s.get("bullets", [])) for s in spec.get("slides", [])) dark_cycle_keys = [ "wireframe_globe", "isometric_hud_grid", "horizon_wave", "neural_constellation", "aurora_mesh", "blueprint_grid", "vercel_spotlight", "warm_editorial", ] if requested_bg == "auto": base_bg_key = auto_select_background(spec.get("title", ""), all_text) elif requested_bg == "cycle": base_bg_key = "isometric_hud_grid" else: base_bg_key = requested_bg if requested_bg in BACKGROUND_PRESETS else "horizon_wave" theme = BACKGROUND_PRESETS[base_bg_key] caption_style = (spec.get("caption_style") or "glass_dual").lower().strip() hud_style = (spec.get("hud_style") or "chapter_tabs").lower().strip() brand_label = spec.get("brand_label") or spec.get("title", "TECH BRIEFING · DEEP DIVE") total_dur = spec["total_duration"] chapters = spec.get("chapters", []) # 1. Top HUD Layer (`chapter_tabs` vs `tech_briefing` vs `docu_watermark` vs `minimal`) if hud_style == "tech_briefing": hud_markup = f"""
{_esc(brand_label)} |
""" elif hud_style == "docu_watermark": if "|" in brand_label: wm_top, wm_bot = [x.strip() for x in brand_label.split("|", 1)] else: words = brand_label.strip().split() if len(words) >= 2: wm_top, wm_bot = " ".join(words[:-1]), words[-1] else: wm_top, wm_bot = "DOCUMENTARY", brand_label.strip()[:12] hud_markup = f"""
{_esc(wm_top)} {_esc(wm_bot)}
""" elif hud_style == "deepfact_hud": df_brand = brand_label.split("|")[0].strip() if brand_label else "딥팩트랩" if len(df_brand) > 16: df_brand = df_brand[:14] first_ctx = "" if spec.get("slides"): s0 = spec["slides"][0] first_ctx = ( s0.get("badge") if s0.get("badge") and not s0.get("badge", "").startswith("SECTION") else (s0.get("source_note") or s0.get("subtitle") or "팩트 검증 · 설명용 자료") ) hud_markup = f"""
{_esc(first_ctx[:34])}
""" elif hud_style == "minimal": hud_markup = "" else: chapter_tabs_html = [ f"""
{_esc(ch['num'])} {_esc(ch['label'])}
""" for c_idx, ch in enumerate(chapters) ] hud_markup = f'
{"".join(chapter_tabs_html)}
' # 2. Scene Clips (Track 0) + Sibling Embedded Video Overlays (Track 5) scenes_html = [] video_overlays_html = [] slide_bg_keys = [] scramble_targets: list[dict[str, Any]] = [] for s_idx, slide in enumerate(spec["slides"]): arch = slide["archetype"] if slide.get("bg_preset") and slide["bg_preset"] in BACKGROUND_PRESETS: s_bg = slide["bg_preset"] elif arch == "hero_3d_briefing" and requested_bg in ("auto", "isometric_hud_grid"): s_bg = "wireframe_globe" elif requested_bg == "cycle": s_bg = dark_cycle_keys[s_idx % len(dark_cycle_keys)] else: s_bg = base_bg_key slide_bg_keys.append(s_bg) rel_media, media_kind = _stage_slide_media(slide.get("media_src", ""), project_dir, s_idx) if arch == "hero_3d_briefing": inner_markup = _render_hero_3d_briefing_scene(slide, s_idx) elif arch == "media_showcase_split": inner_markup = _render_media_showcase_split_scene(slide, s_idx, rel_media, media_kind) scram_txt = slide.get("scramble_text") or slide.get("subtitle") or ( slide["bullets"][1] if len(slide.get("bullets", [])) > 1 else slide.get("title", "") ) scramble_targets.append({"id": f"s{s_idx + 1}-scramble", "text": scram_txt, "start": slide["start"] + 0.2}) if media_kind == "video" and rel_media: video_overlays_html.append(f""" """) elif arch == "cinema_broll_fullscreen": inner_markup = _render_cinema_broll_scene(slide, s_idx, rel_media, media_kind) if media_kind == "video" and rel_media: video_overlays_html.append(f""" """) elif arch == "dossier_stamp_card": inner_markup = _render_dossier_stamp_scene(slide, s_idx) elif arch == "depth_cross_section": inner_markup = _render_depth_cross_section_scene(slide, s_idx) elif arch == "sonar_factcheck_map": inner_markup = _render_sonar_factcheck_map_scene(slide, s_idx, rel_media, media_kind) elif arch == "archify_architecture": inner_markup = _render_archify_architecture_scene(slide, s_idx) elif arch == "anatomy_mechanic": inner_markup = _render_anatomy_mechanic_scene(slide, s_idx) elif arch == "anime_svg_chart": inner_markup = _render_anime_svg_chart_scene(slide, s_idx) elif arch == "custom_viz_stage": inner_markup = _render_custom_viz_stage_scene(slide, s_idx, project_dir) elif arch == "changelog_vertical": inner_markup = _render_changelog_vertical_scene(slide, s_idx) elif arch == "mission_staircase": inner_markup = _render_mission_staircase_scene(slide, s_idx) elif arch == "swarm_network": inner_markup = _render_swarm_network_scene(slide, s_idx) elif arch == "pricing_matrix": inner_markup = _render_pricing_matrix_scene(slide, s_idx) elif arch == "arc_cards": inner_markup = _render_arc_cards_scene(slide, s_idx) elif arch == "mockup_steps": inner_markup = _render_mockup_steps_scene(slide, s_idx) elif arch == "book_quote": inner_markup = _render_book_quote_scene(slide, s_idx) elif arch == "notebook_flip": inner_markup = _render_notebook_flip_scene(slide, s_idx) elif arch == "bento_grid": inner_markup = _render_bento_grid_scene(slide, s_idx) elif arch == "vs_comparison": inner_markup = _render_vs_comparison_scene(slide, s_idx) elif arch == "data_bars": inner_markup = _render_data_bars_scene(slide, s_idx) elif arch == "process_timeline": inner_markup = _render_process_timeline_scene(slide, s_idx) elif arch == "terminal_flow": inner_markup = _render_terminal_flow_scene(slide, s_idx) else: inner_markup = _render_metric_summary_scene(slide, s_idx) scenes_html.append(f"""
{inner_markup}
""") # 3. Subtitle Clips (Track 1) & Voiceover Audio (Track 2) captions_html = [] vo_audio_html = [] karaoke_meta: list[dict[str, Any]] = [] hide_subtitles = (caption_style == "none") or bool(spec.get("disable_subtitles")) for s_idx, slide in enumerate(spec["slides"]): ch_num = f"{slide['chapter_index'] + 1:02d}" for b_idx, beat in enumerate(slide["beats"]): cid = f"cap-s{s_idx + 1}-b{b_idx + 1}" has_next = b_idx + 1 < len(slide["beats"]) next_start = slide["beats"][b_idx + 1]["start"] if has_next else slide["end"] next_is_cont = bool(slide["beats"][b_idx + 1].get("is_continuation")) if has_next else False # Zero blink gap when transitioning mid-sentence into a continuation subtitle cue! gap_trim = 0.0 if next_is_cont else 0.02 cap_dur = round(max(0.25, next_start - beat["start"] - gap_trim), 3) b_lang = beat.get("lang") or spec.get("lang_code") or "ko" sub_en_markup = f'
{_esc_balanced_sub(beat["sub_en"], "en")}
' if beat.get("sub_en") else "" if not hide_subtitles: balanced_ko = balance_subtitle_lines(beat["sub_ko"], lang=b_lang) esc_balanced_ko = "
".join(_esc(ln_p) for ln_p in balanced_ko.split("\n")) if caption_style == "pill_karaoke": word_spans: list[str] = [] word_ids: list[str] = [] weights: list[int] = [] w_counter = 0 lines_ko = balanced_ko.split("\n") for l_idx, ln_str in enumerate(lines_ko): if l_idx > 0: word_spans.append('') for w_txt in ln_str.split(): if not w_txt: continue wid = f"{cid}-w-{w_counter}" word_spans.append(f'{_esc(w_txt)}') word_ids.append(wid) weights.append(max(1, len(w_txt))) w_counter += 1 karaoke_meta.append({ "boxId": f"{cid}-box", "start": beat["start"], "duration": beat["duration"], "wordIds": word_ids, "weights": weights, }) box_inner = f'
{"".join(word_spans)}
{sub_en_markup}' box_cls = "caption-box style-karaoke" elif caption_style == "briefing_clean": box_inner = f'
{esc_balanced_ko}
{sub_en_markup}' box_cls = "caption-box style-briefing" elif caption_style == "cinema_minimal": box_inner = f'
{esc_balanced_ko}
{sub_en_markup}' box_cls = "caption-box style-cinema" elif caption_style == "docu_yellow_bar": box_inner = f'
{esc_balanced_ko}
{sub_en_markup}' box_cls = "caption-box style-yellow-bar" elif caption_style == "neon_bar_left": box_inner = f"""
CHAPTER {ch_num} · {_esc(slide.get("title", "")[:18])}
{esc_balanced_ko}
{sub_en_markup}""" box_cls = "caption-box style-neon-bar" elif caption_style == "kinetic_pop": kin_lines = "
".join(_format_kinetic_tokens(ln_p) for ln_p in balanced_ko.split("\n")) box_inner = f'
{kin_lines}
{sub_en_markup}' box_cls = "caption-box style-kinetic" else: box_inner = f'
{esc_balanced_ko}
{sub_en_markup}' box_cls = "caption-box style-glass" captions_html.append(f"""
{box_inner}
""") if beat.get("src"): aud_dur = beat.get("audio_duration") or beat["duration"] vo_audio_html.append(f""" """) sfx_audio_html = [ f""" """ for ev in spec.get("sfx_events", []) ] bgm_html = "" if spec.get("bgm"): bgm = spec["bgm"] bgm_html = f""" """ choreo_payload = { "totalDuration": total_dur, "chaptersCount": len(chapters) if hud_style == "chapter_tabs" else 0, "hudStyle": hud_style, "captionStyle": caption_style, "themeAccent": theme["accent"], "themeAccentStrong": theme["accent_strong"], "themeCardActive": theme["card_active"], "karaoke": karaoke_meta, "scrambles": scramble_targets, "slides": [ { "index": i, "chapterIndex": s["chapter_index"], "archetype": s["archetype"], "bgPreset": slide_bg_keys[i], "start": s["start"], "duration": s["duration"], "end": s["end"], "statNumber": int(s.get("stat_number", 9)), "bulletsCount": len(s.get("bullets", [])), "contextBadge": ( s.get("badge") if s.get("badge") and not s.get("badge", "").startswith("SECTION") else (s.get("source_note") or s.get("subtitle") or s.get("title", "")[:26]) )[:34], "beats": [ { "start": b["start"], "duration": b["duration"], "end": b["end"], "isContinuation": bool(b.get("is_continuation")), } for b in s["beats"] ], } for i, s in enumerate(spec["slides"]) ], } choreo_json = json.dumps(choreo_payload, ensure_ascii=False) is_light = theme["is_light"] border_subtle = "rgba(15, 23, 42, 0.14)" if is_light else "rgba(148, 163, 184, 0.22)" cinema_bg = "rgba(15, 23, 42, 0.88)" if is_light else "rgba(4, 6, 12, 0.84)" scene_pad_bottom = "96px" if hide_subtitles else "176px" showcase_vid_top = "292px" if hide_subtitles else "252px" html_lang = _esc(spec.get("lang_code") or "ko") word_break_rule = "keep-all" if html_lang in ("ko", "zh", "ja") else "normal" html_doc = f""" {_esc(spec.get("title", "AI SYNC Presentation v4.4"))}
{hud_markup} {"".join(scenes_html)} {"".join(video_overlays_html)} {"".join(captions_html)} {"".join(vo_audio_html)} {"".join(sfx_audio_html)} {bgm_html}
""" index_path = project_dir / "index.html" index_path.write_text(html_doc, encoding="utf-8") return index_path