explainer-studio 0.1.5__py3-none-any.whl

studio/cli.py

@@ -0,0 +1,265 @@
+"""studio: script -> narration -> HyperFrames scenes -> mastered MP4 + captions + chapters.
+
+    uv run studio new <slug> "Title"      scaffold episodes/<slug>/ with a starter script
+    uv run studio status <slug>           scenes, word counts, estimated vs actual length
+    uv run studio sync <slug>             narrate (cached), align, stub scenes, write index.html
+    uv run studio preview <slug>          open HyperFrames Studio on the episode
+    uv run studio check <slug>            HyperFrames lint + layout/contrast audits
+    uv run studio render <slug> [--draft] render changed scenes, assemble, master -> out/
+    uv run studio thumbnail <slug>        screenshot thumbnail/thumbnail.html -> out/
+    uv run studio voices <slug>           audition Kokoro blends or Chatterbox clips on one scene -> out/voice-samples/
+    uv run studio music <slug> --prompt   generate an instrumental music bed (ElevenLabs Music) sized to the episode
+"""
+
+from __future__ import annotations
+
+import argparse
+import html
+import json
+import re
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+
+import numpy as np
+import soundfile as sf
+
+from . import build as builder
+from . import music, voice
+from . import render as renderer
+from .common import EPISODES, OUT, ROOT, TEMPLATES, die, episode_dir, hf, info, require_tools
+from .script import Script, parse
+
+AUDITION = [
+    "bf_emma*0.6 + bf_isabella*0.4",
+    "bf_emma*0.7 + bf_alice*0.3",
+    "bf_emma*0.5 + bf_isabella*0.3 + bf_lily*0.2",
+    "bf_isabella*0.6 + bf_emma*0.4",
+    "bf_emma",
+    "bm_george",
+]
+
+
+def cmd_new(a):
+    slug = a.slug
+    if not slug.replace("-", "").isalnum() or slug != slug.lower():
+        die("slug must be lowercase letters, digits and hyphens, e.g. paris-commune")
+    ep = EPISODES / slug
+    if ep.exists():
+        die(f"{ep} already exists")
+    (ep / "scenes").mkdir(parents=True)
+    (ep / "audio" / "recorded").mkdir(parents=True)
+    (ep / "assets" / "media").mkdir(parents=True)
+    title = a.title or slug.replace("-", " ").title()
+    (ep / "script.md").write_text((TEMPLATES / "script.md").read_text().replace("__TITLE__", title))
+    builder.ensure_project_files(ep)
+    builder.sync_brand(ep)
+    info(f"created episodes/{slug}/  - write the script in episodes/{slug}/script.md, then: studio sync {slug}")
+
+
+def cmd_status(a):
+    ep = episode_dir(a.slug)
+    script = parse(ep / "script.md")
+    timing = json.loads((ep / "timing.json").read_text()) if (ep / "timing.json").exists() else None
+    actual = {s["id"]: s for s in timing["scenes"]} if timing else {}
+    total_words = 0
+    info(f"{script.meta.get('title', a.slug)}   voice={script.setting('tts')}:{script.setting('voice')}\n")
+    info(f"  {'scene':<18}{'template':<10}{'words':>6}{'est s':>8}{'actual s':>10}  cues")
+    for sc in script.scenes:
+        n = len(sc.words)
+        total_words += n
+        est = n / 2.5 + 1.5 if n else sc.min_duration
+        act = actual.get(sc.id, {}).get("duration")
+        file_flag = "" if (ep / "scenes" / f"{sc.id}.html").exists() else "  (no scene file yet)"
+        info(f"  {sc.id:<18}{sc.template:<10}{n:>6}{est:>8.1f}{(f'{act:.1f}' if act else '-'):>10}  "
+             f"{', '.join(sc.cues) or '-'}{file_flag}")
+    est_total = total_words / 2.5 + 1.5 * len(script.scenes)
+    info(f"\n  {total_words} words, estimated {est_total / 60:.1f} min"
+         + (f", actual {timing['duration'] / 60:.1f} min ({timing['duration']:.1f}s)" if timing else ", not yet synced"))
+
+
+def _sync(slug: str, only: set[str] | None = None):
+    ep = episode_dir(slug)
+    script = parse(ep / "script.md")
+    info(f"narration ({script.setting('tts')}:{script.setting('voice')})")
+    vo = voice.voice_all(ep, script, only)
+    info("building project")
+    timing = builder.build(ep, script, vo)
+    info(f"  {len(timing['scenes'])} scenes, {timing['duration']:.1f}s ({timing['duration'] / 60:.1f} min)")
+    return ep, script, timing
+
+
+def cmd_sync(a):
+    _sync(a.slug, set(a.scene) if a.scene else None)
+
+
+def cmd_preview(a):
+    ep, _, _ = _sync(a.slug)
+    subprocess.run(hf("preview", *a.args), cwd=ep)
+
+
+def cmd_check(a):
+    ep, _, _ = _sync(a.slug)
+    proc = subprocess.run(hf("check", *a.args), cwd=ep)
+    raise SystemExit(proc.returncode)
+
+
+def cmd_render(a):
+    require_tools()
+    ep, script, timing = _sync(a.slug)
+    info("rendering")
+    renderer.render_episode(ep, script, timing, a.draft, set(a.force) if a.force else None, a.force is not None)
+
+
+def cmd_thumbnail(a):
+    ep = episode_dir(a.slug)
+    script = parse(ep / "script.md")
+    builder.sync_brand(ep)
+    page = ep / "thumbnail" / "thumbnail.html"
+    if not page.exists():
+        page.parent.mkdir(exist_ok=True)
+        title = html.escape(str(script.meta.get("title", a.slug)))
+        page.write_text((TEMPLATES / "thumbnail.html").read_text()
+                        .replace("__HEADLINE__", title).replace("__TAG__", "Explainer"))
+        info(f"created {page.relative_to(ROOT)} - edit it, then run this again")
+    browser = shutil.which("chromium") or shutil.which("google-chrome") or shutil.which("chrome")
+    if not browser:
+        die("chromium not found")
+    OUT.mkdir(exist_ok=True)
+    with tempfile.TemporaryDirectory() as tmp:
+        png = Path(tmp) / "t.png"
+        subprocess.run([browser, "--headless=new", "--disable-gpu", "--hide-scrollbars",
+                        "--force-device-scale-factor=1", "--window-size=1280,720",
+                        "--virtual-time-budget=3000", f"--screenshot={png}", page.as_uri()],
+                       capture_output=True, timeout=120)
+        if not png.exists():
+            die("thumbnail screenshot failed")
+        dst = OUT / f"{a.slug}-thumbnail.jpg"
+        subprocess.run(["ffmpeg", "-v", "error", "-y", "-i", str(png), "-q:v", "2", str(dst)], check=True)
+    info(f"out/{dst.name}")
+
+
+def cmd_voices(a):
+    """Synthesise one scene with each candidate voice (current settings otherwise), loudness-matched."""
+    ep = episode_dir(a.slug)
+    script = parse(ep / "script.md")
+    scene = next((sc for sc in script.scenes if sc.id == a.scene), None) if a.scene else \
+        next((sc for sc in script.scenes if sc.chunks), None)
+    if not scene or not scene.chunks:
+        die(f"no narrated scene '{a.scene}' in {a.slug}")
+    table = voice.load_pronunciations(script)
+    dst = OUT / "voice-samples"
+    dst.mkdir(parents=True, exist_ok=True)
+    if voice.engine_class(script) is voice.Chatterbox:
+        if a.speed:
+            info("  warning: --speed is ignored by Chatterbox (pacing comes from the reference clip)")
+        # One worker for every clip: the model loads once and only the conditioning changes.
+        # --voices paths are tried against the current directory first, then the studio root.
+        specs = [str(Path(v).resolve()) if Path(v).exists() else v for v in a.voices or []] or \
+            [str(p.relative_to(ROOT)) for p in sorted((ROOT / "brand" / "voices").glob("*.wav"))] + ["default"]
+        tts = voice.Chatterbox(Script({**script.meta, "voice": "default"}, script.scenes))
+        for n, spec in enumerate(specs, 1):
+            ref = voice.chatterbox_ref(Script({**script.meta, "voice": spec}, script.scenes))
+            tts.ref = str(ref) if ref else None
+            audition(tts, scene, table, dst / f"{n}-{ref.stem if ref else 'default'}.wav")
+        return
+    for n, spec in enumerate(a.voices or AUDITION, 1):
+        meta = {**script.meta, "tts": "kokoro", "voice": spec, **({"speed": a.speed} if a.speed else {})}
+        tts = voice.Kokoro(Script(meta, script.scenes))
+        name = re.sub(r"[^a-z0-9]+", "-", voice.voice_spec(spec).lower()).strip("-")
+        audition(tts, scene, table, dst / f"{n}-{name}.wav")
+
+
+def cmd_music(a):
+    """Generate a music bed with ElevenLabs Music, sized to the synced episode, and print the `music:` line."""
+    ep = episode_dir(a.slug)
+    script = parse(ep / "script.md")
+    prompt = a.prompt or script.setting("music_prompt")
+    if not prompt:
+        die("give --prompt, or set music_prompt: in the script's front matter")
+    if not 1 <= a.variants <= 4:
+        die("--variants must be 1-4")
+    info(f"music ({a.model})")
+    out = Path(a.out).resolve() if a.out else None
+    paths = music.make_beds(ep, str(prompt), a.name, a.length, a.model, a.variants, out)
+    rel = [str(p.relative_to(ROOT)) if p.is_relative_to(ROOT) else str(p) for p in paths]
+    info(f"\n  audition, then set in script.md:  music: {rel[0]}")
+    info("  log the track in brand/music/CREDITS.md (source: ElevenLabs Music, prompt, date)")
+
+
+def audition(tts, scene, table: dict, out: Path) -> None:
+    with tempfile.TemporaryDirectory() as tmp:
+        pieces = []
+        for i, chunk in enumerate(scene.chunks):
+            wav = Path(tmp) / f"{i}.wav"
+            tts.synth_to(voice.respell(" ".join(chunk.words), table), wav)
+            pieces += [voice.read_mono(wav), np.zeros(int(chunk.gap_after * voice.SAMPLE_RATE), np.float32)]
+        raw = Path(tmp) / "all.wav"
+        sf.write(str(raw), np.concatenate(pieces), voice.SAMPLE_RATE)
+        subprocess.run(["ffmpeg", "-v", "error", "-y", "-i", str(raw), "-af", "loudnorm=I=-16:TP=-1.5",
+                        "-ar", str(voice.SAMPLE_RATE), str(out)], check=True)
+    info(f"  {out.relative_to(ROOT)}")
+
+
+def main():
+    p = argparse.ArgumentParser(prog="studio", description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    s = sub.add_parser("new", help="scaffold a new episode")
+    s.add_argument("slug")
+    s.add_argument("title", nargs="?")
+    s.set_defaults(fn=cmd_new)
+
+    s = sub.add_parser("status", help="scene table and length estimate")
+    s.add_argument("slug")
+    s.set_defaults(fn=cmd_status)
+
+    s = sub.add_parser("sync", help="narrate, align, stub scenes, write index.html")
+    s.add_argument("slug")
+    s.add_argument("--scene", nargs="*", help="only re-narrate these scenes (others reuse cached timings)")
+    s.set_defaults(fn=cmd_sync)
+
+    s = sub.add_parser("preview", help="sync, then open HyperFrames Studio")
+    s.add_argument("slug")
+    s.add_argument("args", nargs=argparse.REMAINDER, help="extra args for `hyperframes preview`")
+    s.set_defaults(fn=cmd_preview)
+
+    s = sub.add_parser("check", help="sync, then hyperframes check")
+    s.add_argument("slug")
+    s.add_argument("args", nargs=argparse.REMAINDER)
+    s.set_defaults(fn=cmd_check)
+
+    s = sub.add_parser("render", help="render changed scenes and master the episode to out/")
+    s.add_argument("slug")
+    s.add_argument("--draft", action="store_true", help="fast draft quality -> out/<slug>-draft.mp4")
+    s.add_argument("--force", nargs="*", metavar="SCENE", help="re-render these scenes (or all, if none named)")
+    s.set_defaults(fn=cmd_render)
+
+    s = sub.add_parser("thumbnail", help="render thumbnail/thumbnail.html to out/<slug>-thumbnail.jpg")
+    s.add_argument("slug")
+    s.set_defaults(fn=cmd_thumbnail)
+
+    s = sub.add_parser("voices", help="audition Kokoro blends (or Chatterbox clips, with tts: chatterbox) -> out/voice-samples/")
+    s.add_argument("slug")
+    s.add_argument("--scene", help="scene id (default: the first narrated scene)")
+    s.add_argument("--voices", nargs="+", metavar="SPEC", help="voices or blends, e.g. 'bf_emma*0.6 + bf_lily*0.4'; for Chatterbox, clip paths or 'default'")
+    s.add_argument("--speed", type=float, help="override the script's speed for these samples")
+    s.set_defaults(fn=cmd_voices)
+
+    s = sub.add_parser("music", help="generate an instrumental music bed (ElevenLabs Music) sized to the episode")
+    s.add_argument("slug")
+    s.add_argument("--prompt", help="style, instruments, mood (default: music_prompt: in the script); don't name artists or songs")
+    s.add_argument("--name", default="bed", help="file name in the episode's audio/music/ (default: bed)")
+    s.add_argument("--length", type=int, metavar="SEC", help="bed length (default: the synced episode length + 2s)")
+    s.add_argument("--model", default=music.MODEL, help=f"ElevenLabs Music model (default: {music.MODEL})")
+    s.add_argument("--variants", type=int, default=1, help="make N different takes (1-4) to audition, suffixed -a, -b…")
+    s.add_argument("--out", metavar="PATH", help="write here instead, e.g. brand/music/my-bed.mp3 to share across episodes")
+    s.set_defaults(fn=cmd_music)
+
+    a = p.parse_args()
+    a.fn(a)
+
+
+if __name__ == "__main__":
+    main()

studio/common.py

@@ -0,0 +1,160 @@
+"""Paths, settings and small helpers shared by the studio commands."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+
+def _workspace() -> Path:
+    """$STUDIO_ROOT, else the nearest directory at or above the cwd holding episodes/, else the cwd."""
+    if env := os.environ.get("STUDIO_ROOT"):
+        return Path(env).expanduser().resolve()
+    cwd = Path.cwd().resolve()
+    return next((d for d in (cwd, *cwd.parents) if (d / "episodes").is_dir()), cwd)
+
+
+# House style bundled with the package: studio/data/ in a wheel, the source tree in a checkout.
+_HERE = Path(__file__).resolve().parent
+PKG_DATA = _HERE / "data" if (_HERE / "data").is_dir() else _HERE.parents[1]
+
+# The workspace holds episodes/, out/, .env and any brand/music or brand/voices. A workspace brand/
+# or templates/ (as in a repo checkout) overrides the bundled copy.
+ROOT = _workspace()
+BRAND = ROOT / "brand" if (ROOT / "brand" / "brand.css").exists() else PKG_DATA / "brand"
+TEMPLATES = ROOT / "templates" if (ROOT / "templates" / "script.md").exists() else PKG_DATA / "templates"
+EPISODES = ROOT / "episodes"
+OUT = ROOT / "out"
+
+# Pin the HyperFrames CLI so renders are reproducible. Bump deliberately, then run `studio check`.
+HF_VERSION = os.environ.get("STUDIO_HF_VERSION", "0.8.153")
+# Chatterbox TTS runs in its own uv environment (it pins torch and numpy<2); pinned for the same reason.
+CHATTERBOX_VERSION = os.environ.get("STUDIO_CHATTERBOX_VERSION", "0.1.7")
+
+# Episode defaults; any of these can be overridden in a script's front matter.
+DEFAULTS = {
+    "tts": "kokoro",           # TTS engine: kokoro (local), chatterbox (local, cloned) or elevenlabs (cloud; key in .env)
+    # Kokoro voice or weighted blend, an ElevenLabs voice ID, or a Chatterbox reference clip (or "default")
+    "voice": "bf_emma*0.6 + bf_isabella*0.4",
+    "speed": 0.85,             # Kokoro voices differ: the default blend is ~165 wpm at 0.85, bm_george ~155 at 1.0
+    "g2p": "misaki",           # Kokoro phonemizer: misaki (what Kokoro was trained on) or espeak
+    "sentence_pause": 0.38,    # Kokoro: silence between sentences, seconds
+    "clause_pause": 0.12,      # Kokoro: silence where an over-long sentence is split at a comma
+    "voice_fx": True,          # Kokoro: gentle EQ/compression/room on the dry voice (voice.VOICE_FX)
+    "tts_model": "eleven_multilingual_v2",  # ElevenLabs model
+    "voice_settings": None,    # ElevenLabs: {stability, similarity_boost, style, use_speaker_boost}
+    "chatterbox_model": "turbo",  # Chatterbox: turbo (350M, faster) or standard (500M, honours the next two)
+    "exaggeration": 0.5,       # Chatterbox standard: emotional intensity (0.25-2)
+    "cfg_weight": 0.5,         # Chatterbox standard: lower is slower and more deliberate
+    "temperature": 0.8,        # Chatterbox: sampling temperature
+    "seed": 0,                 # Chatterbox: random seed, so a re-synthesis is repeatable
+    "format": "landscape",     # landscape (1920x1080, YouTube) or reel (1080x1920: Reels, TikTok, Shorts)
+    "burn_captions": False,    # burn word-highlighted captions into the video (on for reels; most autoplay muted)
+    "fps": 30,
+    "pad_in": 0.6,             # silence before a scene's narration starts
+    "pad_out": 0.9,            # silence after it ends (the exit fade lives here)
+    "paragraph_gap": 0.45,     # pause between paragraphs inside a scene
+    "music": None,             # path to a music bed, relative to the studio root
+    "music_prompt": None,      # default prompt for `studio music` (ElevenLabs Music)
+    "music_db": -24,          # music level under narration, before ducking
+    "music_fade_in": 2,        # seconds; 0 keeps a hit on the bed's first beat
+    "loudness": -14,           # integrated LUFS target (YouTube normalises to -14)
+    "true_peak": -1.5,
+}
+
+SAMPLE_RATE = 48000
+FORMATS = {"landscape": (1920, 1080), "reel": (1080, 1920)}
+
+
+def die(msg: str) -> None:
+    print(f"error: {msg}", file=sys.stderr)
+    sys.exit(1)
+
+
+def info(msg: str) -> None:
+    print(msg, flush=True)
+
+
+def sha(*parts) -> str:
+    h = hashlib.sha256()
+    for p in parts:
+        if isinstance(p, Path):
+            h.update(p.read_bytes())
+        elif isinstance(p, bytes):
+            h.update(p)
+        else:
+            h.update(json.dumps(p, sort_keys=True, default=str).encode())
+        h.update(b"\0")
+    return h.hexdigest()
+
+
+def tree_hash(folder: Path) -> str:
+    """Hash every file under folder by path, size and mtime (cheap; good enough for cache keys)."""
+    if not folder.exists():
+        return ""
+    entries = sorted(
+        (str(p.relative_to(folder)), p.stat().st_size, int(p.stat().st_mtime))
+        for p in folder.rglob("*")
+        if p.is_file()
+    )
+    return sha(entries)
+
+
+def run(cmd: list[str], cwd: Path | None = None, quiet: bool = False, env: dict | None = None) -> str:
+    full_env = {**os.environ, **(env or {})}
+    proc = subprocess.run(cmd, cwd=cwd, env=full_env, text=True, capture_output=True)
+    if proc.returncode != 0:
+        tail = (proc.stdout + proc.stderr).strip().splitlines()[-25:]
+        die(f"command failed ({proc.returncode}): {' '.join(cmd[:6])} ...\n" + "\n".join(tail))
+    if not quiet and proc.stderr.strip():
+        pass
+    return proc.stdout
+
+
+def hf(*args: str) -> list[str]:
+    """argv for the pinned HyperFrames CLI."""
+    return ["npx", "--yes", f"hyperframes@{HF_VERSION}", *args]
+
+
+def hf_env() -> dict:
+    # Let the CLI's own tts/transcribe find kokoro-onnx in this studio's venv.
+    return {"HYPERFRAMES_PYTHON": sys.executable}
+
+
+def load_env() -> None:
+    """Read ROOT/.env (KEY=value, optional `export`, quotes, # comments) without overriding the environment."""
+    path = ROOT / ".env"
+    if not path.exists():
+        return
+    for line in path.read_text().splitlines():
+        line = line.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        key, _, value = line.removeprefix("export ").partition("=")
+        key, value = key.strip(), value.strip()
+        if len(value) >= 2 and value[0] == value[-1] and value[0] in "'\"":
+            value = value[1:-1]
+        os.environ.setdefault(key, value)
+
+
+def ffprobe_duration(path: Path) -> float:
+    out = run(["ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "csv=p=0", str(path)])
+    return float(out.strip())
+
+
+def episode_dir(slug: str) -> Path:
+    d = EPISODES / slug
+    if not (d / "script.md").exists():
+        die(f"no episode '{slug}' (expected {d / 'script.md'})")
+    return d
+
+
+def require_tools() -> None:
+    for tool in ("ffmpeg", "ffprobe", "npx"):
+        if not shutil.which(tool):
+            die(f"'{tool}' not found on PATH")

studio/data/brand/brand.css

@@ -0,0 +1,145 @@
+/* Explainer house style, after wsws.org. Tokens mirror brand/frame.md.
+   `studio sync` copies this file (with fonts/ and gsap) into each episode's assets/brand/. */
+
+@font-face { font-family: "PT Serif"; src: url("fonts/PTSerif-Regular.ttf") format("truetype"); font-weight: 400; font-style: normal; }
+@font-face { font-family: "PT Serif"; src: url("fonts/PTSerif-Bold.ttf") format("truetype"); font-weight: 700; font-style: normal; }
+@font-face { font-family: "PT Serif"; src: url("fonts/PTSerif-Italic.ttf") format("truetype"); font-weight: 400; font-style: italic; }
+@font-face { font-family: "PT Serif"; src: url("fonts/PTSerif-BoldItalic.ttf") format("truetype"); font-weight: 700; font-style: italic; }
+@font-face { font-family: "Source Sans 3"; src: url("fonts/SourceSans3.ttf") format("truetype"); font-weight: 200 900; font-style: normal; }
+@font-face { font-family: "Source Sans 3"; src: url("fonts/SourceSans3-Italic.ttf") format("truetype"); font-weight: 200 900; font-style: italic; }
+@font-face { font-family: "JetBrains Mono"; src: url("fonts/JetBrainsMono.ttf") format("truetype"); font-weight: 100 800; }
+
+:root {
+  --paper: #ffffff;
+  --panel: #f4f4f4;
+  --ink: #231f20;
+  --ink-2: #333333;
+  --ink-soft: #555555;
+  --rule: #cccccc;
+  --red: #e71e25;
+  --red-wash: #ffdfdf;
+  --tag: #1b2129;
+
+  --font-serif: "PT Serif", Georgia, serif;
+  --font-sans: "Source Sans 3", "Helvetica Neue", Arial, sans-serif;
+  --font-mono: "JetBrains Mono", ui-monospace, monospace;
+
+  --safe-x: 192px;   /* title-safe inset (10%) */
+  --safe-y: 108px;
+  --hairline: 2px solid var(--rule);
+}
+
+/* Full-bleed white page. */
+.paper { position: absolute; inset: 0; background: var(--paper); }
+
+/* Title-safe content box. Put scene content inside one of these. */
+.stage {
+  position: absolute;
+  inset: var(--safe-y) var(--safe-x);
+  color: var(--ink-2);
+  font-family: var(--font-serif);
+}
+
+/* Reel (9:16, 1080x1920) content box. Platform UI covers the top ~200px, the right ~140px
+   (like/comment/share) and the bottom ~480px (caption, handle, audio). Burned captions sit
+   in the band y 1220-1440, so scene content ends by y 1180. */
+.stage-reel {
+  position: absolute;
+  inset: 220px 72px 740px 72px;
+  color: var(--ink-2);
+  font-family: var(--font-serif);
+}
+
+/* Heavy ink rule + uppercase label, like the site's "TOP STORIES" head.
+   <div class="section-head"><div class="section-rule"></div><div class="label">History</div></div>
+   Draw the rule on with scaleX (transform-origin is left). */
+.section-head { display: flex; flex-direction: column; gap: 18px; }
+.section-rule { height: 6px; background: var(--ink); transform-origin: left center; }
+
+.label {
+  font-family: var(--font-sans);
+  font-weight: 700;
+  font-size: 26px;
+  letter-spacing: 0.12em;
+  text-transform: uppercase;
+  color: var(--ink);
+}
+
+/* Dark category tag ("PERSPECTIVE"). */
+.tag {
+  display: inline-block;
+  align-self: flex-start;
+  background: var(--tag);
+  color: #ffffff;
+  font-family: var(--font-sans);
+  font-weight: 700;
+  font-size: 24px;
+  letter-spacing: 0.12em;
+  text-transform: uppercase;
+  padding: 10px 18px 9px;
+}
+
+.headline {
+  font-family: var(--font-serif);
+  font-weight: 700;
+  font-size: 104px;
+  line-height: 1.12;
+  color: var(--ink);
+  margin: 0;
+}
+
+.standfirst {
+  font-family: var(--font-serif);
+  font-style: italic;
+  font-weight: 400;
+  font-size: 48px;
+  line-height: 1.35;
+  color: var(--ink-soft);
+  margin: 0;
+}
+
+.body {
+  font-family: var(--font-serif);
+  font-weight: 400;
+  font-size: 46px;
+  line-height: 1.4;
+  color: var(--ink-2);
+  margin: 0;
+}
+
+/* Source / byline / date line. */
+.byline {
+  font-family: var(--font-sans);
+  font-weight: 600;
+  font-size: 28px;
+  color: var(--ink-soft);
+}
+
+/* Blockquote with red left rule. */
+.quote {
+  border-left: 6px solid var(--red);
+  padding-left: 56px;
+  font-family: var(--font-serif);
+  color: var(--ink);
+}
+
+.italic { font-style: italic; }
+.soft { color: var(--ink-soft); }
+.red { color: var(--red); }
+.sans { font-family: var(--font-sans); }
+.mono { font-family: var(--font-mono); font-weight: 500; }
+.hairline { height: 0; border-top: var(--hairline); }
+.panel { background: var(--panel); padding: 40px 48px; }
+
+/* Highlight wash: <span id="x-key" class="hl">phrase</span>
+   Sweep it in on a cue: tl.to("#x-key", { backgroundSize: "100% 82%", duration: 0.5 }, cue("key")) */
+.hl {
+  background-image: linear-gradient(var(--red-wash), var(--red-wash));
+  background-repeat: no-repeat;
+  background-position: left 70%;
+  background-size: 0% 82%;
+  padding: 0 0.06em;
+  margin: 0 -0.06em;
+  -webkit-box-decoration-break: clone;
+  box-decoration-break: clone;
+}

studio/data/brand/fonts/OFL-JetBrainsMono.txt

@@ -0,0 +1,93 @@
+Copyright 2020 The JetBrains Mono Project Authors (https://github.com/JetBrains/JetBrainsMono)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+
+This license is copied below, and is also available with a FAQ at: https://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.