⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

version unknown

ghost-editor

kurbaitaev@kurbaitaev⭐ 469 stars· last commit 16d ago· 3 open issues

AI video editor for talking-head reels. Turns a raw phone recording of someone talking to camera (retakes, pauses, false starts) into a finished vertical 1080x1920 reel for Instagram, TikTok or Shorts: the best take of each sentence, pause trimming, word-timed captions that never cover the face, motion scenes on the spoken word, sound effects mixed against the voice and checked B-roll. Use when the user hands over a talking-head video and says \"edit this\", \"make a reel\", \"make it look like

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐⭐⭐ 469 on GitHubGitHub ↗

Popular

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

Stars MIT Follow @kurbaitaev

green: in the repo today  ·  orange: coming soon  ·  purple: lab, tried on my own reels

Raw take in, reels out

Effects

I paid an editor once

Same raw recording. The human edit on the left, ghost-editor on the right.

https://github.com/user-attachments/assets/312f6910-a8a0-4424-9dd4-612cd079a2e7

Install

Paste into Claude Code:

Install the ghost-editor skill: clone https://github.com/kurbaitaev/ghost-editor into ~/.claude/skills/ghost-editor and follow its docs/INSTALL.md.

Then:

Edit ~/Downloads/my-video.mov into a reel in Clean OS.

Make my video look like this reel: ~/Downloads/reel-i-love.mp4

askyou get
edit this in Clean OSan Apple-ad talking head that lives inside your phone
make a Seoul lista voice-over list over fast B-roll and white collage pages
edit this in RESULT stylea warm podcast edit with navy cards and polaroids
edit this in stan stylea tool tutorial with your screen behind your head
make an animated explainerno camera: a narrator and a world that draws itself
cut these POV clips into a reelsmart-glasses or GoPro clips cut into a story
edit this in Face RESULTRESULT around your face: paper props, polaroids and quote cards beside you, never on you
make a kinetic doca black-and-white archive documentary with one red accent, words popping on as you say them
edit this in Whiteboarda split screen: a marker board above draws each thought live, you below
make a Step Decka numbered tips deck: giant italic numerals, word cards and prints cut between your face
edit this as a Product pagea tool review laid out like a product page: real pictures, rebuilt UI, hairline drawings
edit this in Tactile paperyour talk on printed paper that moves like stop-motion, with real page folds
edit this in Caption Newsbig chunked captions, the keyword on a yellow block, source tags
make a News Packageyou as the anchor of a TV news segment
edit this in Telestratorfreeze the frame and draw on it like a sports replay
make a Halftone Dossiera retro printed case file
edit this in Swiss Grida strict grid poster with one red
make a Data Storypencil charts of real, sourced numbers
edit this in Hologram HUDa wireframe scan with target boxes
edit mine like this reelit studies a reel you love and edits yours the same way

Plus seven one-word presets: clean, editorial, meme, cinematic, launch, kinetic, pop.

  • Claude Code on a paid Claude plan. ghost-editor itself is free.
  • A Mac with Apple silicon. Linux and Intel Macs are untested.
  • About 4 GB of disk; the install sets up ffmpeg, Node, Python, Whisper and OpenCV.
  • A free Gemini API key for the B-roll check (the frames it checks go to Google). Without it, that check is skipped.
  • An ElevenLabs key, only for the explainer's narrator.

A 60-second reel takes about 15 to 25 minutes of machine time on an M3 MacBook Air.

Languages? Tested in English and Russian. The demos are in Russian because I post in Russian.

Can it make a style that isn't here? Yes. Describe it or show it a reel and it writes the recipe. That's how the named styles were made.

Sounds and music? Mixkit's free library, downloaded during the install, plus a pack of CC0 meme sounds that ships in the repo.

More: how it works · every building block · licences


// HOW IT'S BUILT

// FILES

362 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • SKILL.md45 KBfa9c7a61ccbdtruncatedupstream ↗

    Showing the inlined prefix. The rest is in the upstream file.

    ---
    name: ghost-editor
    description: "AI video editor for talking-head reels. Turns a raw phone recording of someone talking to camera (retakes, pauses, false starts) into a finished vertical 1080x1920 reel for Instagram, TikTok or Shorts: the best take of each sentence, pause trimming, word-timed captions that never cover the face, motion scenes on the spoken word, sound effects mixed against the voice and checked B-roll. Use when the user hands over a talking-head video and says \"edit this\", \"make a reel\", \"make it look like this video\", \"add captions/sound effects\", \"pick the best takes\", \"remove the pauses\", asks for a re-cut, or names a style. Named styles (recipes/, docs/PLAYBOOK.md): Clean OS, Seoul list, RESULT, Face RESULT, stan style, vector explainer, POV montage, Whiteboard, Kinetic doc, Step Deck, Product page, Tactile paper, Caption News, News Package, Telestrator, Halftone Dossier, Swiss Grid, Data Story, Hologram HUD; plus seven presets (clean, editorial, meme, cinematic, launch, kinetic, pop). Not for landscape screen recordings."
    ---
    
    # ghost-editor
    
    One recording in, one reel out. The creative work is choosing takes and
    planning beats. The scripts do everything else the same way every time: cut
    math, zoom tweens, captions, SFX levels, asset copying, QA. Nothing on
    screen says anything the speaker did not say. A meme is a reaction, so it
    lands ON or just AFTER the punchline, never before it.
    
    Skill dir: `~/.claude/skills/ghost-editor` (below: `$S`). A reel project is any
    directory (`$P`); `build.mjs` copies what it needs into `$P/assets` so the
    project renders on its own.
    
    ## Cost: one fresh helper per reel, the right model per step
    Measured on a batch of 21 reels: looking at frames was ~5 % of the Claude usage. The cost is context re-read on every
    turn (one helper that built 3 reels in a row re-read 212 M cached tokens over 464 turns) and new generator code written
    per reel (two helpers per style each wrote their own lib). Numbers: docs/PLAYBOOK.md "Cost".
    - **One reel = one FRESH helper** (Agent tool). Never one helper for several reels or a wave. The session that talks to
      the user orchestrates: fill `templates/briefs/build-one-reel.txt` (build -> preview -> stop), send them the preview,
      and on their OK fill `templates/briefs/finish-one-reel.txt` for a new helper. Changes after their notes go to a fresh
      helper with the reel's `reel.py` and their words (the generator is the state, not the old transcript); SendMessage the
      old helper only for a one-line fix. Spawn helpers as `reel-helper` when the session lists it
      (`templates/agents/reel-helper.md`, copied to ~/.claude/agents/; shell and file tools only): a general-purpose helper
      starts at ~85 k tokens of tool and skill lists and re-reads them on every call. Long jobs run in one blocking call,
      never a background job polled per turn.
    - **Model per step:** Opus (the default) plans and judges: takes, hook, beats, components, `reel.py`, snapshots, the
      user's notes. Sonnet (Agent tool `model: "sonnet"`) runs fixed recipes: preview / final renders, `finals.py` qa /
      deliver, `components.py record`, file moves and commits. It stops on a hard QA fail and reports; the fix goes back to
      Opus. Many frames are Gemini Flash's job (broll_vision / broll_qa), not Claude's.
    - **Little code per reel:** a named style's reel is a short generator on its recipe's builder (`clean-os/cleanos.py` +
      `kit.py`, `result-podcast/faceresult.py`, `whiteboard/board.py`, `seoul-list/seoul.py`); read `<builder> --api`, not
      old generators, and never write a per-batch lib. A part two reels needed goes into the builder's kit.
    - **Small context:** grep / `sed -n`, not cat; one overview sheet per look (`snap.py beats` -> overview.jpg), not single
      frames; never re-read what you just wrote. Measure a reel with `scripts/reel_usage.py <helper transcripts>`.
    
    ## Pipeline
    
    ```
    prep.sh        -> $P/assets/talk.mp4        1080x1920 30 fps, voice at -16 LUFS
    transcribe.py  -> $P/build/words.whisper.json + take table (all takes)
    face_track.py  -> $P/build/face.json          (captions and cards never cover the face)
    choose takes   -> $P/reel.json takes        (references/take-selection.md)
      a scripted recording with many takes: rawcut_prep.sh -> vad_pauses.py -> islands_tx.py -> facescan.py --pts -> takes.py -> plan_cut.py -> subcheck.py
      -> assemble.py --plan -> voice_smooth.py --plan -> qa_cut.py: the clean raw cut every style builds on (take-selection.md)
    plan beats     -> $P/reel.json beats/zoom   (references/reel-json.md; taste.py prompt first)
    film_look.py / transitions.py reel           optional: graded plate, transition windows (after takes are final)
    build.mjs      -> $P/index.html             + SFX table + rule and taste warnings
    approval_sheet.py -> build/approval.html    lint, a frame at every cut and beat; WAIT for the user's yes
    own_footage.py -> the user's own clips for the lines (face-checked: only them); `sheet` -> show the picked frames, WAIT for yes
    broll_fetch.py -> $P/broll/: stock originals (Pexels by link, Mixkit search) + manifest.json; when to use which: references/broll.md 3
    pictures: wikimedia_fetch.py (archival first) -> google_images.py; EN + RU, >= 1080 px, people-checked (references/broll.md 3)
    brand_kit.py pull <tool URL> --dir $P/brand -> a reel about a named tool/app/company: its real logo (light + dark), icon, brand colour, nearest Cyrillic Google font, people-checked product shots; LOOK at brand/sheet.jpg
    image_pick.py brief/pull/score/pick/sheet -> per line 6-10 candidates scored 0-5 (says the line at a glance >= 4 or FLAG); the scores sheet goes next to the preview
    insert_prep.py -> every B-roll insert: people + line check, cut, SDR, fps conform, graded onto the speaker's plate as shot (never the reverse)
    components.py plan/check -> new components per reel for a named style (catalog.json); record after the user's yes
    broll_vision.py picks -> build/broll-picks.jpg: every B-roll shot + stock image, its line, the people check; WAIT for the user's yes
    finals.py preview -> "<name> (preview).mp4": 720x1280 at ~4.5 Mbit/s for the user's phone (+ a frame-0 still); WAIT for their OK
    finals.py render  -> "<name>.mp4": delivery master -> Instagram H.264 (refuses a reel with no current preview)
    finals.py qa      -> render_report.py + broll_qa.py per reel, one summary line each; fix and re-render, at most 3 rounds
    qa.py             -> SFX-vs-voice on a stem, A/V lengths, contact sheet
    finals.py deliver -> optional: -14 LUFS into the user's library of finished videos (CONTENT): NOT POSTED, _moves.tsv,
                         TRACKER; taste.py log-reel; save_style.py if the user loved it
    ```
    
    ### 0. Check the toolchain once per session
    `bash $S/scripts/doctor.sh`: tools, GEMINI_API_KEY and the media library,
    each with its fix. The Gemini key is needed for the B-roll checks (the free tier is enough), and doctor proves it with
    one test call: insert_prep.py, broll_vision.py and broll_qa.py's people / match checks ask Gemini, and with people rules
    set a shot nobody could check fails the QA. On a fresh machine run `python3 $S/scripts/library_restore.py`
    first (SFX, memes, music and the animated emoji aren't in git). Say what is missing; don't
    improvise around it. Lines marked `opt` are optional tools with their own `scripts/setup_<x>.sh`
    (BiRefNet matte, audio QA, film-look LUTs, caption metrics); the core works without them.
    
    ### 1. Prep and look
    ```bash
    bash $S/scripts/prep.sh <IMG_xxxx.MOV> $P
    ffmpeg -v error -i $P/assets/talk.mp4 -vf "fps=1/10,scale=216:384,tile=6x3" -frames:v 1 -update 1 $P/build/sheet.jpg
    ```
    Look at the sheet. Check that it is the right person (show the frames
    and confirm with the user when there is any doubt). Note where the face
    sits (the zoom origin, default `50% 29%`), where the chin is (the card band
    starts at y 990), and how bright the wall is.
    
    ### 2. Transcribe everything
    ```bash
    python3 $S/scripts/transcribe.py $P/assets/talk.mp4 --out $P/build/wor
  • examples/README.md1.0 KBbd987c376ea8upstream ↗
    # Worked examples
    
    Real `reel.json` files from shipped reels. Copy the closest one into a new
    project and rewrite the takes and beats against the new transcript. Every
    time is an ORIGINAL-recording second of that project's own recording, so the
    times themselves don't transfer. The structure and the choices do.
    
    | file | recording | style | what it shows |
    |---|---|---|---|
    | `genz-motion-en.reel.json` | one clean English take, wide framing | motion (recreated from a reference edit) | `autocut` takes, editorial captions with pill tags and highlight, all 5 scene kinds, music bed, push-in whooshes |
    | `coffer-reach-motion-en.reel.json` | one English take, a product walkthrough | motion | a product pitch: price cards, a comment-keyword ending, short scene runs |
    | `gallery/<style>.reel.json` | the same English take | each of the 7 presets | the minimal reel.json per preset: start a new project from the closest one |
    
    To render one yourself you need its recording. These files are for reading and
    copying, not for rendering as they are.
    
  • library/memes/README.md205 B0fa6eb896125upstream ↗
    # Your meme library
    
    Empty on purpose: memes are other people's media. Add clips you have the rights to use:
    
    ```bash
    python3 scripts/meme_add.py <id> <url-or-file> --tags ... --use ... --triggers ...
    ```
    
  • README.md6.3 KB77290bf7442dupstream ↗
    <div align="center">
    
    <h1>ghost-editor</h1>
    
    <p><b>Three minutes of you stumbling through a script in.<br>A 30-second reel that looks paid-for out.</b></p>
    
    <p>Open-source AI video editor for talking-head reels. A Claude Code skill that renders on your Mac.</p>
    
    [![Stars](https://img.shields.io/github/stars/kurbaitaev/ghost-editor?style=flat&color=black)](https://github.com/kurbaitaev/ghost-editor/stargazers)
    [![MIT](https://img.shields.io/badge/license-MIT-black?style=flat)](LICENSE)
    [![Follow @kurbaitaev](https://img.shields.io/badge/follow-%40kurbaitaev-black?logo=x&style=flat)](https://x.com/kurbaitaev)
    
    <img src="docs/media/styles-grid.gif" width="100%" alt="34 styles playing at once in vertical tiles, each with its name underneath. Green dot: in the repo today (Clean OS, Seoul list, RESULT, stan style, Explainer, POV montage, Face RESULT, Kinetic doc, Whiteboard, Step Deck, Product page, Tactile paper, Caption News, News Package, Telestrator, Halftone Dossier, Swiss Grid, Data Story, Hologram HUD). Orange: coming soon (Paper collage). Purple: lab experiments from my own reels.">
    
    <sub>green: in the repo today &nbsp;·&nbsp; orange: coming soon &nbsp;·&nbsp; purple: lab, tried on my own reels</sub>
    
    </div>
    
    ## Raw take in, reels out
    
    <img src="docs/media/raw-to-ready.gif" width="100%" alt="Left: my raw phone take at 10x speed while a counter climbs to try 14 of the last line. Right: that same last line in five finished styles: Clean OS, Seoul list, Face RESULT, Kinetic doc and Product page.">
    
    <img src="docs/media/pipeline.svg" width="100%" alt="How it works, animated: 33 spoken tries in a 2:57 raw take; the bad tries turn red and drop out; the best take of each line slides into a 0:30 reel; you approve a page with a frame at every cut; captions, scenes and sound fill in; the self-check ticks pauses, sound levels, caption size, B-roll budget and nothing on your face; then the finished reel.">
    
    <p align="center"><sub>FROM MY LAST BATCH: <b>21 reels in 3 h 40 min</b> on one Mac mini · <b>2 of its own mistakes caught</b> before delivery</sub></p>
    
    ## Effects
    
    <img src="docs/media/effects-grid.gif" width="100%" alt="18 effects close up: route maps, live counters, big word captions, photo stacks, cut-out collage, hand-drawn board, paper with highlights, growing diagrams, search and reveal, kinetic type, screen callouts, chalk writing, step numbers, engraving with a lens, live app demo, life in weeks, product drop, B-roll with captions.">
    
    ## I paid an editor once
    
    Same raw recording. The human edit on the left, ghost-editor on the right.
    
    https://github.com/user-attachments/assets/312f6910-a8a0-4424-9dd4-612cd079a2e7
    
    ## Install
    
    Paste into [Claude Code](https://claude.com/claude-code):
    
    ```text
    Install the ghost-editor skill: clone https://github.com/kurbaitaev/ghost-editor into ~/.claude/skills/ghost-editor and follow its docs/INSTALL.md.
    ```
    
    Then:
    
    > Edit ~/Downloads/my-video.mov into a reel in Clean OS.
    
    > Make my video look like this reel: ~/Downloads/reel-i-love.mp4
    
    <details>
    <summary><b>Styles you can ask for today</b></summary>
    
    | ask | you get |
    |---|---|
    | `edit this in Clean OS` | an Apple-ad talking head that lives inside your phone |
    | `make a Seoul list` | a voice-over list over fast B-roll and white collage pages |
    | `edit this in RESULT style` | a warm podcast edit with navy cards and polaroids |
    | `edit this in stan style` | a tool tutorial with your screen behind your head |
    | `make an animated explainer` | no camera: a narrator and a world that draws itself |
    | `cut these POV clips into a reel` | smart-glasses or GoPro clips cut into a story |
    | `edit this in Face RESULT` | RESULT around your face: paper props, polaroids and quote cards beside you, never on you |
    | `make a kinetic doc` | a black-and-white archive documentary with one red accent, words popping on as you say them |
    | `edit this in Whiteboard` | a split screen: a marker board above draws each thought live, you below |
    | `make a Step Deck` | a numbered tips deck: giant italic numerals, word cards and prints cut between your face |
    | `edit this as a Product page` | a tool review laid out like a product page: real pictures, rebuilt UI, hairline drawings |
    | `edit this in Tactile paper` | your talk on printed paper that moves like stop-motion, with real page folds |
    | `edit this in Caption News` | big chunked captions, the keyword on a yellow block, source tags |
    | `make a News Package` | you as the anchor of a TV news segment |
    | `edit this in Telestrator` | freeze the frame and draw on it like a sports replay |
    | `make a Halftone Dossier` | a retro printed case file |
    | `edit this in Swiss Grid` | a strict grid poster with one red |
    | `make a Data Story` | pencil charts of real, sourced numbers |
    | `edit this in Hologram HUD` | a wireframe scan with target boxes |
    | `edit mine like this reel` | it studies a reel you love and edits yours the same way |
    
    Plus seven one-word presets: `clean`, `editorial`, `meme`, `cinematic`, `launch`, `kinetic`, `pop`.
    </details>
    
    <details>
    <summary><b>What you need</b></summary>
    
    - [Claude Code](https://claude.com/claude-code) on a paid Claude plan. ghost-editor itself is free.
    - A Mac with Apple silicon. Linux and Intel Macs are untested.
    - About 4 GB of disk; the install sets up ffmpeg, Node, Python, Whisper and OpenCV.
    - A free [Gemini API key](https://aistudio.google.com/apikey) for the B-roll check (the frames it checks go to Google). Without it, that check is skipped.
    - An ElevenLabs key, only for the explainer's narrator.
    
    A 60-second reel takes about 15 to 25 minutes of machine time on an M3 MacBook Air.
    </details>
    
    <details>
    <summary><b>Questions</b></summary>
    
    **Languages?** Tested in English and Russian. The demos are in Russian because I post in Russian.
    
    **Can it make a style that isn't here?** Yes. Describe it or show it a reel and it writes the recipe. That's how the named styles were made.
    
    **Sounds and music?** Mixkit's free library, downloaded during the install, plus a pack of CC0 meme sounds that ships in the repo.
    
    More: [how it works](docs/HOW-IT-WORKS.md) · [every building block](docs/PLAYBOOK.md) · [licences](docs/THIRD_PARTY/README.md)
    </details>
    
    ---
    
    <p align="center">Code: MIT. The demo clips are me and my reels: watch, don't reuse. Reels you make are yours.<br>
    <b>Star it if it saved you an edit. Follow <a href="https://x.com/kurbaitaev">@kurbaitaev</a> for new styles.</b></p>
    
  • recipes/caption-news/README.md2.6 KB17310a4cfda4upstream ↗
    # Caption News
    
    Social-video news that reads with the sound off, on a talking head. The speaker's face as shot is the ground; huge
    captions are the lead actor, slammed in 2-3 chunks on the word onsets, one keyword per caption on a honey block that
    wipes left to right; the hook lands on frame 4; a title sting (a honey ruled page over the bottom band) becomes the
    channel bug; when the speaker names a source, a document beat on a dark desk with highlighter sweeps, the title re-set in a honey
    block and a source tag; lists become a lit grid or a ruled list on the ledger sheet. Ported from the MIT-licensed
    lemo-opuscar style "Caption News" (styles/caption-news, demo "The Bee Ledger") and adapted to a vertical talking head.
    
    Read SYSTEM.md first; house.json is the fixed look, catalog.json what each reel used.
    
    ## Calls
    
    - "Caption News"
    - "news captions", "like a news short", "sound-off news"
    
    ## What it needs
    
    The cut: assets/tight.mp4 (+ wide.mp4) as shot on one timeline, assets/voice.wav, build/words.cut.json (edit seconds).
    For a document beat, the source itself (a cover, a page, a screenshot of the real document) at a size it can be shown at
    1:1 or less. No matte (captions sit under the speaker's chin), no stock footage, no music. Fonts (Inter Tight, OFL) and SFX
    (library/sfx, licensed only) are copied by the builder.
    
    ## Build
    
    The public edition has no worked example for this recipe yet: write the reel's build.py from the usage block in
    captionnews.py's docstring (`python3 captionnews.py` prints it), SYSTEM.md (slots, planning procedure) and the catalog, then
    
    ```bash
    S=~/.claude/skills/ghost-editor; PY=~/.venvs/media/bin/python
    $PY $P/tools/build.py                       # index.html, build/beats.json, build/coverage.txt (checks every word is shown)
    bash $S/scripts/hf.sh lint $P               # 0 errors (nested-structure warnings are expected)
    bash $S/scripts/hf.sh snapshot $P --at <beat times> --no-end --describe false   # look at every beat
    $PY $S/scripts/finals.py preview $P --out $P/finals --style "Caption News" --code R01 --title "..."   # WAIT for the user's OK
    ```
    
    Builder: `captionnews.py`, class `News` (docstring lists every call): `plates()`, `cap()` (the caption card, hook=True for
    frame 4), `sting()` (title page -> bug), `doc()` (the document says it, with `source()`), `grid()` (lit grid),
    `ruled_list()`, `sfx()`, `build()`. Measuring writes build/ttf once with a Python that has fontTools + brotli (falls
    back to ~/.venvs/ghost-captions).
    
    ## Credit
    
    Adapted from lemo-opuscar by LemoLab (https://github.com/lemomo-ai/lemo-opuscar, styles/caption-news), MIT licence,
    Copyright (c) 2026 LemoLab: see CREDITS.txt and LICENSE-lemo-opuscar.txt.
    
  • recipes/clean-os/README.md8.6 KB3bac64198217upstream ↗
    # Clean OS: talking head edited like an Apple ad that lives inside your phone
    
    Call it with: **"edit this in Clean OS"** (or "Clean OS style").
    
    **Read SYSTEM.md first.** This README is the first reel's grammar; SYSTEM.md is the logic (invariants, slots, generators)
    and catalog.json records every element used. A new reel fills each slot with something NEW; copying a previous reel's
    scenes is the known failure (it reads as the same edit).
    
    The look was reverse-engineered from @yashmotions' Apple-style clean talking-head edit.
    
    **When to use:** reflective or explanatory monologues where each sentence names something the viewer can *see on a phone*
    (a date, a notification, a search, a photo, a message). Calm-to-medium energy. Not for hype or meme content.
    
    ## The grammar (keep all of it)
    
    1. **Two shot sizes from one 4K camera.** Wide = the full frame; tight = a 1.6× crop around the face (1350×2400 → 1080×1920,
       downscale only). Switch at phrase changes every 2–4 s; each shot has a slow push (1.00→1.05). The cut to wide gets a soft whoosh.
    2. **Word cards, not subtitles.** 1–3 words at a time, centred on the chest (y≈1250), lowercase, Inter. Entry: blur 14→0 px,
       scale 0.82→1, 0.22 s, power3.out. Exit: 0.12 s blur-out. Sizes: s 64/600, m 96/700, it 170 italic 700, xl 230/800,
       stack 130 (2nd line italic 300), xl-sub (hero 300/800 + thin italic sub-line 46/300). Tracking −0.03 to −0.06 em.
       A quiet pop on every card (pop-1/2/3 at 0.05–0.07).
    3. **Literal phone scenes on #FAFAFA** (speaker hidden, voice continues), 3–4 per 40 s, each illustrating exactly the sentence:
       date picker wheel, lock screen with notifications landing on the words, search bar typing + a loading bar that stalls,
       Photos "Memories" card. Enter 0.26 s rise + tech-digital-whoosh; exit 0.18 s fade. iOS blue #0A84FF, black #111.
    4. **Red Figma selection box.** rgba(239,68,68,.38) fill, 3 px #EF4444 border, white corner handles, dashed full-width guides,
       a "Text" label tag, a macOS cursor flying in from bottom-right and clicking (click-1). For words the speaker *rejects*:
       add the strike line and dim them. For words to *focus on*: select only.
    5. **One "data" moment:** perspective text over the horizon (rotateX 28°, 3 lines, last one 190 italic 800) plus a white ring
       draining 100→0 % beside the head.
    6. **One script word:** Great Vibes, 300 px, wiped in left→right with a thin italic sub-line.
    7. **Sound:** a small sound on every graphic entrance (pop, tick, click, keyboard, notification/ding, shutter, ui-confirm),
       nothing on bare cuts. Ambient bed (`vastness`) at volume 0.16. Final −14 to −16 LUFS, TP ≤ −1.
    8. **Colour:** keep the footage's own mood (dusk stays dusk); only clean it (contrast 1.05, saturation 0.92, slightly cool).
       The white phone scenes give the "Apple" contrast. Soft dark fade on the bottom 45 %.
    
    ## Pipeline
    
    ```bash
    S=~/.claude/skills/ghost-editor; R=$S/recipes/clean-os; P=~/reels/<name>
    # 1. look + transcribe the RAW (all takes); pick the best COMPLETE take per line (watch for false starts: confirm with Gemini)
    python3 $S/scripts/transcribe.py proxy.mp4 --out $P/build/words.whisper.json --lang <code> --model turbo
    python3 $S/scripts/face_track.py proxy.mp4 --out $P/build/face.json          # median eyes -> cut.json "eyes"
    # 2. denoise (outdoor noise): DeepFilterNet3 capped at 20 dB (full strength = thin, watery voice)
    .venv-df/bin/deepFilter audio/raw.wav --atten-lim 20 -o audio/df20      # venv: the first run of scripts/denoise.sh creates $S/.venv-df
    # 3. write $P/cut.json (see assemble.py docstring), then:
    python3 $R/assemble.py $P
    #    many takes of a script: plan the cut first (references/take-selection.md, "The raw cut, step by step"):
    #    python3 $S/scripts/plan_cut.py $P && python3 $R/assemble.py $P --plan $P/build/plan.json --alt
    #    The plates are never graded (the speaker's face as shot); the old default grade is gone.
    python3 $S/scripts/transcribe.py $P/assets/voice.wav --out $P/build/words.cut.json --lang <code> --model turbo
    python3 $R/fetch_fonts.py $P
    # 4. write $P/reel.py on the builder (SYSTEM.md section 4): python3 $R/cleanos.py --api lists every call; the project
    #    from an approved cut: python3 $R/cleanos.py --new $P --from <cut dir>. Everything is keyed to words: R.t("word").
    #    (example/build_one_thing.py is a hand-written build of an English example: read it for ideas, never copy it.)
    #    A Markup pen word needs its font: python3 $R/fetch_fonts.py $P "Marck Script".
    cd $P && python3 reel.py && $S/scripts/hf.sh lint && python3 $S/recipes/seoul-list/snap.py beats $P   # look at build/snaps/overview.jpg
    python3 $S/scripts/finals.py preview $P --out $P/finals --style "Clean OS" --code <C> --title "<title>"   # WAIT for the user's OK
    ```
    
    ## Checks that caught real problems
    
    - Hiding every flagged frame hides the speaker: in one audit, a reel that covered 31 off-lens windows kept the speaker on
      screen 33 % of the reel. Small glances stay (plan_cut.py / cover_windows.py now say keep or cover per window). Inserts
      are graded onto the plate with insert_prep.py and kept to <= 3 per minute. Scenes open from an icon below the chin,
      never over the speaker's mouth. Run `broll_qa.py --project $P` on every render (references/broll.md).
    
    - Raw whisper merges a false start with its restart ("And even the… And even the thing that now…"): re-transcribe the cut voice.
    - A "khm" before a word: find it with a voicing/pitch scan (a voiced hum with falling pitch), not by asking Gemini.
      Gemini's sub-second timestamps are unreliable.
    - Speakers often bow their head or close their eyes right AFTER a take's last word. Check every take's tail in close-up frames
      (a head-pose scan from face landmarks does not see an eyes-down glance), end the take at the word, and when a phone scene
      covers the cut, end the scene's fade over the NEXT shot (scene out = next segment start + 0.2 s), not over the tail.
    - Gemini's visual QA called the cut "clean" while the bow was visible; trust frames over its verdict. Its audio flags need
      checking too: a "breath" it reported was an unvoiced fricative inside a word (voicing scan: unvoiced, high zero-crossing
      between vowels).
    - Never use a bare `tl.to()` on something animated twice; use fromTo with explicit values (seek order changes the result).
    - `.strike` on non-deleting boxes: render the element only when it's used (the lint rejects CSS transform + GSAP scale).
    - Every `<video>` needs an id, including decorative blurred copies (otherwise it renders frozen).
    - 4K HEVC select-by-time assembly takes ~4 min per framing; delete assets/{wide,tight}.mp4 to force a rebuild.
    - Lip sync: assemble.py snaps every segment edge to the 30 fps grid and cuts the picture and the voice at the same snapped
      times, then checks frames == round(voice seconds x 30). Before that fix, a 23-piece cut rounded each piece of the picture
      to whole frames while the voice was cut at exact times: the picture ran 2 frames long and the voice ended 43-54 ms early.
      An older cut: `python3 $S/scripts/qa.py $P <any render> --av-only` flags it; `python3 $S/tests/test_assemble_sync.py`
      is the regression test.
    
    ## Worked example
    
    `example/build_one_thing.py` with `example/script.txt` and `example/cut.json`: an English monologue, "one thing at a time"
    (9 lines, about 32 s), built in the current house look (house.json), not the first reel's: Inter cards resolving from blur
    on the chest, the red Figma box twice rejecting ("more time", "not forever") and once focusing, QuickType suggestions
    tapped up into the card on two choice words, the Markup pen writing "feeling" in Marck Script, a green accent. Its
    components: four OS moments (a home screen whose badges count up on 32 / 11 / 3, the app switcher flicking every card away
    but one, a chest window with a timer wheel rolling to 25 and a notifications toggle switching off, a checklist with one
    item done and ten started), the scenes growing out of the Dynamic Island and shrinking back, an "attention" battery
    beside the head draining across its sentence; a small sound on every entrance and the `vastness` bed. A new reel keeps the
    house and replaces those components. It is for reading (a new reel is written on the builder, not copied from
    it) and for a test run: the recording is yours to supply. Put your file in
    cut.json `source`, re-time `segments` from your own transcript, run assemble.py, transcribe `assets/voice.wav` with
    `--lang en`, then fix any word key the build stops on (whisper writes "10" for "ten": keys accept `"ten|10"`). A dry run
    (a test-pattern 4K source with a synthetic voice and a false start, cut by assemble.py, words from whisper on the cut voice)
    builds and lints with 0 errors and 0 warnings; it has not been rendered with real footage.
    
  • recipes/data-story/README.md3.3 KBe4b81a225f28upstream ↗
    # Data Story
    
    When the speaker's line carries a quantity, a chart draws itself on cream paper: a red-blue pencil draws every mark
    (axes, bars, cells, dots), handwritten notes pin the speaker's words and the facts to the marks, the subtitle is the
    chart's figure caption (mono kicker with the figure and its source, hairline rule, serif words on their onsets). Between
    the pages the face as shot, with the caption on a paper band at the bottom and pencil notes on paper slips above the
    head. Every number on screen is true and sourced; a chart with no verified number says SCHEMATIC and shows none. Ported
    from Lemo-Opuscar's "Data Storytelling" style (styles/dataviz, MIT).
    
    Read SYSTEM.md first (thesis, invariants, house look, slots and generators, planning procedure, changelog); house.json
    is the fixed look, catalog.json what each reel used.
    
    ## Calls
    
    - "Data Story"
    - "data storytelling"
    - "chart reel", "draw the numbers"
    
    ## What it needs
    
    The approved cut: the plates as shot (any number, same timeline: alt / wide / tight), assets/voice.wav,
    build/words.cut.json (edit seconds), build/face.json per plate (`scripts/face_track.py <plate> --out ...`; the notes are
    guarded against the face core). The data: a primary or official source for every number (paper, agency page), with its
    date. A real picture only for a thing the speaker names (e.g. a book cover). No matte, no music, no stock footage.
    Fonts (Caveat, Playfair Display, JetBrains Mono) and SFX are copied from the skill by the builder.
    
    ## Build
    
    A Python builder on scripts/lib/facereel.py: `datastory.py` (class `DataStory`, pages as `Layer`; the docstring lists
    every call and sketches an English reel about caffeine with real FDA numbers), drawing with `engine.js` (the source's
    Canvas engine adapted to 1080x1920, inlined into index.html and painted from one paused GSAP timeline, so every frame is
    a pure function of t). The public edition has no worked example for this recipe yet: write `$P/tools/build.py` from
    build/plan.txt and the docstring.
    
    ```bash
    S=~/.claude/skills/ghost-editor; PY=~/.venvs/media/bin/python
    $PY $P/tools/build.py --project $P             # index.html, build/spec.json, beats.json, plan.json, sfx_events.json
    bash $S/scripts/hf.sh lint $P                   # 0 errors
    bash $S/scripts/hf.sh snapshot $P --at <beat times> --no-end --describe false -o $P/build/snap   # look at every beat
    $PY $S/scripts/finals.py preview $P --out $P/finals --style "Data Story" --code R01 --title "..."   # WAIT for the user's OK
    ```
    
    The calls: `R.talk(plate, t0, t1)` (the face world), `R.note(text, x, y, at, dur, color, align, deco)` (a pencil note
    on a slip above the head), `R.page(id, t0, t1, push)` -> Page with `title`, `sub`, `mono`, `type`, `hand`, `stroke`,
    `ring`, `leader`, `under`, `strike`, `wave`, `heart`, `dot`, `bar`, `cell`, `box`, `fill`, `hatch`, `img`, `push`, and
    the generators `plot_frame`, `bars`, `day_grid`, `print_`; `R.picture()`, `R.captions(starts, kickers)`, `R.sound()`,
    `R.beat()`, `R.build()`.
    
    ## Where things are
    
    - Source: Lemo-Opuscar, styles/dataviz (STYLE.md, DEMO.md, demo/engine.js); its film was only watched and is not
      copied here.
    
    ## Credit
    
    Adapted from Lemo-Opuscar by LemoLab, https://github.com/lemomo-ai/lemo-opuscar, styles/dataviz (MIT, (c) 2026 LemoLab;
    LICENSE-lemo-opuscar.txt). Details in CREDITS.txt.
    
  • recipes/explainer-vector/README.md4.2 KB3cd111d50324upstream ↗
    # Vector explainer: a narrated story drawn live in one continuous world
    
    Call it with: **"make an animated explainer"**, **"like the tree video"**, **"faceless explainer with a wise voice"**.
    
    First made for "Two Directions" (a tree grows down and up; life lesson), Sep 2026: the worked example in example/.
    
    **When to use:** a script or idea with no footage, especially a metaphor or a concept that can be *drawn*:
    a process, a contrast (above/below, before/after), a growth story. Parables, life lessons, science explainers.
    
    ## The grammar
    
    1. **One world, one camera.** Not a sequence of slides: a single tall SVG world (e.g. sky over soil, a horizon at mid-frame) and a
       camera (`#cam`: translate + scale, origin 0 0) that moves over it. `cam(x, y, s)` centres world point (x, y) at scale s.
       Dives, rises and zooms carry the story (underground for "into darkness", up into a light burst for "breaks through").
    2. **The subject draws itself.** Procedural SVG (seeded random, so it's repeatable): paths with `pathLength=1`, stroke-dashoffset 1→0,
       ordered by depth so growth spreads outward. Leaves grow with `attr: {r}` (not scale transforms; the renderer drops those on SVG).
    3. **Every beat keyed to a WORD** of the voiceover: `W("word", n)` returns that word's time from voice/words.json. A new voice take = one rebuild.
    4. **Headlines:** Playfair Display on soft cream panels (dark panels over dark ground), 84 px, key word in the italic. 5–7 per minute.
       One heavy moment in Montserrat 900 (e.g. "RESISTANCE / PRESSURE / DIRT") with screen shake and booms.
    5. **Captions:** editorial reveal: each word rises out of a blur (22 px → 0, 0.3 s) exactly when spoken; Geist 600 lowercase, key words
       in Playfair italic gold; no box, a dark glow; bottom edge at y 1490 (above the Reels UI). Hidden while a headline says the same words.
    6. **Labels on the drawing** (roots: "the work in the dark"; fruit: "success") pop with `back.out(2)` on their words.
    7. **A closing montage moment** (seasons cycling: snow, blossom, fruit, falling leaves) on the last line, then a held final line.
    8. **Look:** paper grain overlay (6–7 %), soft vignette, a warm grade layer after the turning point. Palette: soil #1B1410/#2A1F18,
       root gold #C9A15B, sky cream #F4EAD8, sun #F2B544, leaf greens, fruit #C0392B.
    9. **Sound:** ElevenLabs voice (a wise elder: Spuds Oxley `NOpBlnGInO9m6vDvFkFC`), piano bed (silent-descent) at 0.2 that swells
       at the turning point and the end, cinematic SFX on structural moments only (whooshes on camera moves, booms on heavy words,
       rumble riser into the breakthrough, cine hit on it). Final −15 LUFS, TP ≤ −1.
    
    ## Pipeline
    
    ```bash
    S=~/.claude/skills/ghost-editor; P=~/reels/<name>
    # 1. tighten the script (~115 words ≈ 60 s at an elder's pace); fact-check it; write "..." where the voice should breathe
    # 2. voiceover with word timings (2 takes, pick by ear)
    python3 $S/scripts/tts_elevenlabs.py $P/voice/script.txt --voice NOpBlnGInO9m6vDvFkFC --out $P/voice --takes 2
    cp $P/voice/take1.words.json $P/voice/words.json
    ffmpeg -i $P/voice/take1.mp3 -af loudnorm=I=-16:TP=-1.5 -c:a aac $P/assets/voice.m4a
    # 3. fonts (Playfair, Montserrat, Geist from $S/templates/fonts), SFX + music bed from $S/library into $P/assets
    # 4. copy example/build_two_directions.py to $P/build.py; redraw the world for the new metaphor; re-key every beat to words
    cd $P && python3 build.py && $S/scripts/hf.sh lint && $S/scripts/hf.sh snapshot --at <every beat>
    $S/scripts/hf.sh render -o renders/<name>.mp4
    ```
    
    ## Checks that caught real problems
    
    - A bare `tl.to()` on something tweened twice locks a stale start value depending on the renderer's seek order (leaves stayed
      hidden until late). Use `fromTo` with explicit values everywhere (`ft` / `tw` helpers in the example).
    - SVG `transformOrigin` on circles is unreliable in the renderer: animate `attr: {r}` instead.
    - A baseline `tl.set(..., 0)` added later in the list overrides an earlier one (orange "autumn" leaves showed from frame 0):
      register the selector in `based` when you set its baseline by hand.
    - Hero text over a dense canopy needs a panel; captions need no box over the dark soil.
    - The ElevenLabs MCP connector's grant budget can run out; the direct API key (skill .env) keeps working.
    
  • recipes/halftone-dossier/README.md3.1 KBbc9361f2228dupstream ↗
    # Halftone Dossier
    
    A talking-head reel read out as a retro print case file on its subject: cream archive paper, overprinted halftone
    dots in four flat inks, heavy black-serif headlines with a misregistered pink shadow that pop in glyph by glyph,
    rubber stamps that slam with a page shake, drawn exhibits with thick navy outlines that boil at 10 fps, a case-file
    HUD and a navy caption bar that carries every spoken word. The speaker's face, as shot, sits between the pages: on the speaker's face only
    the HUD, the caption bar under the speaker's chin, headlines behind the speaker's head (matte) and one closing stamp below the speaker's face.
    Ported from LemoLab's MIT-licensed style "Halftone Dossier" (github.com/lemomo-ai/lemo-opuscar, styles/halftone-dossier).
    
    Read SYSTEM.md first (thesis, invariants, house look, slots and generators, planning procedure, changelog);
    house.json is the fixed look, catalog.json what each reel used.
    
    ## Calls
    
    - "Halftone Dossier"
    - "case file style"
    - "dossier reel"
    
    ## What it needs
    
    The approved cut (any talking head with a subject that can be "put on file": a habit, a product, a tool, a myth): one
    plate as shot (the alt cut works: it already alternates the speaker's framings), its matte webm with alpha for the headlines
    behind the speaker's head (scripts/matte.py; only the time ranges you use need it), assets/voice.wav, build/words.cut.json (edit
    seconds). Pictures only when the speaker names a real thing (a book cover, a product): shown as a pinned print, never halftoned.
    Everything else is drawn by the builder. Fonts and SFX are copied from the skill; paper, grain, stamp ink and halftone
    layers are generated into assets/gen/.
    
    ## Build
    
    A Python builder, `dossier.py` (class `Dossier`; its docstring lists every call), reading the look from house.json.
    A reel is a short generator in the project. The public edition has no worked example for this recipe yet: write it from
    the usage block in dossier.py's docstring (`python3 dossier.py` prints it), SYSTEM.md (slots, planning procedure) and the
    catalog, then
    
    ```bash
    S=~/.claude/skills/ghost-editor; PY=~/.venvs/media/bin/python
    $PY $P/tools/build.py                          # index.html, build/beats.json, build/coverage.txt
    bash $S/scripts/hf.sh lint $P                   # 0 errors
    bash $S/scripts/hf.sh snapshot $P -o $P/build/snap --no-end --describe false --at <beat times>   # look at every beat
    $PY $S/scripts/finals.py preview $P --out $P/finals --style "Halftone Dossier" --code R01 --title "..."   # WAIT for the user's OK
    ```
    
    The calls: `face()`, `behind()`, `face_stamp()`, `card()`, then per page `ht()`, `headline()`, `text()`, `svg()`
    (boil=True for props), `numeral()`, `stamp()`, `shake()`, `flash()`, `pushin()`, `pop()`, `rise()` and the exhibit
    generators `mugshot()`, `photo_exhibit()`, `notifications()`, `board()`, `task_verdict()`, `space_grid()`; then
    `captions()`, `chips()`, `wipes()`, `sfx()`, `build()`.
    
    ## Where things are
    
    - Source: https://github.com/lemomo-ai/lemo-opuscar, styles/halftone-dossier (STYLE.md, DEMO.md, demo/).
    
    Credit: adapted from "Halftone Dossier" by LemoLab (lemo-opuscar, MIT, Copyright (c) 2026 LemoLab); see CREDITS.txt
    and LICENSE-lemo-opuscar.txt.
    
  • recipes/hologram-hud/README.md3.0 KBd7b8188e0acdupstream ↗
    # Hologram HUD
    
    A talking-head reel cut between the speaker's face as shot and full-screen HUD scenes. The thing the speaker talks about (a phone, a book,
    the habits they list) is scanned into a glowing line wireframe on a projector pad. Target boxes lock onto its parts,
    values roll in from garbage glyphs and turn amber on the frame they become true, and finished values dock as toggle chips
    in a rail that stays to the end. One interface covers both worlds: the edge chrome and the HUD subtitle sit on the speaker's face
    shots too, never on the speaker's face. Ported from Lemo-Opuscar "Sci-fi Hologram HUD" (MIT, LemoLab), see CREDITS.txt.
    
    Read SYSTEM.md first (thesis, invariants, house look, slots and generators, planning procedure, changelog).
    house.json holds the fixed look. catalog.json records what each reel used.
    
    ## Calls
    
    - "Hologram HUD"
    - "hologram reel", "HUD style", "like the e-bike spec scan"
    
    ## What it needs
    
    The approved cut: one or more plates of the same timeline (assets/wide.mp4, tight.mp4, alt.mp4), assets/voice.wav and
    build/words.cut.json (edit seconds). It needs no matte, because nothing ever sits over the speaker's face. Each HUD scene needs an
    object for the spoken noun, built as a wireframe model in engine/holohud.js (MODELS: phone, book, basics; add new ones with
    rr / piece / cylX / place). It can use at most one real printed object (a book cover), drawn on the wireframe in its own
    colour. Fonts (Exo 2 from fonts/, JetBrains Mono from templates/fonts) and SFX (library, licensed only) are copied by the
    builder. There is no music bed.
    
    ## Build
    
    The Python builder is `hologramhud.py` (class `Hud`, scenes from `Hud.scene()`; its docstring lists every call). The
    engine `engine/holohud.js` is inlined into index.html: one canvas painted from a paused GSAP timeline (seek-safe, no
    timers). The public edition has no worked example for this recipe yet: write the reel's build.py from the usage block
    in hologramhud.py's docstring (`python3 hologramhud.py` prints it), SYSTEM.md (slots, planning procedure) and the catalog,
    then
    
    ```bash
    S=~/.claude/skills/ghost-editor; PY=~/.venvs/media/bin/python
    $PY $P/tools/build.py                          # index.html, build/beats.json, build/coverage.txt
    bash $S/scripts/hf.sh lint $P                   # 0 errors (one warning: the file is long, the engine is inlined)
    bash $S/scripts/hf.sh snapshot $P --at <beat times> --no-end --describe false   # look at every beat
    $PY $S/scripts/finals.py preview $P --out $P/finals --style "Hologram HUD" --code R01 --title "..."   # WAIT for the user's OK
    ```
    
    The calls are `face()`, `scene()`, then on a scene `obj()`, `cam()`, `lock()`, `card()`, `marker()`, `title()`, `status()`,
    `beam()`, `pad_spin()`. On the reel: `chip()`, `sub()`, `glitch()`, `image()`, `sfx()`, `build()`.
    
    ## Credit
    
    Adapted from Lemo-Opuscar styles/hologram-hud (https://github.com/lemomo-ai/lemo-opuscar), MIT, Copyright (c) 2026
    LemoLab: the STYLE.md spec and the holo.js / hud.js engine code. The licence is in LICENSE-lemo-opuscar.txt. Their demo
    film and models are not copied.
    
  • recipes/kinetic-doc/README.md3.4 KBd87b19dfa42aupstream ↗
    # Kinetic doc
    
    Black-and-white archive documentary with one red accent: words pop on as spoken in one centred line (a big heavy word
    + small words), pictures arrive as prints, windows and polaroids, punch lines get their own page. One grammar for three
    kinds of video: (A) the speaker talking to camera, (B) a voice-over over designed pictures, (C) B-roll only + a voice-over.
    Not the `kinetic` reel.json preset (full-screen type on a colour).
    
    Read SYSTEM.md first (thesis, invariants, house look, slots and generators, planning procedure, changelog);
    house.json is the fixed look, catalog.json what each reel used. Founded from four reference reels (@lightyear.residency,
    @usvchq, @_otsan, @rit2raj_das), measured frame by frame.
    
    ## Build
    
    A Python builder on scripts/lib/facereel.py: `kdoc.py` (class `KineticDoc`). A reel is a short generator in the
    project that calls it (copy one of the worked examples; they are English and written for reading and copying: the
    recording is yours, so re-time every word ref against your own words.json):
    
    | format | example | needs |
    |---|---|---|
    | A talking head | `example/a_talking_head.py` (a 2-minute-rule tip, ~30 s) | assets/plate.mp4 (as shot), assets/voice.wav, build/words.json, build/face.json (`face_track.py` on the plate), build/cover_windows.json |
    | B voice-over + pictures | `example/b_voiceover.py` (attention residue, ~35 s) | assets/voice.wav, build/words.json, assets/pics/ (B&W archive-style stills, `broll_gen.py`, the prompt prefix in the example) |
    | C B-roll only | `example/c_broll.py` (walking without headphones, ~30 s) | assets/voice.wav, build/words.json, assets/clips/ (the user's own footage via `own_footage.py find` + `insert_prep.py --no-grade`), assets/pics/ (archive / AI stills) |
    
    ```bash
    S=~/.claude/skills/ghost-editor
    python3 reel.py $P                                   # writes $P/index.html, build/plan.json, beats.json, sfx_events.json
    bash $S/scripts/hf.sh lint $P                        # 0 errors
    python3 $S/recipes/seoul-list/snap.py beats $P       # look at every beat
    python3 $S/scripts/components.py check --style kinetic-doc --project $P
    python3 $S/scripts/finals.py preview $P --out <dir> --style "Kinetic doc" --code R01 --title "..."   # WAIT for the user's OK
    ```
    
    The building blocks (all keyed to word refs, `K.t("word")`, `"word#2"`, `"^word"`):
    - `K.picture(id, src, a, b, line, frame="print"|"window"|"full", label=..., push=..., his_face=..., tag=...)`
      (`his_face=True`: footage with the speaker on screen stays in colour)
    - `K.burst(id, [(src, at), ..., (src, at, end)], line)`: the one montage burst, hook only
    - `K.page(id, a, b, "grey"|"paper"|"type"|"black", [[(text, ref, "s"|"big"|"red"|"serif"[, px]), ...], ...])`
    - `K.polaroids(id, a, b, [(src, label, ref), ...], line)`; `K.label(id, a, b, text, at=, sub=, host=)`;
      `K.counter(id, a, b, to, at=, unit=, host=)`; `K.punch(at, target=None)`; `K.swap(...)`; `K.strike(...)`;
      `K.erase("word", at)`; `K.quiet(t)` (no SFX from t: the payoff); `K.mark(tag)` (a slot component's name)
    - `K.build(BIG={...}, RED={...}, SERIF={...})`: captions, sound, budgets (A: facereel's; B / C: every moment a scene),
      pace report, the components check.
    
    Looks are baked into files under assets/kd/ (B&W copies, blurred backdrops, page grounds): HyperFrames' capture can
    turn black when a page carries many CSS blurs, filters and gradients.
    
    ## Calls
    
    - "kinetic doc"
    - "black-and-white documentary"
    
  • recipes/news-package/README.md3.6 KBde89fd11ee7bupstream ↗
    # News Package
    
    The speaker's talking head as the anchor of a one-story TV news segment: a sting whose plate flies into the corner and
    becomes the channel bug, a lower-third strap on the speaker's chest (lemon category tab, paper headline, ink end block)
    that stays from the first story to the recap and flips its words, a rundown of the reel's points that opens the segment
    and comes back ticked off at the end, and between face shots full-frame package cards on ink that carry one fact each
    (a document, a split-flap board, check rows, accent-edged cards, a schematic threshold line, proportion bars), joined by
    a lemon band wipe between parts and hard cuts inside a part. Ported from the MIT-licensed lemo-opuscar style "Broadcast
    News Package" (https://github.com/lemomo-ai/lemo-opuscar, styles/news-package) and adapted from a 16:9 bulletin with no
    anchor to a 9:16 talking head.
    
    Read SYSTEM.md first (thesis, invariants, house look, slots and generators, planning procedure, changelog);
    house.json is the fixed look, catalog.json what each reel used.
    
    ## Calls
    
    - "News Package"
    - "like a TV news segment"
    - "news bulletin style"
    
    ## What it needs
    
    The cut as shot: one or more 1080x1920 framings of the same timeline (alt / wide / tight; switching between them on the
    speaker's jump cuts is the only "camera"), assets/voice.wav, build/words.cut.json (edit seconds). No matte: nothing sits
    behind the speaker's head. A list or a run of points in the script (3-5) for the rundown. Pictures only when the speaker
    names a real thing (a book cover, a document); everything else is drawn in code. Fonts (Fira Sans, Fira Sans Extra
    Condensed, IBM Plex Mono, all OFL with Cyrillic) and SFX are copied by the builder.
    
    ## Build
    
    A Python builder, `newspackage.py` (class `Bulletin`; its docstring lists every call and sketches an English segment),
    reading the look from house.json. A reel is a short generator in the project that calls it. The public edition has no
    worked example for this recipe yet: write `$P/tools/build.py` from build/plan.txt, the docstring and SYSTEM.md.
    
    ```bash
    S=~/.claude/skills/ghost-editor; PY=~/.venvs/media/bin/python
    $PY $P/tools/build.py --project $P             # index.html, build/beats.json, build/coverage.txt
    bash $S/scripts/hf.sh lint $P                   # 0 errors
    bash $S/scripts/hf.sh snapshot $P --at <beat times> --no-end --describe false   # look at every beat
    $PY $S/scripts/finals.py preview $P --out $P/finals --style "News Package" --code R01 --title "..."   # WAIT for the user's OK
    ```
    
    The calls: `sting()` (plate -> bug), `face()` + `face_strap()` (enter / set / flip), `card()` + `wipe()`, the package
    parts `rundown()`, `eyebrow()`, `push_text()`, `stamp()`, `corner_tag()` (via `card(tag=...)`), `bracket()`, and the
    graphics `document()`, `flap_board()`, `check_rows()`, `accent_cards()`, `threshold()`, `proportion()`, `cells()`;
    then `plates()`, `sfx()`, `build()`. Strap states are `Strap(tab, head, sub, source)`; every word is checked to be
    >= 48 px and to have its glyph in the font. `Bulletin(..., lang=)` sets the page language (default "ru"; pass "en" for
    an English reel).
    
    ## Where things are
    
    - Source: lemo-opuscar, styles/news-package (STYLE.md, DEMO.md, demo/main.js); the reference film was only watched
      (not part of the recipe).
    - Fonts: fonts/ (woff2 subsets for the page, OFL texts beside them) and fonts/ttf/ (the full TTFs for measuring; IBM
      Plex Mono is served from its TTF, see CREDITS.txt).
    
    ## Credit
    
    Package system, component geometry and palette adapted from lemo-opuscar "Broadcast News Package" by LemoLab (MIT,
    Copyright (c) 2026 LemoLab; LICENSE-lemo-opuscar.txt). The demo film (CC BY 4.0) and its media are not copied.
    Details: CREDITS.txt.
    
  • recipes/pov-montage/README.md7.6 KB07492ba80ac2upstream ↗
    # POV montage: first-person footage cut into a story, with the editorial motion layer on top
    
    Call it with: **"cut these POV clips into a reel"**, **"make a vlog reel from my glasses footage"**.
    
    First made for a first-person scooter ride across a city (smart-glasses footage, 7 clips, 13 min → 50 s).
    
    **When to use:** several clips from smart glasses, a GoPro or a phone, a day or a trip, with a few spoken lines and moments.
    
    ## The grammar
    
    1. **Find the story first.** Order clips by creation time; contact sheets at 1 frame/4–8 s; transcribe everything (whisper small, then
       medium on the lines you keep, then Gemini 2.5 Pro to confirm); ask the user for the moment they remember ("someone tried to hit me").
       A flash-forward hook from the end (a line like "39 minutes left and I'm late") + a "15 minutes earlier" rewind works.
    2. **One edit list (edl.json):** clip, source in/out, speed (1 for speech, 2–3× for riding), audio (voice / amb −14 dB / mute),
       and `freeze` segments (a held frame, silent). `assemble.py` crops 3:4 glasses footage to 9:16 (1647×2928 → 1080×1920, no upscale),
       bakes the speed-ups and writes one talk.mp4 + edl_map.json.
    3. **Captions from verified source word times** (`gen_words.py`): words typed once with their source times, mapped through edl_map.json,
       so re-cuts keep them right.
    4. **Motion layer = the editorial preset with an accent that fits the footage** (lime #A6FF00 with `brand.onAccent: "#111"`):
       - kinetic hook scene, dark background, white filler words, `pip` window, `pullback` short so the last word isn't covered
       - fly3d "15 minutes earlier / 13:24 / place" rewind with a glitch in
       - `behind` text on the one selfie (needs `matte: true`; delete assets/talk-matte.webm after every re-cut)
       - a cursor-click `card` for the fun fact and `stats` badges for times
       - B-roll stills from your own unused 4K frames (`image` scene), never 720p stock
    5. **The moment:** freeze frame (1.4 s) + 1.3× zoom + record scratch + an emoji over a stranger's face (also anonymises them),
       then the line, then a reaction meme 2–3 s later. Music ducks to almost nothing under the freeze.
    6. **Music** (life-is-a-dream for a sunny ride) with `music.duck` windows on every spoken line.
    
    **Public edition note:** the reaction meme and the record-scratch sound in step 5 come from a private meme kit that is not
    redistributed. Add your own clip with `scripts/meme_add.py` (only media you have the rights to) and use a Mixkit sound such as
    `impact-1` or `whoosh-cine` for the freeze. The worked example does that: `impact-1` on the freeze and a Mixkit reaction sound
    (`reaction-fail-trombone`) where the meme would go.
    
    ## Formats (worked example in example/: edl.json, assemble.py, gen_words.py, reel.json, script.txt)
    
    - **edl.json:** `{"segments": [...]}` in edit order. A segment is `{"clip": "<id>", "a": <source in, s>, "b": <source out, s>,
      "speed": 1, "audio": "voice" | "amb" | "mute", "note": "..."}`; a freeze is `{"clip": "<id>", "freeze": <source s>, "dur": 1.4,
      "audio": "mute", "note": "..."}`.
    - **assemble.py** (write it per project, with the clip id → source file map at the top): each segment cut to a whole number of
      30 fps frames in both picture and audio (source edges snapped to the frame grid, so the concat cannot drift), 3:4 clips
      centre-cropped to 9:16, speed-ups baked in (chained `atempo` above 2×), voice segments high-passed and lightly denoised at full
      level, ambience 14 dB down, speed-ups silent, the whole program normalised to −16 LUFS (two-pass loudnorm, TP −1.5).
      Writes assets/talk.mp4 and build/edl_map.json: per segment `i`, `clip`, `src_a`, `src_b`, `speed` (0 for a freeze),
      `edit_start`, `edit_end`, `note`.
    - **gen_words.py:** the kept lines typed once as `(clip, [(word, source start, source end), ...])`, mapped to edit time through
      build/edl_map.json (words whose source moment is not in the cut are skipped), written as build/words.fixed.json
      (whisper-style `segments[].words[]` with `word`, `start`, `end`).
    - **reel.json:** `"style": "editorial"`, `"source": "assets/talk.mp4"`, `"words": "build/words.fixed.json"`, `"matte": true`
      (for `behind`), a `brand` block (`accent`, `accentDark`, `ink`, `onAccent`, `capSize`, `font`), one take over the whole
      pre-assembled montage (`"takes": [{"a": 0, "b": <length>}]`), `zoom.pushes` for the moment, `captions` (`group`, `y`,
      `highlight`), `music` with `duck` windows, and `beats`: scenes of kind `kinetic`, `fly3d`, `image`, `card`, `stats`, plus
      `behind`, `emoji` and `meme` beats.
    
    ## Pipeline
    
    ```bash
    S=~/.claude/skills/ghost-editor; P=~/reels/<name>
    # proxies + sheets + transcripts (see SKILL.md step 1-2); write $P/edl.json (format: example/edl.json)
    cp $S/recipes/pov-montage/example/{assemble.py,gen_words.py} $P/   # edit SRC / PHONE at the top of assemble.py
    cd $P && python3 assemble.py && python3 gen_words.py              # gen_words: type the kept lines with source word times
    python3 $S/scripts/face_track.py assets/talk.mp4 --out build/face.json
    # reel.json: start from example/reel.json (style editorial + brand + beats), then
    node $S/scripts/build.mjs $P && $S/scripts/hf.sh lint && $S/scripts/hf.sh snapshot --at <every beat>
    $S/scripts/hf.sh render -o build/reel.mp4 && python3 $S/scripts/qa.py $P build/reel.mp4
    ```
    
    ## Checks that caught real problems
    
    - Mixkit's San Francisco clips are 720p and personal-use only: rejected. Your own 4K frames make better B-roll.
    - The QA SFX stem used to include the music bed, so loud music read as loud effects (fixed in qa.py).
    - Two meme sounds 5 s apart break the 8 s guideline; keep both only when they are the joke, and say so.
    - The person cut-out (matte) is cached: after any re-cut delete it, or old cut-outs float over new footage.
    - Speed-ups above 2× need chained atempo filters (assemble.py does it).
    
    ## Worked example
    
    `example/` holds an English montage, "lost my lunch to a seagull": a seaside walk in first person, five smart-glasses clips
    and one phone selfie cut by `edl.json` into 14 segments (39 s + a 2 s outro): the flash-forward hook as a `kinetic` scene
    with the speaker in a round window, a `fly3d` "20 minutes earlier / 12:40 / the pier" rewind with a glitch in, a `behind`
    word on the selfie, an `image` scene from a still of the speaker's own unused footage, a cursor-click `card` for the fun
    fact, `stats` badges for the times, the moment (the gull dives in, a 1.4 s freeze with a 1.3× push, `impact-1` and an emoji
    over the gull), the reaction sound right after the line and a comment-prompt end card; editorial captions (`group` 4, two
    `highlight` words), `happy-times` ducked under every spoken line, `sfxProfile: "restrained"` (7 hits, about 10 a minute).
    `script.txt` lists the seven spoken lines with their clip and source seconds. It is for reading and copying: the clips are
    yours to supply. Map your files in `assemble.py` (`SRC`, `PHONE`), re-time `edl.json` and the words in `gen_words.py` from
    your own sheets and transcripts, then every beat time in `reel.json` (they are edit times on the assembled montage,
    build/edl_map.json). Editorial captions pair lines two by two across the whole reel (a `tags` pill heads a block of up to
    three), so a sentence with an odd number of lines hands its last line to the next sentence's block, and it stays on screen
    through a mute montage in between: check each `eblock`'s `data-start`/`data-duration` in index.html, and keep every sentence
    an even number of lines with `group` and the commas you type in gen_words.py (the example puts a comma after "seaside" for
    that). A dry run (test-pattern clips with a synthetic voice; whisper times typed into gen_words.py) assembles, builds
    (BiRefNet matte for the behind word) and lints with 0 errors; it has not been rendered with real footage.
    
  • recipes/product-page/README.md3.4 KBf3f7169187edupstream ↗
    # Product page
    
    a review or demo of a named tool laid out like a product page: the speaker's cut-out over a rounded footage card on a
    gradient page, two-tier headlines (heavy sans + italic serif), one spoken word at a time in a pill, zoomed screen crops
    on the verb, camera moves between sections; from @adrien.ninet
    
    What it looks like: white pages carry the thing (its real picture, the rebuilt UI state, hairline line-art drawings of
    the nouns) and a virtual camera moves inside them on the speaker's words; the speaker's face, as shot, comes in full
    frame for the lines said to the viewer (white two-tier chest captions) and as a cut-out over a rounded footage card in
    the hook and the splits; the grey word pill runs over pages; black two-tier titles land on the page; a ducked plucky bed
    that drops out under the hook payoff; a flat ending.
    
    The accent and the logo come from the product itself: run `scripts/brand_kit.py pull <its URL> --dir $P/brand` and
    pass `accent=kit["accent_on_white"]`; its logo, icon and people-checked product shots are in `$P/brand/` (see `brand_kit.py show`).
    
    Read SYSTEM.md first (thesis, invariants, house look, slots and generators, planning procedure, changelog);
    house.json is the fixed look, catalog.json what each reel used.
    
    ## Build
    
    A Python builder on scripts/lib/facereel.py: `productpage.py` (class `ProductPage`; usage block in its docstring). A reel
    is a short generator in the project that calls it. The public edition has no worked example for this recipe yet (the
    founding reel's generator holds a private script): write `reel.py` from the usage block in productpage.py's docstring,
    SYSTEM.md (slots, planning procedure) and the component definitions in catalog.json. What a reel needs in $P:
    the plate(s) as shot (assets/*.mp4), assets/<plate>_matte.webm (matte.py on the hook + split windows),
    assets/voice.wav, build/words.cut.json, build/face.json per plate (face_track.py), the real picture of the named thing
    through insert_prep.py (+ a 2x copy for the hook badge).
    
    ```bash
    S=~/.claude/skills/ghost-editor
    ~/.venvs/media/bin/python reel.py --project $P          # index.html + build/beats.json, plan.json, sfx_events.json, capboxes.json
    bash $S/scripts/hf.sh lint $P                           # 0 errors
    python3 $S/recipes/seoul-list/snap.py beats $P          # look at every beat
    python3 $S/scripts/components.py check --style product-page --project $P
    python3 $S/scripts/finals.py preview $P --out $P/finals --style "Product page" --code R01 --title "..."   # WAIT for the user's OK, then render
    ```
    
    The building blocks (times are edit seconds or word refs, `R.t("word")`, `"word#2"`):
    - scenes: `R.hook(end, file_card(...), headline)`, `R.art_page(...)`, `R.rise_page(...)`, `R.split(...)`,
      `R.ui_page(...)` + `R.rows_off(...)`, `R.face_beat(...)`, `R.whip_pages(...)`, `R.gallery(...)` + `R.shrink_tile` +
      `R.veil`, `R.page_title(...)`, `R.pills(windows)`, `R.build()`
    - moves: `R.camera`, `R.app_icon`, `R.press`, `R.fade_in` / `fade_out`, `R.draw_on`, `R.loop`, `R.hop` / `falter`,
      `R.phone_hops`; budgets: `R.full_page`, `R.insert`, `R.sound`, `R.beat`
    - props and UI (the founding reel's set: draw new ones per reel): `Art`, `iso`, `box`, `line`, `cyl`, `phone_art`,
      `bed_art`, `shoe_art`, `mugs_art`, `stairs_art`, `book_art`, `ios_alert`, `ios_list`, `bell_glyph`, `tile`, `full`, `place`
    - `fontwidths.py`: advance widths for fitting (run by the builder when build/metrics.json lacks a voice)
    
    ## Calls
    
    - "Product page"
    - "tool review page"
    
  • recipes/result-podcast/README.md11 KBcc07539277e3upstream ↗
    # RESULT: a warm podcast-style edit with paper, film and handwriting
    
    Call it with: **"edit this in RESULT style"**, **"loompixual style"**.
    
    The look comes from @loompixual's "RESULT" edit. Libraries and licences behind it: STYLE-LIBRARIES.md in this folder.
    
    **When to use:** storytelling or nostalgic talking heads, podcast-style monologues, lists of memories or examples where a photo per
    idea helps. Warmer and more tactile than Clean OS.
    
    **Two ways to build it:**
    - **Face RESULT** (the default for a talking head): the speaker's face stays on screen as shot and the paper props sit
      beside, above or below it, never on it. Section "Face RESULT" below; `faceresult.py`.
    - **Paper-led RESULT**: full-screen paper scenes between lines (`example/` in the private edition). On a talking head it
      breaks the budgets (face >= 65 %, a full-screen card <= 2.5 s): use it only for a narrated or footage-free reel.
    
    ## The grammar
    
    1. **Captions:** one or two words at a time, centred, Inter Tight. Two-tier emphasis: a small line, then one big bold word.
       Key words in Caveat handwriting.
    2. **Cards:** navy text cards with film dust; polaroid photo cards; a paper stack whose pictures swap stop-motion; framed B-roll.
    3. **Texture:** dust and grain drawn on a canvas seeded per frame (deterministic in render); film-burn light leaks at section turns.
    4. **Props for the funny beats:** comic emoji stickers, a REC frame, an incoming-call card with a finger tapping "decline",
       a cursor clicking a dialog, a chat-bubble card.
    5. **Cuts:** hide jump cuts with a 0.2 s picture morph-dissolve between lines while the audio hard-cuts. No zoom on every cut:
       at most three comic punch-ins per reel (per-cut zooms were rejected as annoying).
    
    ## Pipeline
    
    ```bash
    S=~/.claude/skills/ghost-editor; P=~/reels/<name>
    # 1. attempt log: Gemini 2.5 Pro over the WHOLE raw take (every attempt, restart and filler, verbatim)
    # 2. takes: best take per line, cut only pauses > 0.7 s inside a line, start each line at the voice onset (RMS > -30 dB, no breaths)
    cp $S/recipes/result-podcast/example/{takes.py,build.py,gen_broll.sh} $P/ && cd $P && python3 takes.py      # -> build/takes.json + build/rough.mp4
    # 3. the rough cut: transcribe it (build/rough.words.json), audit it verbatim with Gemini 2.5 Pro; fix and re-audit until clean
    python3 $S/scripts/transcribe.py build/rough.mp4 --out build/rough.words.json --lang <code>
    # 4. B-roll stills / photos for the polaroids and stack (gen_broll.sh: AI stills with $S/scripts/broll_gen.py), the fonts,
    #    then adapt build.py's beats to the new script (every beat is keyed to the spoken words)
    bash gen_broll.sh && python3 $S/recipes/clean-os/fetch_fonts.py $P "Inter Tight:ital,wght@0,400..800;1,400..800" "Caveat:[email protected]"
    python3 build.py && $S/scripts/hf.sh lint && $S/scripts/hf.sh snapshot --at <every beat>
    $S/scripts/hf.sh render -o renders/<name>.mp4
    ```
    
    ## Checks that caught real problems
    
    - Whisper merges restarts ("millennials alw- millennials") into a clean sentence and can even invent a script word that was never
      said. The take picker left 6 restarts in until two Gemini 2.5 Pro audits found them all.
    - Hide each caption with an explicit `fromTo` placed AFTER its fade-in; a bare `set` inside the fade gets overridden and the caption
      stays on screen.
    - Seed the per-frame dust/grain canvas by frame number, never by wall-clock time, or renders won't match previews.
    
    ## Worked example
    
    `example/` holds an English storytelling reel, "keep the paper" (12 lines, about 32 s of speech + a 2.2 s outro), with
    `script.txt`: on every trip the speaker keeps one paper thing a day. `takes.py` picks the best take of each line (two of
    them follow a false start) and writes the rough cut; `build.py` lays the takes with the morph dissolve and keys every
    beat to the rough cut's words: a train ticket stamped "day 1" on kraft, a thermal receipt that prints out of its slot and
    gets its missing address circled, a notebook page closing over a pressed leaf, a photo-count notification and a storage
    dialog a cursor dismisses over the speaker (with the only two punch-ins and two emoji stickers), a paper stack whose
    pictures swap stop-motion, a polaroid with the ticket landing on it and handwriting on both, a sticky note, the final navy
    card held through the outro; film-burn leaks at the three turns only, `chillax` as the bed. `gen_broll.sh` makes its six
    stills (no people in any of them). It is for reading and copying: the recording is yours to supply. Re-time `LINES` in
    takes.py from your own attempt log, transcribe the rough cut with `--lang en`, and fix any word key the build stops on
    (keys accept spellings like `"thousand|3000"`). A dry run (a test-pattern recording with a synthetic voice and two false
    starts, the six stills from gen_broll.sh) builds and lints with 0 errors; it has not been rendered with real footage.
    
    ## Face RESULT (talking head: props beside the face, never on it)
    
    Call it with: **"Face RESULT"**, **"RESULT on my face"**, or **"RESULT style"** on a talking head.
    
    `faceresult.py`, on the shared base `scripts/lib/facereel.py`. It shares this folder's house.json and catalog.json, so a
    new reel cannot repeat a RESULT prop by accident.
    
    **House (never changes):**
    - the speaker's plate AS SHOT: no grade, no filter, no vignette on the face; a slow 4 % drift; at most 3 punch-ins (they
      pivot on the mouth line so the chin barely moves); film grain + per-frame dust over everything (texture only);
    - two-tier captions on a navy card under the chin: a small Inter Tight line (62 px) over one big word (132 px) or a
      Caveat key word (150 px), sized to fit; one text layer at a time (a chest prop or a card that carries the words drops them);
    - paper objects from the line's world BESIDE (left / right column), ABOVE (top band) or BELOW (chest band) the face,
      placed in zones measured from build/face.json per prop window, inside the Instagram safe area (top 220, bottom 1500);
    - full-screen cards (navy / kraft / cork / paper) <= 2.5 s, pushing in slowly; the face on screen >= 65 %; <= 3 stock / AI
      inserts a minute, each in a polaroid or paper frame, prepared by insert_prep.py.
    
    **New every reel** (`components.py plan --style result-podcast`): the props, the card treatments, the entrances
    (`enter=`: none / slap / toss / unfold / swing / fade / side / drop / rise), the full-screen card entrances
    (fade / iris / push / wipe), the hook and the outro.
    
    ```bash
    S=<skill>; P=<project>
    # $P/assets/plate.mp4 (the approved raw cut, video only, as shot), $P/assets/voice.wav, $P/build/words.json (edit seconds)
    python3 $S/scripts/face_track.py $P/assets/plate.mp4 --out $P/build/face.json
    python3 $S/scripts/components.py plan --style result-podcast        # avoid the recent reels' components
    # write $P/reel.py (below): this reel's beats, keyed to words; example-face/reel.py is a whole one to start from
    # (copied into $P, point its sys.path line at $S/recipes/result-podcast)
    python3 $P/reel.py $P                 # -> index.html + build/{plan,beats,sfx_events}.json; FAILS on a broken rule (below)
    $S/scripts/hf.sh lint ; python3 $S/recipes/seoul-list/snap.py beats $P      # look at every beat's strip
    python3 $S/scripts/finals.py preview $P --out $P/finals --style "Face RESULT" --code R01 --title "..."   # WAIT for the user's OK
    python3 $S/scripts/components.py add --style result-podcast --id <new> --kind prop --sig 'class="prop fr-<new>"' --desc "..."
    python3 $S/scripts/components.py record --style result-podcast --project $P --reel R01              # after the user's yes
    ```
    
    ```python
    import sys; sys.path.insert(0, "<skill>/recipes/result-podcast")
    from faceresult import *
    R = FaceResult(sys.argv[1], cover=[(23.5, 24.2)], music={"id": "chillax", "db": -21})
    t = R.t                                   # word refs: "word", "word#2", "^word" (its end), "word+0.1", "two words", a number
    a, b = t("beach") - 0.1, t("^work") + 0.4
    R.prop("card", a, b, "right", '<div class="sheet"><div class="hand l1">tasks</div></div>', w=260, h=380, what="a note",
           enter="slap", cls="fr-note")
    R.write("#card .l1", t("tasks"))          # handwriting on its word; also R.stamp, R.pop, R.draw, R.words_in, R.show / R.hide
    R.scene("big", t("even"), t("even") + 2.0, "kraft", "<div>...</div>", what="a full-screen card", enter="iris", caps=True)
    R.punch(t("better"))
    R.build(BIG={"work", "better"}, SCRIPT={"breather"}, css=".l1 { position: absolute; left: 20px; top: 40px; font-size: 52px; }")
    ```
    - `R.prop(id, a, b, zone, html, w, h, what, dx=0, dy=0, rot=0, enter=..., leave="fade", nocap=None, cls="fr-<name>")`:
      `zone` = `left` / `right` / `top` / `chest`; it fails when it does not fit the zone or touches the face; `cls` is the
      catalog sig (`class="prop fr-<name>"`).
    - `R.scene(id, a, b, "navy"|"kraft"|"cork"|"paperbg", html, what, caps=False, enter="fade"|"iris"|"push"|"wipe", cls=...)`
    - `R.polaroid(...)`, `R.still(...)` / `R.video(...)` (an insert: counted, picked up by broll_vision picks from index.html)
    - `R.build(BIG={...}, SCRIPT={...}, css="...")`: captions, plate, grain, dust, audio; prints the numbers and `components.py check`.
    
    **The build refuses** (fix the generator): a prop that touches the face (also under a punch-in or the drift) or does not
    fit its zone; a caption card the chin reaches; a full-screen card > 2.5 s; a look-away (`cover` / build/cover_windows.json)
    not hidden while a card is fully in; the face on screen < 65 %; > 3 inserts a minute; a 4th punch-in; an id named c<n>
    (caption ids).
    
    **Worked example:** `example-face/` holds an English talking head, "the doorway effect" (11 sentences, about 42 s), with
    `script.txt`: you walk into a room and forget why, because a doorway tells the brain the scene is over. `reel.py` keys
    every beat to the words: a paper door already beside the speaker on frame 1 that opens on an empty doorway, a paper
    fridge whose magnet letters spell WHY, a ticket ("memory: fine ✓", THE DOOR stamped) with the first punch-in, a label
    tape printing DOORWAY EFFECT on the chest, a film slate that claps on "film" and changes scene on "doorway", the one
    full-screen card (2.44 s, wiped in: an index card drops into an OLD SCENES drawer) over the look-away, a graph-paper card
    in the top band whose bars grow on "door" and "room", a paper megaphone on the chest with the second punch-in, and the
    door again as the outro (it shuts on "close", a wedge props it open on "don't"). Every prop is drawn (0 inserts), 15
    sounds from the kit, `lo-fi-02` as the bed. It is for reading and copying: the recording is yours to supply. Transcribe
    your cut with `--lang en`, take its look-aways from `scripts/cover_windows.py` (leave `cover=` out to read
    build/cover_windows.json), and fix any word key the build stops on (`fixes=` maps a misheard word to the spoken one).
    A dry run (a synthetic voice, a stand-in talking-head plate tracked by face_track.py) builds with the face on screen
    94.3 %, one full-screen card covering the look-away and 2 punch-ins, lints with 0 errors and was checked beat by beat
    with snap.py; it has not been rendered.
    
  • recipes/seoul-list/README.md17 KBea0f84249f1bupstream ↗
    # Seoul list: a voice-over list over fast B-roll, two type families, phone-UI stickers, an iMessage outro
    
    Call it with: **"Seoul list"**, **"like the Seoul reel"** (also "edit this in Seoul list").
    
    From a 46 s list reel about life in Seoul (Sep 2025). The numbers below come from its breakdown (shot lengths, every
    element checked on full-res frames).
    **Status (Oct 2026):** the mechanics are proven by a smoke test (that reel's own voice, music removed, over unrelated
    clips, compared with the reference block by block). The look still has to be proven on the next real video.
    **Read SYSTEM.md before planning a reel**: what must stay, what must change.
    
    **When to use:** a calm voice-over (not to camera) listing 5-8 observations about a place, a trip or a topic, ~100 words
    in 45 s, over B-roll (the user's own when they hand it over). A selfie shot as the opener is fine. For talking heads use the main flow, Clean OS or RESULT.
    
    **Footage ("Seoul list" names the format, not the footage source).** Full-screen B-roll is the
    format, so any footage may fill the screen. In order:
    1. Footage the user hands over for this reel: always used.
    2. The user's own library through `own_footage.py` (face-checked: only the speaker appears; show the user the confirmation sheet before the render).
    3. Sourced B-roll, stock or AI, full screen allowed here (the "stock only inside a frame" rule is for talking-head styles).
    4. A line with no fitting footage can still become type: a word flash, a list, a collage page, a phone sticker.
    
    The quality bar keeps the B-roll few and good-looking. It is checked by
    `broll_qa.py <render> --project $P --profile broll-led --style seoul-list`:
    - **People rules:** configurable B-roll people rules (`people-rules.json`; e.g. exclude women, or symbols; the default
      file has none, see `people-rules.example.json`). A shot that breaks a rule fails: pick an empty street, a detail or
      another shot. `broll_vision.py picks` before the render, `broll_qa.py` check `people` (skipped when no rules are set).
    - **Each shot shows its line** (check `match`); a line with nothing that fits becomes type. Stock images on a collage
      page are fine.
    - **One graded world:** every clip goes through `insert_prep.py --ref <ref>`: the speaker's face plate AS SHOT, or with
      no face of the speaker the main footage the user handed over. Never regrade the speaker's face to a house look, and the
      inserts agree. The spread across them must stay within L* sd 14 and b* sd 5
      (the reference: 11.8 / 2.5).
    - **No posed stock models:** places, objects, the speaker's world. A stranger's face filling 8 % or more of the frame width fails.
    - **Reference pace:** a median shot of 0.9-2.2 s (the reference: 1.30 s).
    - **1080p or better.**
    - Spoken lists of activities ("swimming, cycling, football") are typography, not one 0.5 s clip per noun.
    
    In an audit of test reels, the lowest-scoring one (4.0) failed on mismatched stock, not on stock as such: 21 unrelated
    posed models in three light worlds (white balance spread 7.7 b*).
    
    ## Anatomy (measured on the reference)
    
    | block (`type`) | look | timing |
    |---|---|---|
    | B-roll montage (`shots`) | hard cuts, median 1.4 s (0.8-2.7), one long hold allowed, opener can be a selfie | cut on spoken words; 1 transition max: a zoom-blur whip into the outro (`tx`) |
    | word beat (`word`) | ONE big word ~600-700 px wide (short words get bigger) + a subline (~54 px) tucked under its right end, or small words over its corners. *Playfair Display Italic* for mood/place words, *Inter Tight 800* (tight, CAPS for the contrast word) for facts. White, soft dark shadow, centred at 45-55 % | blur-in 0.22 s ON the spoken word (stagger ~0.1 s), fade out 0.12 s; a new word every 0.7-1 s |
    | stacked list (`list`) | heavy words stacked (three verbs, one per line) | each on its word |
    | white word flash (`flash`) | white frame, one black heavy connector word ("even", "cameras &"), small | 0.4-0.8 s, hard in/out |
    | white collage page (`collage`) | (a) the current shot shrinks into a rounded card on white, a small black line above; the card dissolves as a red glitch serif word lands and the line drops under it; hand + 👀 stickers. (b) heavy black line above a photo card that flies in tilted and lands straight, italic serif word under it, a sticker at the edge | the hook, 1.5-3 s per page |
    | triptych (`triptych`) | three shots as equal 640 px bands | under a list or a comment card |
    | Instagram comment (`comment`) | white rounded card, round avatar, text typed word by word on the voice, emoji, a faint "Reply" label | the first-person aside, ~2 s, notification sound |
    | macOS window (`window`) | dark frosted glass (a blurred copy of the shot), red/yellow/green dots, label or logo top right, a BiRefNet cut-out; the shot behind darkened | swaps item + label on each spoken item |
    | blue highlight (`highlight`) | iMessage blue (#0B84FE) blocks behind white heavy words, left-aligned, stacked like a selection, optional emoji | each wipes in on its word |
    | iMessage outro (`imessage`) | the last shot shrinks into a card on black and floats off in 3D (+ 0-4 tilted photo cards from the reel), a blue typing bubble (•••; blue in the reference, not grey), the blue bubble with the closing word, an emoji tapback on its corner | starts >= 1 s before the closing word; bubble ON the word |
    | sound | measured on the downloaded reel: NO audible music bed (the mix in VO pauses is -54 dB) and only 3 non-voice hits (hook whoosh, photo-card fly-in, the outro send). Gemini's "~25 hits + lo-fi bed" is not supported | `sfx: "reference"` reproduces exactly that; a bed is optional |
    
    The reference's cartoon glove hands are Disney/Mickey-style art: never copied. Stickers are Fluent emoji (MIT) from
    library/emoji: `waving-hand`, `hand-splayed`, `point-right`, `eyes`, `running`, `yum`, `fire`, ... Brand logos are never
    bundled: pass the user's own image as `logo`, or a text `label`.
    
    ## Pipeline (end to end)
    
    ```bash
    S=~/.claude/skills/ghost-editor; R=$S/recipes/seoul-list; P=~/reels/<name>; HF="$S/scripts/hf.sh"   # the pinned HyperFrames (scripts/HF_VERSION)
    mkdir -p $P/clips && cd $P
    # 1. proxies: 1080x1920 30 fps H.264, no audio, refuses < 1080p; originals are never moved or modified
    bash $R/proxy.sh <out-dir> <clips...>     # e.g. bash $R/proxy.sh clips ~/Downloads/my-trip/IMG_1.MOV ~/Downloads/my-trip/IMG_2.MOV
    #    pick shots on 1 fps sheets: ffmpeg -i clips/X.mp4 -vf "fps=1,scale=180:320,tile=20x1" -frames:v 1 X.jpg
    # 2. the voice-over (if it has music under it: voice_enhance.py IN clean.wav --mode enhance, audio-QA venv)
    python3 $R/prep.py voice <your-read> assets/voice.wav [--keep 0-21.2,24.6-26.4 --gap 0.2]   # -16 LUFS, frame-snapped pieces
    python3 $R/prep.py words assets/voice.wav build/words.json                                # whisper turbo + word times; read it
    # 3. stills (LOOK at each; confirm the avatar is the speaker)
    python3 $R/prep.py still  clip07 6.0  stills/photo-01.jpg         # photo / outro cards: a proxy frame
    python3 $R/prep.py cutout clip01 9.0  stills/item-pastry.png      # window items: BiRefNet (matte venv), cropped to the object
    python3 $R/prep.py avatar clip10 30.0 stills/avatar.jpg           # comment avatar: YuNet face crop
    # 4. list.json (start from example/list.json), build, lint, LOOK at every beat
    node $R/build.mjs $P                     # shots, beats + snapshot times, SFX table, music, WARNINGS
    $HF lint                                 # 0 errors, 0 warnings
    python3 $R/snap.py beats $P --shots      # build/snaps/<beat>.jpg + overview.jpg: read every strip, fix, rebuild
    # 5. after the user's yes: render, QA, the frame-exact cut check, per-block strips
    $HF render -o renders/<name>.mp4 --quiet
    python3 $S/scripts/qa.py $P renders/<name>.mp4         # A/V lengths, loudness, SFX vs voice on a stem, silences, contact sheet
    python3 $R/snap.py cuts $P renders/<name>.mp4          # each visible cut shows exactly its proxy frame (best offset 0)
    python3 $R/snap.py strips $P renders/<name>.mp4        # build/strips/<beat>.jpg from the render
    ```
    Against a reference: `snap.py compare REF.mp4 RENDER.mp4 --pairs "label=refT,...:ourT,...;..." -o compare`.
    approval_sheet.py and render_report.py read reel.json, so for this recipe send the user `build/snaps/overview.jpg` and
    the strips as the approval page, then deliver as in SKILL.md step 8.
    A Python generator (a reel's own short script) imports the plumbing from `$R/seoul.py` instead of writing
    a lib: `sys.path.insert(0, "$R"); from seoul import *`, then `setup("$P", cut="<clip>/edit")`, `W(word, near)` for word times,
    `vid` / `card` / `still_clip` for stock inserts, `write(spec)` (list.json + build.mjs + the readability CSS) and `measure(spec)`.
    `python3 $R/seoul.py --api` lists every call with its signature; the reel's own new components stay in its generator.
    
    ## list.json
    
    Top level (all optional except `shots`):
    
    | key | default | |
    |---|---|---|
    | `voice` | `assets/voice.wav` | from `prep.py voice` |
    | `words` | `build/words.json` | from `prep.py words`; re-run whenever the voice changes |
    | `clips` | `clips` | the proxy folder; a clip is named without `.mp4` |
    | `fixes` | | whisper corrections used for matching: `{"Five": "5"}` |
    | `tail` | `1.0` | seconds after the last word |
    | `sfx` | `restrained` | `reference` (hook word, photo fly-in, outro send), `restrained` (+ one per block), `standard` (+ every sticker, swap and item, ~10 per 10 s), `none` |
    | `mix.roleDb` | ui -14, whoosh -12, impact -8 | SFX level per role, dB against the voice's p95 peak (as build.mjs) |
    | `music` | none | `{"id": "lo-fi-02"}` (library/music) or `{"src": ...}`; `db` -14 vs the voice, `duck` -6 dB under speech, `start`, `fadeIn` 0.6, `fadeOut` 1.2 |
    | `blue` | `#0B84FE` | highlight and bubble blue |
    | `title`, `fps` | `Seoul list`, 30 | the frame is always 1080x1920 |
    
    **Time refs.** A time is a VO second (number) or a word ref, matched case-insensitively, ё = е, punctuation ignored, after
    `fixes`: `"Lisbon"` = first occurrence at or after the previous ref in list order (minus 0.3 s); `"in#2"` = the 2nd
    occurrence in the whole voice (**a repeated word needs #n**); `"^life"` = the word's end; `"Portugal+0.2"`, `"^coffee-0.1"`
    = an offset. A word not in the voice stops the build and prints the words it has.
    
    **shots** run back to back from 0 to the end: `{"at", "clip", "in", "zoom", "tx", "txDur", "txSfx"}`. `at` = when it
    starts (ignored on the first), `in` = clip second (proxy = source times), `zoom: [1, 1.06]` = slow push, `tx` = a
    transitions.py transition INTO this shot (`zoom_blur` is the reference's whip; `python3 $S/scripts/transitions.py list`).
    The build stops if a clip is too short.
    
    **beats** share `at` (start), `to` (end; a text beat ends at the next text beat or scene, max 2.4 s; a scene at the next
    scene, max 6 s: **give flashes and collages a `to`**), `y` (0-1), `sfx` (false, an id or a list: replaces the default
    hit), `label`. Per type:
    - **word:** `big` = a string (its words appear as spoken) or `[{text, at, family, size, color}]` segments (e.g. an upright
      "5"); `family` serif (default, italic) | serif-up | sans (800) | sans-it; `size` 150 serif / 140 sans (base); `width`
      = on-screen target px (660 serif / 620 sans; the page scales the big text to it x0.6-1.7; 0 keeps `size`); `caps`,
      `color`, `together` (all at once 0.1 s apart), `maxWidth` 960. `sub` = string | `{text, at, pos, size, family, color,
      caps}` | array; `pos` below-right (default) | below-left | above-left | above-right | below | above; size 54; default
      time = its first word as spoken near the big word (give `at` if it is not spoken). `subPos` / `subSize` for all subs.
    - **list:** `items` (strings or `{text, at}`), `size` 104, `lineGap` 0.92, `family` sans, `caps`.
    - **highlight:** `items` (strings or `{text, at, emoji}`), `size` 84, `x` 96 or `align: "center"`, `y` 0.47.
    - **flash:** `text`, `family` sans, `size` 92 (kept as set), `sub` (e.g. `{"text": "&", "pos": "below-left"}`), `y` 0.48.
    - **collage:** `shrink: {}` or `{scale: 0.63, until}` (the current shot shrinks into a card, dissolves at `until` / the
      big word); `line` (string or `{text, at, size, family}`, word by word; 58 px over a card, 88 px over a photo); `photo`
      (path or `{src, at, w 792, h 446, y, tilt 16}`, flies in tilted); `big` (string or `{text, at, family, size, color,
      caps, glitch, sub, y}`; `glitch: true` = red ghost copies + glow, colour #FF3B30); `stickers: [{emoji, x, y, size 150,
      at, to}]` (x/y = centre px; default time just after the big word, 0.12 s apart). Without a photo the line drops under
      the big word as its subline; with a photo the line sits above the card and the big word below it.
    - **triptych:** `clips` (three `{clip, in, pos}`; `pos` = vertical object-position %), `stagger` (s between band
      slide-ins; omit for a hard cut). Black page underneath.
    - **comment:** `text` (each word appears on its spoken word), `emoji` (pops right after the last word), `avatar`
      (`prep.py avatar`), `reply` (the faint label under the text, e.g. "Reply"; the built-in default is Instagram's Russian
      label, so set it for any other language).
    - **window:** `bg: {clip, in}`; `items: [{img, label | logo, at}]` (cut-outs from `prep.py cutout`; each swaps in at its
      `at`, default 1 s after the previous); `w` 720, `h` 520, `dim` 0.58, `bgBlur` 3.
    - **notify:** an iOS notification banner: `app` (upper-case header), `time` (e.g. "now"; the built-in default is the
      Russian iOS label, so set it for any other language), `title` (bold, blurs in at `titleAt`), `text` (typed word by word
      on the voice from its first spoken word, or `textAt`), `emoji` (the app tile), `tile` (tile colour), `y` 0.19. A number
      or a fact with its source ("Study review / 38,000+ workers").
    - **imessage:** `word` (bubble text, timed to that spoken word, or `at_word`), `at` (outro start; default `lead` 1.05 s
      before the word; the build warns under 1 s), `emoji` (tapback), `cards` (up to 4 stills), `typing` 0.42, `x` 150,
      `y` 0.5, `typingColor`, `sendSfx` (send-swoosh). It runs to the end.
    
    Outputs: `index.html`, `assets/` (hard links to the used proxies, fonts, emoji, SFX, stills, transition windows),
    `build/sfx_events.json` + `build/transitions.json` (qa.py), `build/beats.json` (snap.py), and the printed report.
    
    ## Rules (each one bit the smoke test or comes from the reference)
    
    - Everything is keyed to the VO's word times; write list.json from the whisper printout. Whisper can write a spoken hook
      number as a word ("Five things" -> "Five"): fix it in `fixes`, then refs can say "5".
    - Every word lands on its own spoken time, including a big word whose block opens on a small word said first, and a
      subline (key it to its FIRST word). The smoke build showed three big words 0.22-0.56 s early; fixed in build.mjs.
      Checked on the render: whisper word times = words.json (58/59 within 20 ms), audio offset 0 samples, every caption
      frame equal to the timeline's.
    - Read every strip from `snap.py beats` before rendering. The first smoke build had glitch ghosts visible from frame 0
      (a ghost's first tween started at opacity .85; the seek-safe helper applies the first from-state at load), 3 px word
      gaps (an em gap on a 16 px parent), a subline floating above the word next to a 330 px "7", a comment emoji with no
      size (`.cm-text span {display: inline}` won over `.iemo`), an outro card that went empty when its footage ended before
      its fly-off, and a typing bubble on top of the still-shrinking card. All fixed in build.mjs; this class of bug only
      shows in the snapshots.
    - The window's glass is a blurred second copy of the background video one frame later (identical copies trip
      hyperframes' `duplicate_media_discovery_risk`); not backdrop-filter.
    - Keep SFX sparse (the reference has 3 hits in 46 s); `restrained` is one hit per block. A bed is the user's call.
    - Photo and outro cards are frames from the reel's own clips. The avatar is the speaker's face crop or a photo the user
      gives; confirm it.
    - No 720p B-roll (proxy.sh refuses it). Proxy on the machine that holds the footage; never move or modify originals.
    
    ## Worked example
    
    `example/list.json` with `example/script.txt`: an English voice-over, "5 things that surprised me in Lisbon" (7 lines,
    71 words, about 30-35 s), 16 shots from `clip01`-`clip10`, 17 beats, every block type except `notify` at least once
    (word, collage with a shrinking card and with a photo card, flash, highlight, window, triptych, comment, list,
    imessage), a zoom-blur whip into the outro, lo-fi-02 bed at -14 dB ducked -6 dB. It is for reading and copying: the
    recording, the clips and the stills are yours to supply. Record script.txt (one block per line), proxy your clips as
    `clips/clip01.mp4` ..., make the stills with `prep.py still / cutout / avatar` under the names list.json uses, run
    `prep.py words assets/voice.wav build/words.json --lang en`, then re-time the `in` values to your clips. Every word ref
    in list.json resolves, in order, against script.txt; check them again against your words.json (whisper may write
    "Five" or "5"; `fixes` maps it so refs can say "5"). A dry run (test-pattern clips, a tone for the voice, word times
    synthesised from script.txt) builds with no errors and lints 0/0; it has not been rendered with real footage.
    
  • recipes/stan-style/README.md12 KBd1e7bb78df67upstream ↗
    # Stan style: a seated tool tutorial with screen recordings on top
    
    Call it with: **"stan style"**, **"tool tutorial"** (also "edit this in stan style").
    
    From @nicktarmo's tool tutorial (Oct 2026, 100 s). The numbers below come from its breakdown (verbatim script, every
    element checked on full-res frames); this README corrects the breakdown where the frames disagree (see "Measured"
    below). **Status (Oct 2026):** the mechanics are proven by a smoke test (a talking head plus three screen recordings,
    every block once, compared with the reference). The look still has to be proven on the next real video. **Read SYSTEM.md
    before planning a reel.**
    
    **Prerequisite: real screen recordings of the tool being explained.** Without them, say so and propose Clean OS (the
    idea as phone UI) or RESULT. Never fill the band with stock: a test reel filled it with stock people (a student with a
    laptop, code over a shoulder), their heads cut by the band, and it read as filler.
    
    **When to use:** a talking head explaining a tool, a workflow or a how-to in steps, with screen recordings of it
    ("here's how", "step one..."). One continuous take is the norm (choose takes as usual if not). It is NOT a separate
    renderer: it is the core pipeline (prep.sh, transcribe.py, face_track.py, takes, build.mjs, approval sheet, render,
    render_report.py, qa.py) with six beat types and the `chest` caption style from `scripts/lib/stan.mjs`.
    
    ## Anatomy (measured on the reference, 1080x1920)
    
    | block | look | timing |
    |---|---|---|
    | speaker | one seated medium shot; the eyes sit at ~42 % (y 815); a hard punch-in for the benefit line + CTA (`zoom.snaps`) | the whole reel |
    | `panel` (split screen, ~half the runtime) | the screen recording fills the top band edge to edge (cover-cropped), no frame, no shadow, BEHIND the speaker: their head is cut out and drawn over it, so the hair overlaps the screen (the reference band ends at y 700-780, 37-40 %). The speaker moves down only as far as the eyes need to sit ~80 px under the band (the reference never moved; the build computes it from face.json) | pops in (scale 1.05 -> 1 + fade, 0.2 s) and out (1 -> 0.95); the next panel pops in over the previous one with no speaker move between them; a mouse click on each cursor click |
    | `chest` captions | small white lowercase phrases (3-6 words, ~38 px Inter medium, soft shadow, no box) centred at y ~1305 (68 %); no punctuation | each phrase CUTS in on its first word (no animation) |
    | single words | one word at a time, ~66 px, same height: the hook (`captions.single`) and every diagram (black there, y ~1378) | cut on each word |
    | forehead words | one word at a time, ~64 px at y ~557 (29 %): a stretch near the end (`captions.top`) and `emphasis` words | cut on each word |
    | `hook` card | 1-2 rows of icons (~150 px) around a 1-2 line title in BLACK bold type on WHITE rounded strips (the breakdown said white on black: the frames show black on white), over the speaker | the first 1-5 s; at frame 0 it is simply there |
    | `diagram` scene | the only full-screen graphic: white, icons (~100-130 px), a bold black word (~110 px, «Idea»), curved black lines that draw on, a ringed dot at a line's end | entered by a zoom-blur from the speaker, ~4 s, a scribble per line |
    | `step` label | «[Step n]» (~46 px, medium) over a title (~46 px), the app icon(s) under them (~88 px), stacked just above the caption, under the chin | with the matching panel on top |
    | `cta` label | «Comment "word" for the prompt» + the product logo, in the step's place | when the prompt is on screen and at the end over the close-up |
    | `aside` | «*content sauce*» upright white (~66 px, semibold, the breakdown said italic: it is not) above the head | a spoken joke, on a full speaker shot |
    | sound | (Gemini, not yet measured) a bed under the voice, a whoosh into the diagram, pen scribbles, mouse clicks | restrained |
    
    Gemini's edit log was wrong about the captions (it said word by word at 52 %), missed the split screen, and claimed a
    "24/7 strobe": frames 0.1 s apart show no strobe, so `strobe` exists but is off unless asked for.
    
    Icons are user-supplied: `src` (their own logo files), `icon` (a simple-icons slug fetched at build time) or `emoji` (a
    Fluent emoji from library/emoji, MIT). Brand logos are never bundled.
    
    ## reel.json (on top of references/reel-json.md)
    
    ```jsonc
    {
      "captions": { "style": "chest",
        "single": [[0, 4.9]],                 // original-second windows: one bigger word at a time at the chest (the hook)
        "top": [[79.6, 95.7]],                 // one word at a time at the forehead
        "emphasis": ["find", { "word": "works", "at": 94.7 }],   // single words lifted to the forehead
        "strobe": [],                          // optional blink on a word (not in the reference)
        "y": 1305, "size": 38, "wordSize": 66, "topY": 557, "topSize": 64, "inkY": 1378, "maxWords": 6, "maxChars": 30, "lower": true },
      "zoom": { "origin": "52% 42%", "snaps": [[93.0, 1.22]] },          // the punch-in close-up
      "music": { "id": "lo-fi-02", "db": -22 },                           // optional bed
      "beats": [
        { "type": "hook", "at": 0, "to": 4.9, "title": ["AI automation tutorial", "for creative content ideas"],
          "icons": [[{ "src": "logos/video.png" }, { "src": "logos/app.png", "label": "the app" }],
                    [{ "src": "logos/chat.png" }, { "src": "logos/newsletter.png" }, { "src": "logos/social.png", "bg": "#000" }]] },
        { "type": "diagram", "at": 5.1, "to": 9.5,
          "nodes": [{ "id": "src", "src": "logos/video.png", "x": 330, "y": 1000, "at": 5.4 },
                    { "id": "app", "src": "logos/app.png", "label": "the app", "x": 540, "y": 600, "at": 6.6 },
                    { "id": "idea", "text": "Idea", "x": 540, "y": 340, "at": 8.4 }],
          "links": [{ "from": "src", "to": "app" }, { "from": "app", "to": "idea", "dot": true }] },
        { "type": "panel", "at": 11.2, "to": 15.0, "src": "rec/app.mov", "in": 2.0 },
        { "type": "step", "at": 46.0, "to": 50.4, "n": 1, "title": "Create a private channel", "icons": [{ "src": "logos/chat.png" }] },
        { "type": "cta", "at": 66.0, "to": 70.0, "word": "ritual", "logo": { "src": "logos/app.png" } },
        { "type": "aside", "at": 30.0, "to": 31.4, "text": "content sauce" }
      ]
    }
    ```
    
    | type | fields | default sound |
    |---|---|---|
    | `panel` | `src` (mp4/mov, 1080p or better), `in` (seconds into it), `to`, `behind` (default true: the speaker's cut-out is drawn over the panel; `false` = the panel covers the speaker), `h` (band height px, default 768), `gap` (eyes under the band, default 80), `pos` (object-position, default `50% 50%`), `zoom` ([from, to] slow push), `clicks` (recording seconds; default: the `clicks` list of `<src>.json` if it exists; `false` = none), `clickSfx` | click-1 per click |
    | `hook` | `title` (string or 1-2 lines), `icons` (one row, or two: `[[above], [below]]`), `iconSize` (150), `size` (title px, 62, shrinks to fit), `y` (top, default 250; moves up off the eyes) | pop (none at frame 0) |
    | `diagram` | `nodes: [{id, x, y, emoji\|icon\|src\|text, label, size, at, sfx}]` (centre px), `links: [{from, to, at, dur, bend, dot, width}]` (a line draws from `from` to land when `to` appears, unless timed), `bg`, `ink`, `sfx` (the whoosh in) | whoosh in, marker-scribble per line |
    | `step` | `n`, `title`, `icons`, `label` ("Step"; "Шаг" for Cyrillic), `size` (46), `iconSize` (88) | pop |
    | `cta` | `word`, `text` (default «Comment "{word}" for the prompt» / «Напиши "{word}" в комментариях»), `logo` (an icon), `size` | pop |
    | `aside` | `text` (asterisks added), `y`, `size` (66), `italic` | none |
    
    Icons everywhere: `{emoji | icon | src, label, size, bg (a tile colour), invert}` or a bare emoji slug string.
    
    What the build does for you: the person cut-out over every panel run (BiRefNet-portrait via scripts/matte.py for just those
    source seconds, cached in assets/talk-matte.webm; a second copy of the camera wrappers keeps it on the speaker through zooms,
    punch-ins and the speaker's move), the panel run's speaker move (from face.json and the camera zoom), the step/cta stack placed
    above the caption and pushed (with the captions) under the chin when the speaker sits low, top words kept off the eyes and
    moved to the chest while a panel covers the forehead, black diagram captions, a panel that stays up 0.2 s under the next
    one, one file per icon use (the same image twice trips hyperframes' duplicate-media lint). It warns when a label covers the
    chin, a hook card reaches the eyes, the eyes are too high for the band, or a recording is under 1080p.
    
    ## Pipeline (end to end)
    
    ```bash
    S=~/.claude/skills/ghost-editor; P=~/reels/<name>; HF="$S/scripts/hf.sh"   # the pinned HyperFrames (scripts/HF_VERSION)
    bash $S/scripts/prep.sh <IMG_xxxx.MOV> $P                                     # talk.mp4, voice at -16 LUFS
    python3 $S/scripts/transcribe.py $P/assets/talk.mp4 --out $P/build/words.whisper.json --lang ru
    python3 $S/scripts/face_track.py $P/assets/talk.mp4 --out $P/build/face.json   # required: the panel move and every label use it
    mkdir -p $P/rec && cp <screen recordings> $P/rec/                              # Cmd-Shift-5 recordings; 1080p+; note the click times
    # reel.json: takes, then beats from the transcript (start from example/reel.json); one panel per sentence that names
    # something on screen, a step label per "step N", the CTA on the comment line
    node $S/scripts/build.mjs $P                                                   # read the SFX table and every WARNING
    python3 $S/scripts/approval_sheet.py $P --open                                 # lint 0 errors + a frame per beat; WAIT for the user's yes
    $HF render -o build/reel.mp4 --quiet
    python3 $S/scripts/render_report.py $P build/reel.mp4 && python3 $S/scripts/qa.py $P build/reel.mp4
    ```
    (If plain `python3` has no numpy/opencv, run the Python steps with a venv that has them, e.g. `~/.venvs/media/bin/python`.)
    
    ## Rules (each one bit the smoke test or comes from the reference)
    
    - Captions are PHRASES that cut, not karaoke: no per-word highlight, no box, no punctuation, lowercase.
    - The screen goes BEHIND the head (what the reference does): the
      matte venv (`bash $S/scripts/setup_matte.sh`) is required; without it the build warns and the panels cover the speaker. Matting
      costs ~1.4 s per matted frame (BiRefNet-portrait, MPS): 11 min for 15 s of panels, cached after that;
      `"matte": {"stride": 2}` roughly halves it.
    - The speaker moves only when the eyes would hide under the band; never more than the band height minus 60 px. List
      back-to-back panels in time order (the later one is drawn on top).
    - Step and CTA labels go under the chin, above the caption; the build pushes both down when the face sits low and warns
      when even that covers the chin.
    - Diagram captions turn black by the group's midpoint (a word that starts while the white frame fades in was white on
      white in the first build).
    - Screen recordings of web pages: Google Chrome, not Playwright's Chromium (no H.264: every video tile recorded black).
    - Screen recordings can show private material (other people's work, a private gallery): check every recording before
      publishing a render.
    
    ## Worked example
    
    `example/reel.json` with `example/script.txt`: an English tutorial, "3 settings that make a notes app faster", cut from
    a ~66 s seated recording into five takes (33 s): the hook card, one diagram, four panels (two back to back), an
    aside, three step labels and the CTA, with `single`, `top`, `emphasis` and `strobe` captions and a punch-in close-up.
    Icons are Fluent emoji from library/emoji, so no logo files are needed. It is for reading and copying: the recording
    (`assets/talk.mp4` from prep.sh) and the screen recordings `rec/rec1.mp4`-`rec/rec3.mp4` are yours to supply.
    script.txt holds the lines each take assumes with their source seconds; re-time `takes`, `captions` and every beat
    `at`/`to` from your own transcript (`transcribe.py ... --lang en`). A dry run (test-pattern video, a tone for the
    voice, word times synthesised from script.txt, panels in front instead of behind) builds and lints with 0 errors; it has
    not been rendered with real footage.
    
  • recipes/step-deck/README.md3.1 KBaefa07b39eabupstream ↗
    # Step Deck
    
    A tips reel as a numbered deck over a talking head: every spoken word lands on its onset, sized by importance and set
    behind the speaker's head; between face shots the reel cuts every 1-2 s to flat full-screen cards (navy word cards,
    white word pages, a cream icon card, B&W paper prints of the line's objects, line drawings); a hook stack of the first
    three lines in three worlds; one step card per tip with a giant italic numeral that shrinks into place (navy,
    off-white, electric blue); a flat ending with at most one gradient word. From a reel by @ant.lon, replicated frame by
    frame.
    
    Read SYSTEM.md first (thesis, invariants, house look, slots and generators, planning procedure, changelog);
    house.json is the fixed look, catalog.json what each reel used.
    
    ## Calls
    
    - "Step Deck"
    - "like the ant.lon reel"
    - "steps reel"
    
    ## What it needs
    
    An approved cut with a list in it (2-5 steps or tips): the plates as shot (wide + tight best), a matte per plate
    (`scripts/matte.py` -> assets/<plate>-matte.webm, so the words hide behind the speaker's head), assets/voice.wav,
    build/words.cut.json (edit seconds), build/cover_windows.json. Pictures made per line: B&W object stills for one
    montage (`broll_gen.py`, no people), at most one metaphor clip (`broll_fetch.py`, 1080p or better), line drawings in
    SVG. Fonts, SFX and the bed are copied from the skill by the builder.
    
    ## Build
    
    A Python builder, `stepdeck.py` (class `Deck`; its docstring lists every call), reading the look from house.json.
    A reel is a short generator in the project that calls it. The public edition has no worked example for this recipe
    yet: write $P/tools/build.py (an argparse script taking --project) from the usage block in stepdeck.py's docstring, build/plan.txt and SYSTEM.md, then
    
    ```bash
    S=~/.claude/skills/ghost-editor; PY=~/.venvs/media/bin/python
    $PY $P/tools/build.py --project $P             # index.html, build/beats.json, build/coverage.txt
    bash $S/scripts/hf.sh lint $P                   # 0 errors
    bash $S/scripts/hf.sh snapshot $P --at <beat times> --no-end   # look at every beat on one sheet
    python3 $S/scripts/components.py check --style step-deck --project $P
    $PY $S/scripts/finals.py preview $P --out $P/finals --style "Step Deck" --code R01 --title "..."   # WAIT for the user's OK
    $PY $S/scripts/finals.py render $P --out $P/finals --style "Step Deck" --code R01 --title "..."    # only after the user's yes
    ```
    
    The calls: `face()` (the face, captions behind the head; push / fade / pushin / punch), `navy()`, `page()` (exit to
    white), `card_words()`, `montage()` + `make_prints()`, `disk()`, `title()`, `panel()`, `broll()`, `step()`,
    `push_out()`, `counter()`, `keyword()` (the gradient outro word), the motion helpers `pop_in()`, `jump()`, `rack()`,
    `box_grow()`, `blur_out()`, then `plates()`, `sfx()`, `build()`. Caption specs are strings: `"B T +T /ST Sf"`.
    
    ## Where things are
    
    - The reference: a "hook stacking" tutorial reel by @ant.lon (55 s), studied frame by frame; the study's element and
      transition labels (E1-E29, X1-X9) are kept in stepdeck.py, house.json and catalog.json as names for the devices.
    
  • recipes/swiss-grid/README.md3.6 KB3b3f21b97ac8upstream ↗
    # Swiss Grid
    
    International Typographic Style in motion around a talking head: the 9:16 frame is a modular page with 6 columns, one
    typeface (Inter) and one signal colour (red = the reel's one protagonist). The speaker's face, as shot, lives in one
    band of the page between a paper header (caption row + chapter counter) and a paper page where their words are set
    flush left, each word rising out of a clip rect on its spoken onset. Between face worlds the page wipes up into short
    poster cards: giant numeral chapter cards, a grid being built, a grid that means something. Exact, quiet motion: one
    precise ease and linear, no fades, knife cuts for deletions, and one exception (the protagonist) that leaves the grid.
    Ported from LemoLab's MIT-licensed Swiss Motion Graphics style (lemo-opuscar `styles/swiss-motion`); see CREDITS.txt.
    
    Read SYSTEM.md first (thesis, invariants, house look, slots and generators, planning procedure, changelog);
    house.json is the fixed look, catalog.json what each reel used.
    
    ## Calls
    
    - "Swiss Grid"
    - "Swiss style" / "Swiss motion"
    - "like a Swiss poster"
    
    ## What it needs
    
    The approved cut: the plates as shot (wide + tight on the same timeline is best; one works), assets/voice.wav,
    build/words.cut.json (edit seconds), and a face file per plate (`scripts/face_track.py <plate> --out
    build/face_<name>.json`). No matte and no stock: the header and page never touch the speaker's head box. A real picture
    only for a thing the speaker names (shown greyscale, at most ~3 a minute). Inter (OFL) and the SFX are copied from the
    skill by the builder; there is no music bed.
    
    ## Build
    
    A Python builder on `scripts/lib/facereel.py`: `swissgrid.py` (class `Grid`; its docstring lists every call and
    sketches an English reel), reading the look from house.json. A reel is a short generator in the project that calls it.
    The public edition has no worked example for this recipe yet: write `$P/tools/build.py` from the world list (SYSTEM.md
    planning procedure) and the docstring.
    
    ```bash
    S=~/.claude/skills/ghost-editor; PY=~/.venvs/media/bin/python
    $PY $S/scripts/face_track.py $P/assets/wide.mp4 --out $P/build/face_wide.json      # one per plate
    $PY $P/tools/build.py --project $P            # index.html, build/beats.json, plan.json, sfx_events.json, holds.txt
    bash $S/scripts/hf.sh lint $P                 # 0 errors
    bash $S/scripts/hf.sh snapshot $P -o $P/snaps --no-end --describe false --at <beat keys>   # look at every beat
    $PY $S/scripts/finals.py preview $P --out $P/finals --style "Swiss Grid" --code R01 --title "..."   # WAIT for the user's OK
    ```
    
    The calls: `face_world()` (the face + the page), `card()` (a full-screen poster card, <= 2.5 s), `text()` (the
    speaker's words on their onsets, or a label), `note_row()`, `counter()`, `numeral()`, `rule()`, `slab()`, `dot()`,
    `bar()`, `modules()`, `guides()`, `knife()` + `group()`, `minute_grid()`, `exception()`, `picture()`, `sfx()`, `build()`.
    
    The build fails on: a word the speaker did not say (word refs and phrases are matched to the transcript), a glyph Inter
    lacks, text under 48 px, any text box outside the safe area (y 120-1700, x <= 980), a page or header that touches the
    head box, a card over 2.5 s, the face on screen under 65 %, more than 3 inserts a minute, a gap between worlds.
    
    ## Where things are
    
    - Source: lemo-opuscar, styles/swiss-motion (STYLE.md, DEMO.md, demo/); the film was only watched (not part of the
      recipe).
    
    ## Credit
    
    Adapted from "Swiss Motion Graphics" in lemo-opuscar by LemoLab (https://github.com/lemomo-ai/lemo-opuscar), MIT,
    Copyright (c) 2026 LemoLab (LICENSE-lemo-opuscar.txt). The demo film, its music, voice and fonts are not copied.
    
  • recipes/tactile-paper/README.md2.8 KB8acf64b877ebupstream ↗
    # Tactile paper
    
    A talk told on printed paper: newspaper and archive pages that turn with a real page fold, stepped 8 fps motion like
    stop-motion, zoom-blur pushes, small hand-drawn labels that rise from a mask, paper foley; from @chrismoran__
    
    What it looks like: frame 0 is maroon paper with half the first line in a near-black grotesque and the object that
    finishes it already unfurling from a corner; a zoom-blur push on the next word; pages, prints and cards land on their
    nouns and turn with a WebGL page fold, all stepped on twos (the payoff on threes); white arrows and one crimson marker
    point; black condensed pill captions of 1-3 words; the paper turns away like a page to reveal the speaker's face (as
    shot) on the personal lines; the payoff replays the hook object on 8 fps and the reel ends flat on the face.
    
    Read SYSTEM.md first (thesis, invariants, house look, slots and generators, planning procedure, changelog);
    house.json is the fixed look, catalog.json what each reel used.
    
    ## Build
    
    - `tactile.py`: the builder (Tactile on scripts/lib/facereel.py; stdlib). Scenes (`paper_scene`, `face_scene`) take
      grounds, sheets (`sheet`, `unfurl`, `turn`, `slide`), marks (`underline`, `ellipse`), `label`, `title`, `rise`,
      `arrow`, `gobo`, `blur`, `reveal`; cameras (`push_camera`, `close_camera`, `camera`); `captions`, `sound`,
      `build`. Its docstring has the usage block.
    - `tactile.js`: the runtime inlined into index.html (the replica's page fold, brush, marker, gobo, captions + the
      scene loop); seek-safe.
    - `props.py`: paper props per reel (ground, essay_page, notebook_page, ticket, photo_print, paper, apply_ink,
      halftone); numpy + Pillow + OpenCV, so run generators with a python that has them (e.g. `~/.venvs/media/bin/python`).
    
    The public edition has no worked example for this recipe yet: write the reel's generator (an argparse script taking --project) from the usage block in
    tactile.py's docstring, SYSTEM.md (slots, planning procedure) and the catalog, then
    
        ~/.venvs/media/bin/python <generator> --project $P          # draws missing props, writes index.html + build/*.json
        $S/scripts/hf.sh lint $P                                    # 0 errors
        python3 $S/scripts/components.py check --style tactile-paper --project $P
        python3 $S/scripts/finals.py preview $P --style "Tactile paper" --code <CODE> --title "..."   # then WAIT for the user's OK
        python3 $S/scripts/finals.py render ...                     # only after the user's OK
    
    ## Where things are
    
    - The reference: a page-turn tutorial reel by @chrismoran__ (After Effects CC Page Turn + Posterize Time), studied
      frame by frame; its measured motion (unfurl, fold, gobo, arrow) lives in tactile.py (`REPLICA`, `REF_ARROW1`).
    
    ## Calls
    
    - "Tactile paper"
    - "like the @chrismoran__ page-turn reel"
    - "paper page turn"
    
  • recipes/telestrator/README.md3.5 KBc41dc28f1b7eupstream ↗
    # Telestrator
    
    A TV football-analysis segment over a talking head: the speaker's footage plays live, freezes on the word that carries
    a finding and gets drawn on (a ring under the hand, marker arrows, a red zone for the space around the speaker, one
    label card), always around the face, never on it; yellow slanted wipes cut to dark tactics boards where the object of
    the line (a phone, a cup, a book, a list) is played, frozen, rewound and drawn on; a studio packaging on every frame
    (corner bug with LIVE / ANALYSIS / REPLAY, a source clock, a matchup bar naming the reel's two sides, a subtitle bar).
    Ported from the MIT style "Sports Telestrator" of lemo-opuscar by LemoLab (https://github.com/lemomo-ai/lemo-opuscar,
    styles/telestrator).
    
    Read SYSTEM.md first (thesis, invariants, house look, slots and generators, planning procedure, changelog);
    house.json is the fixed look, catalog.json what each reel used. CREDITS.txt and LICENSE-lemo-opuscar.txt: the source.
    
    ## Calls
    
    - "Telestrator"
    - "like a football analysis show"
    - "freeze and draw"
    
    ## What it needs
    
    The cut as plates (assets/*.mp4, 1080x1920; wide + tight best), assets/voice.wav, build/words.cut.json (edit seconds),
    and a matte for each frozen frame only (`scripts/matte.py <plate> -o build/freeze/<plate>_fz-matte.webm --ranges ...`).
    A line with an object the boards can play (phone, app, list, book). A real picture only when the speaker names it (a
    cover). Fonts (Inter Tight, Oswald, JetBrains Mono: Cyrillic, OFL) and SFX are copied from the skill by the builder.
    The packaging words (show name, modes, the matchup's two sides) are in house.json `packaging`: set the matchup for
    each reel.
    
    ## Build
    
    A Python builder, `telestrator.py` (class `Show` + `Scene`; the docstring lists every call and sketches an English
    reel), reading the look from house.json. A reel is a short generator that calls it. The public edition has no worked
    example for this recipe yet: write the generator from the plan (SYSTEM.md planning procedure) and the docstring.
    
    ```bash
    S=~/.claude/skills/ghost-editor; PY=~/.venvs/media/bin/python
    mkdir -p $P/build/freeze
    ~/.venvs/ghost-matte/bin/python $S/scripts/matte.py $P/assets/alt.mp4 -o $P/build/freeze/alt_fz-matte.webm \
        --ranges 3.80-3.95,14.25-14.40,27.75-27.90 --pad 0.1          # only the frozen frames
    $PY $P/tools/build.py --project $P                                    # index.html, build/beats.json, build/coverage.txt
    bash $S/scripts/hf.sh lint $P                                         # 0 errors
    bash $S/scripts/hf.sh snapshot $P -o $P/build/snap --no-end --at <beat times>   # look at every beat
    $PY $S/scripts/finals.py preview $P --out $P/finals --style "Telestrator" --code R01 --title "..."   # WAIT for the user's OK
    ```
    
    Keep the generator's sys.path line pointing at the recipe (`sys.path.insert(0, "<skill>/recipes/telestrator")`),
    write the segments from the plan in its docstring, and measure each freeze frame's face box on a full-res still.
    
    The calls: `mode()`, `clock()`, `wipe()`, `flip()`, `subs()`, `sfx()`; scenes `live_scene()`, `freeze()`, `board()`,
    `split()` with the drawing grammar `ring()`, `marker()` (solid / dashed), `zone()`, `spot()`, `label()`, `stamp()`,
    `chalk()`, `html()`; then `close()` each scene and `build()`.
    
    ## Where things are
    
    - Source: lemo-opuscar, styles/telestrator (STYLE.md, DEMO.md, demo/); the film was only watched (not part of the
      recipe).
    
    Credit: style grammar and drawing rules adapted from "Sports Telestrator", lemo-opuscar by LemoLab, MIT licence.
    
  • recipes/whiteboard/README.md8.0 KB6642fde35f83upstream ↗
    # Whiteboard: a marker board draws each thought over the speaker's talking head
    
    Call it with: **"Whiteboard"**, **"edit this as a whiteboard"**, **"a marker board edit"**.
    
    A split screen: a white marker board on the top half, the speaker's face on the bottom half, as shot. Each sentence is
    drawn live in rough marker strokes, and a visible marker follows every stroke and every handwritten word. An eraser
    wipes between pages. White pill captions sit on the seam with the spoken word swept in yellow.
    
    **When to use:** a talking head that explains one idea per sentence: psychology, advice, how something works, a
    paradox. 25-60 s. Not for a list of places (Seoul list) or a tool tutorial with screen recordings (stan style).
    **Read SYSTEM.md before planning a reel**: what stays, what must be new.
    
    ## Footage
    - The talking head only; no B-roll (0 inserts). The **wide plate** works best: the face is scaled up to x1.15 into the
      bottom half. A plate where the face cannot fit under the seam fails the build ("use the wide plate").
    - Look-aways that must be hidden (`build/cover_windows.json` from `cover_windows.py`, or `cover=[...]`) get the board
      full screen, <= 2.5 s each. Small glances stay (references/broll.md 1).
    
    ## Anatomy
    
    | part | look | timing |
    |---|---|---|
    | hook | the face full screen, the first words in a white pill under it | frame 1 until the board drops on the 2nd word (`split_at=` to change) |
    | the drop | the board falls over the top half (0-960, 0.42 s, power3.inOut); the face slides down and scales (pivot and scale measured from face.json, the whole face under the seam) | once |
    | strokes | seeded rough lines, rects, ellipses, arrows, figures (board.py helpers), 6-9 px, ink / blue / red / green / orange | each draws on over 0.2-1 s, on the word that names it |
    | the marker | a white dry-erase marker, its cap in the stroke colour, the nib on the line being drawn; glides between close strokes, lifts off the board when idle | follows every stroke and word (points sampled at build time, no DOM measurement) |
    | handwriting | Caveat 700, revealed left to right as the marker writes it | on its spoken word |
    | pages | one per thought; an eraser sweeps left to right before the next | the next page starts 0.26 s after the wipe |
    | captions | white Inter pills on the seam (y 914), up to 3 words, each word swept yellow as it is said | words outside the hook and full-board windows |
    | full board | the board grows to full screen, the drawing moves to its centre (unscaled, so nothing near the edges is cut) | only over a look-away, <= 2.5 s |
    | sound | a quiet bed (-22 dB, ducked under speech), marker scribbles as texture (>= 1.6 s apart), an eraser whoosh per page, a whoosh on the drop | |
    
    ## Pipeline
    
    ```bash
    S=<skill>; P=<project>
    # the raw cut (references/take-selection.md): $P/assets/plate.mp4 (the WIDE plate, video only, as shot),
    # $P/assets/voice.wav, $P/build/words.json (words of the cut, edit seconds)
    python3 $S/scripts/face_track.py $P/assets/plate.mp4 --out $P/build/face.json     # on the plate: its seconds are edit seconds
    python3 $S/scripts/components.py plan --style whiteboard                          # what the last reels drew: avoid it
    # write $P/reel.py (below): the pages for this script
    python3 $P/reel.py $P              # -> index.html, build/{plan,beats,sfx_events}.json; FAILS on a broken rule (below)
    $S/scripts/hf.sh lint              # in $P: 0 errors (the file-size warning is fine)
    python3 $S/recipes/seoul-list/snap.py beats $P      # one strip per page -> build/snaps/: look at every page
    python3 $S/scripts/finals.py preview $P --out $P/finals --style "Whiteboard" --code W01 --title "..."   # WAIT for the user's OK
    python3 $S/scripts/finals.py render $P ... ; python3 $S/scripts/finals.py qa $P ...
    python3 $S/scripts/components.py record --style whiteboard --project $P --reel W01     # after the user's yes
    ```
    
    ## reel.py (a generator per reel, keyed to words)
    
    ```python
    import sys; sys.path.insert(0, "<skill>/recipes/whiteboard")
    from board import *
    B = Board(sys.argv[1], music={"id": "forest-mist-whispers", "db": -22}, cover=None, split_at=None)
    t = B.t                                 # word refs: "word", "word#2", "^word" (its end), "word+0.1", "two words", a number
    B.page(t("relationship") - 0.2)         # a new page; the previous one is erased 0.26 s before
    B.draw(stick(230, 380, 1.5), t("there"), INK, 8, shape="stick")     # paths draw on from the time; shape = catalog name
    B.write("you", 230, 700, t("you"), 88, INK, "middle")              # Caveat, the marker writes it
    B.draw(link(520, 380, 1.4), t("relationship"), RED, 8, shape="link")
    B.build()                               # prints the timeline, the numbers and components.py check
    ```
    - Board coordinates: 1080 x 960; keep everything above y 900 (the seam pills cover the bottom; the build fails below).
    - Helpers (each returns a list of path strings): `rline rrect rellipse poly arrow stick runner crown check cross phone
      phone_apps envelope clock bulb bubble shield cloud underline heart crack bell book bed zz mountain pair link wrench key
      plane wheel house day`. Pick shapes the last reels did not draw, or add a helper.
    - `draw(..., snd=False)` for small follow-up marks; `write(..., snd=True)` for a written word that should be heard.
    - Colours: `INK BLUE RED GREEN GOLD ORANGE`.
    
    ## The build refuses (fix the generator, never the check)
    - a look-away in the cover windows not hidden by a full board, or a full board longer than 2.5 s;
    - the face over the seam in split mode (the scale is measured; pass `scale=` lower only if needed);
    - a stroke or a word below y 900 (under the seam captions);
    - the face on screen under 65 % (full boards add up).
    
    ## Checks that caught real problems
    - A CSS `filter: contrast() saturate()` on the speaker's video is a colour change on the face: the plate has no filter,
      and broll_qa `as_shot` fails one.
    - `getPointAtLength()` inside a timeline callback is seek-order dependent in the renderer (hyperframes lint
      gsap_callback_dom_measurement): the marker follows points sampled from each path at build time.
    - A label under the seam pill is unreadable: the build fails any stroke or word below y 900.
    - A scribble sound on every stroke was 29 sounds in 30 s: scribbles are texture, >= 1.6 s apart, 4 dB lower.
    
    ## Worked example
    
    `example/` holds an English talking head, "willpower is a battery" (7 thoughts, 91 words, about 38 s), with
    `script.txt`: small choices drain willpower like a battery, so decide the small things once. `reel.py` draws one page
    per thought, keyed to the spoken words: a battery that charges four green cells; the same battery drained cell by cell
    while a T-shirt, a bowl and a TV are drawn on "wear", "eat", "watch"; a crescent moon over a battery with one red cell;
    a tired brain at a fork in the road, a red dotted route down the easy branch with a stop per temptation and a sad face
    where it ends; a balance tipping from "more discipline" (struck out) to "fewer choices"; a week as a timeline with one
    arrow per habit; a target hit by an arrow and a full battery. Its drawings are helpers in reel.py (`battery charge
    slash shirt bowl tv moon sparkle brain fork dotted frown stand balance timeline target`), plus board.py's arrow, check,
    underline, zz and runner. The one look-away (on "wear ... eat") gets the board full screen; when
    `build/cover_windows.json` exists, its windows are used instead. Bed: `digital-clouds` at -22 dB. It is for reading
    and copying: the recording is yours to supply. Put the cut in `$P`, transcribe it with `--lang en` into
    `build/words.json`, run face_track.py on the plate, then `python3 $S/recipes/whiteboard/example/reel.py $P` (or copy it
    to `$P/reel.py` with its `sys.path` line pointing at `$S/recipes/whiteboard`), and fix any word key the build stops on
    (`fixes=` corrects a misheard word: whisper heard "drains" as "trains"). A dry run (a synthetic voice, a stand-in wide
    plate, the look-away keyed to the words) builds with 7 pages, 139 strokes, split at 0.06 s, the face x1.15 under the
    seam and on screen 95.3 %, one full board of 1.82 s, and lints with 0 errors; it has not been rendered with real footage.
    
  • scripts/allframes_qa.py17 KB8324eab9abe7upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/approval_sheet.py45 KB69279d1f0095upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/audition.py3.1 KB97a1d8c895cfupstream ↗
    #!/usr/bin/env python3
    """Write library/audition.html: a soundboard of every SFX (with its role,
    tags, source and licence) and every meme (preview + playable clip), so a
    human can listen and look before a sound or meme goes into a reel.
    
        audition.py [--open]
    
    Automated checks cannot tell a good vine boom from a bad rip; ears can.
    Sounds flagged in manifest.json with "review" show a badge.
    """
    import argparse
    import html
    import json
    import os
    import subprocess
    
    HERE = os.path.dirname(os.path.abspath(__file__))
    LIB = os.path.abspath(os.path.join(HERE, "..", "library"))
    
    
    def main():
        ap = argparse.ArgumentParser()
        ap.add_argument("--open", action="store_true")
        a = ap.parse_args()
        sfx = json.load(open(os.path.join(LIB, "sfx", "manifest.json")))
        rows = []
        for role in ("meme", "impact", "whoosh", "ui"):
            for k, v in sfx.items():
                if v["role"] != role:
                    continue
                flag = f'<span class="flag">{html.escape(v["review"])}</span>' if v.get("review") else ""
                rows.append(f'<tr><td><b>{k}</b>{flag}</td><td>{role}</td><td><audio controls preload="none" src="sfx/{v["file"]}"></audio></td>'
                            f'<td>{v["duration"]:.2f}s</td><td>{", ".join(v["tags"])}</td><td class="src">{html.escape(v["source"])}<br><i>{html.escape(v["licence"])}</i></td></tr>')
        cards = []
        mdir = os.path.join(LIB, "memes")
        for d in sorted(os.listdir(mdir)):
            p = os.path.join(mdir, d, "meta.json")
            if not os.path.exists(p):
                continue
            m = json.load(open(p))
            media = f'<video controls preload="none" poster="memes/{d}/preview.png" src="memes/{d}/{m["clip"]}"></video>' if m.get("clip") else f'<img src="memes/{d}/{m["image"]}">'
            cards.append(f'<div class="card">{media}<div><b>{html.escape(m["name"])}</b> <code>{d}</code> <span class="t {m["trend_status"]}">{m["trend_status"]}</span></div>'
                         f'<div>{", ".join(m["emotion"])}</div><div class="u">{html.escape(m["use_case"])}</div></div>')
        page = f"""<!doctype html><meta charset="utf-8"><title>ghost-editor library</title>
    <style>body{{font:14px system-ui;margin:24px;background:#111;color:#eee}}table{{border-collapse:collapse;width:100%}}td{{border-bottom:1px solid #333;padding:6px 8px;vertical-align:middle}}
    .src{{color:#999;font-size:12px}}.flag{{background:#b33;color:#fff;border-radius:6px;padding:1px 6px;margin-left:6px;font-size:11px}}
    .grid{{display:grid;grid-template-columns:repeat(auto-fill,minmax(220px,1fr));gap:16px}}.card{{background:#1c1c1f;border-radius:12px;padding:10px}}
    .card video,.card img{{width:100%;border-radius:8px;background:repeating-conic-gradient(#444 0 25%,#666 0 50%) 0/20px 20px}}
    .u{{color:#aaa;font-size:12px}}.t{{font-size:11px;padding:1px 6px;border-radius:6px;background:#333}}.hot{{background:#c2410c}}.dying{{background:#555}}</style>
    <h1>Sound effects ({len(sfx)})</h1><table>{''.join(rows)}</table><h1>Memes ({len(cards)})</h1><div class="grid">{''.join(cards)}</div>"""
        out = os.path.join(LIB, "audition.html")
        open(out, "w").write(page)
        print(out)
        if a.open:
            subprocess.run(["open", out])
    
    
    if __name__ == "__main__":
        main()
    
  • scripts/autocut.py3.8 KBd165b2d1e98aupstream ↗
    #!/usr/bin/env python3
    """Tighten a single clean take: cut the pauses, keep every word.
    
        autocut.py <project>/assets/talk.mp4 [--noise -35] [--min 0.28] [--keep 0.10] [--from 0] [--to END] [--vad]
    
    For a recording that is already one good take (no retakes to choose), the
    edit is mostly pause removal. Whisper stretches words over the pauses, so the
    pauses come from the AUDIO: silencedetect at --noise dB, silences longer than
    --min seconds are removed except --keep seconds on each side (the breath that
    keeps it natural). Prints a "takes" array for reel.json and the new length.
    
    --vad finds the pauses with silero-vad (scripts/vad_pauses.py, optional venv from scripts/setup_audioqa.sh) instead of a
    dB threshold: noise above the threshold (crickets, wind, traffic) no longer glues the recording into one island, and a
    soft first word is not clipped. --min is then the shortest pause that gets cut (0.35 recommended), --keep the lead/tail.
    """
    import os
    import argparse
    import json
    import re
    import subprocess
    
    
    def main():
        ap = argparse.ArgumentParser()
        ap.add_argument("src")
        ap.add_argument("--noise", type=float, default=-35)
        ap.add_argument("--min", type=float, default=0.28)
        ap.add_argument("--keep", type=float, default=0.10)
        ap.add_argument("--from", dest="t0", type=float, default=0.0)
        ap.add_argument("--to", dest="t1", type=float, default=None)
        ap.add_argument("--vad", action="store_true", help="speech islands from silero-vad (noise-robust) instead of silencedetect --noise")
        a = ap.parse_args()
        if a.vad:
            here = os.path.dirname(os.path.abspath(__file__))
            py = os.path.join(os.environ.get("AUDIOQA_VENV", os.path.expanduser("~/.venvs/ghost-audioqa")), "bin", "python")
            if not os.path.exists(py):
                raise SystemExit(f"--vad needs the audio QA venv: bash {os.path.join(here, 'setup_audioqa.sh')}")
            cmd = [py, os.path.join(here, "vad_pauses.py"), a.src, "--min-pause", str(a.min), "--lead", str(a.keep), "--tail", str(a.keep)]
            if a.t0:
                cmd += ["--ss", str(a.t0)]
            if a.t1:
                cmd += ["--t", str(a.t1 - a.t0)]
            res = json.loads(subprocess.run(cmd, capture_output=True, text=True, check=True).stdout)
            takes = [{"a": round(t["a"], 2), "b": round(t["b"], 2)} for t in res["takes"]]
            kept = sum(t["b"] - t["a"] for t in takes)
            print(json.dumps(takes))
            print(f"\n{len(takes)} takes (silero-vad), {kept:.2f}s kept of {res.get('duration', kept):.2f}s")
            return
        dur = float(subprocess.run(["ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "csv=p=0", a.src],
                                   capture_output=True, text=True).stdout)
        t1 = a.t1 or dur
        err = subprocess.run(["ffmpeg", "-hide_banner", "-nostats", "-i", a.src, "-af", f"silencedetect=noise={a.noise}dB:d={a.min}",
                              "-f", "null", "-"], capture_output=True, text=True).stderr
        starts = [float(x) for x in re.findall(r"silence_start: ([\d.]+)", err)]
        ends = [float(x) for x in re.findall(r"silence_end: ([\d.]+)", err)]
        sil = list(zip(starts, ends + [dur] * (len(starts) - len(ends))))
        takes, cur = [], a.t0
        for s, e in sil:
            if e <= a.t0 or s >= t1:
                continue
            if s <= a.t0:  # leading silence
                cur = max(cur, e - a.keep)
                continue
            takes.append({"a": round(cur, 2), "b": round(min(s + a.keep, t1), 2)})
            cur = e - a.keep
        if cur < t1 - 0.05:
            takes.append({"a": round(cur, 2), "b": round(t1, 2)})
        takes = [t for t in takes if t["b"] - t["a"] > 0.15]
        kept = sum(t["b"] - t["a"] for t in takes)
        print(json.dumps(takes))
        print(f"\n{len(takes)} takes, {kept:.2f}s kept of {t1 - a.t0:.2f}s ({t1 - a.t0 - kept:.2f}s of pauses removed)")
    
    
    if __name__ == "__main__":
        main()
    
  • scripts/brand_kit.py33 KB6a2b700674ceupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/broll_fetch.py13 KB4b68131d9f05upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/broll_gen.py1.8 KBd8f3bfb17060upstream ↗
    #!/usr/bin/env python3
    """Generate a still B-roll image with Gemini (vertical 9:16 by default).
    
        broll_gen.py "<prompt>" <out.png> [--aspect 9:16] [--model gemini-2.5-flash-image]
    
    Needs GEMINI_API_KEY in the environment (or in <skill>/.env, gitignored);
    the key is never printed. Needs google-genai (pip install google-genai).
    Look at the image before using it: AI images get hands, text and logos wrong.
    """
    import argparse
    import os
    import sys
    
    FALLBACK = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", ".env")
    
    
    def key():
        k = os.environ.get("GEMINI_API_KEY")
        if not k and os.path.exists(FALLBACK):
            for line in open(FALLBACK):
                if line.startswith("GEMINI_API_KEY="):
                    k = line.split("=", 1)[1].strip().strip('"')
        if not k:
            sys.exit("GEMINI_API_KEY not set")
        return k
    
    
    def main():
        ap = argparse.ArgumentParser()
        ap.add_argument("prompt")
        ap.add_argument("out")
        ap.add_argument("--aspect", default="9:16")
        ap.add_argument("--model", default="gemini-2.5-flash-image")
        a = ap.parse_args()
        from google import genai
        from google.genai import types
        client = genai.Client(api_key=key())
        cfg = types.GenerateContentConfig(response_modalities=["IMAGE"], image_config=types.ImageConfig(aspect_ratio=a.aspect))
        resp = client.models.generate_content(model=a.model, contents=a.prompt, config=cfg)
        for part in resp.candidates[0].content.parts:
            if getattr(part, "inline_data", None) and part.inline_data.data:
                open(a.out, "wb").write(part.inline_data.data)
                print(f"-> {a.out} ({len(part.inline_data.data) // 1024} KB, {a.model}, {a.aspect})")
                return
        sys.exit("no image in the response: " + str(resp)[:400])
    
    
    if __name__ == "__main__":
        main()
    
  • scripts/broll_qa.py82 KB72a74edae216upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/broll_vision.py22 KB10a7f710c034upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/build.mjs82 KB48f6c3cd5939upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/cc0_pack.py7.6 KBdd2a60d68a60upstream ↗
    #!/usr/bin/env python3
    """The CC0 meme-sound pack: reaction sounds from Freesound that the uploader recorded or made
    themselves and released as CC0 1.0 (public domain: commercial use, no credit, redistribution OK).
    Unlike the Mixkit kit (fetched at setup, never shipped) and the YouTube rips (private only),
    these files ship in the repo as library/sfx/cc0-<id>.wav.
    
        cc0_pack.py list                 # the pack, with sources
        cc0_pack.py build [--only a,b]   # download the HQ previews, trim, peak-normalize, merge manifest.json
    
    Every entry was checked by hand on 2026-10-29: the sound page shows "Creative Commons 0" and the
    description says the uploader recorded or synthesized it (no rips of the famous meme audio).
    Re-check the page before adding a new one, and listen on the audition page before using it.
    """
    import argparse
    import datetime
    import json
    import os
    import re
    import subprocess
    import tempfile
    import urllib.request
    
    HERE = os.path.dirname(os.path.abspath(__file__))
    SFX = os.path.abspath(os.path.join(HERE, "..", "library", "sfx"))
    PREVIEW = "https://cdn.freesound.org/previews/{a}/{id}_{uid}-hq.mp3"
    
    # id, freesound id, uploader, uploader id, title, role, tags, max seconds, fade-out seconds, what it is
    PACK = [
        ("deep-boom", 539968, "Za-Games", 12029332, "Deep Boom", "meme", ["punchline", "claim", "reveal", "sus"], 2.5, 0.6, "deep explosion boom"),
        ("vinyl-scratch", 71853, "ludvique", 1062668, "record_scratch.wav", "meme", ["wait", "freeze-frame", "twist"], 0.6, 0.05, "cartridge scratched over a vinyl record"),
        ("error-beep", 478191, "JonnyRuss01", 10233023, "Beep_Error_1.wav", "meme", ["wrong", "myth", "fail"], 0.5, 0.05, "soft error beep made from a metal bowl"),
        ("metal-clang", 125404, "jasonLON", 2279655, "Metallic Clang.aif", "meme", ["fail", "sudden", "absurd"], 1.8, 0.4, "baking pan hit with a bass-drum mallet, layered"),
        ("violin-sad", 234311, "andyssoundbox", 4232887, "Hearts and Flowers.wav", "meme", ["sad", "pity"], 5.5, 0.8, "Hearts and Flowers (1893, public domain) played on violin"),
        ("dark-sting", 578577, "nomiqbomi", 10522382, "Dark Crescendo 3", "meme", ["reveal", "twist", "drama"], 3.6, 0.5, "dark orchestral crescendo, made in Logic"),
        ("piano-sting", 183500, "ecfike", 2337290, "Piano Cord.wav", "meme", ["drama", "mystery", "reveal"], 1.75, 0.4, "minor piano chord hit"),
        ("group-ooh", 870650, "CHallSmith", 18412227, "Group Ooh 1", "meme", ["burn", "spicy", "shock"], 2.8, 0.3, "loop group's synchronized ooh"),
        ("gong-hit", 436486, "rabban625", 2988281, "gong-013.wav", "meme", ["punchline", "stop", "verdict"], 2.9, 0.8, "live orchestral gong"),
        ("cricket-chirp", 822935, "_sinny_", 14007850, "cricket chirping (slow)", "meme", ["awkward", "silence"], 2.8, 0.3, "a cricket, field recording"),
        ("air-horn", 414208, "jacksonacademyashmore", 6938106, "Airhorn", "meme", ["hype", "win"], 1.6, 0.15, "air horn made in Audacity"),
        ("huh-voice", 150505, "davdud101", 1883289, "Huh? - Vocal", "meme", ["confused", "disbelief"], 0.9, 0.05, "young male voice: huh?"),
        ("wow-voice", 167355, "willy_ineedthatapp_com", 3062051, "wow.mp3", "meme", ["impressive", "flex"], 1.6, 0.1, "wow in a high voice"),
        ("bike-honk", 188039, "AntumDeluge", 3403708, "Bicycle Horn", "meme", ["absurd", "dumb", "bad-joke"], 0.7, 0.05, "child's plastic bicycle horn"),
        ("whip-crack", 529925, "SciFiSounds", 11751070, "Whip Crack.m4a", "meme", ["roast", "savage", "fast"], 0.6, 0.05, "whip crack"),
        ("tada", 397355, "plasterbrain", 4284968, "Tada Fanfare A", "meme", ["win", "done", "reveal"], 1.75, 0.3, "brass tada in A major"),
        ("glass-break", 141563, "avrahamy", 1422573, "Glass Break", "meme", ["fail", "broke", "shatter"], 1.9, 0.3, "a glass window breaking"),
        ("cartoon-zip", 541507, "se2001", 8472935, "Cartoon Quick Zip 02", "meme", ["fast", "exit", "gone"], 0.3, 0.03, "mouth-made cartoon zip"),
        ("riser-short", 685256, "syntheffects", 12265588, "Riser sound effect short.wav", "riser", ["build-up", "suspense"], 3.05, 0.03, "noise riser"),
        ("oof-voice", 719053, "unfa", 1038806, "Oof (original)", "meme", ["fail", "pain", "ouch"], 0.35, 0.03, "an original oof, recorded by the uploader"),
        ("oh-no-voice", 801386, "Sadiquecat", 5287430, "Fear - ohno ohno ohno", "meme", ["mistake", "dread"], 1.7, 0.1, "male voice actor: oh no oh no oh no"),
        ("glitch-hit", 673773, "h0p1r4e7o", 10282604, "Glitch SFX - 1 sek.wav", "impact", ["error", "tech", "glitch"], 0.9, 0.05, "digital glitch"),
    ]
    
    
    def sh(cmd):
        return subprocess.run(cmd, capture_output=True, text=True, check=True)
    
    
    def normalize(src, dst, max_s, fade):
        # trim silence at both ends, cap length, fade out, 48 kHz stereo, peak -1 dBFS (same house format as sfx_fetch.py)
        trim = ("silenceremove=start_periods=1:start_threshold=-45dB:start_silence=0.01,"
                "areverse,silenceremove=start_periods=1:start_threshold=-50dB:start_silence=0.02,areverse,"
                f"atrim=0:{max_s}")
        tmp = dst + ".tmp.wav"
        sh(["ffmpeg", "-v", "error", "-y", "-i", src, "-af", trim, "-ar", "48000", "-ac", "2", tmp])
        dur = float(sh(["ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "csv=p=0", tmp]).stdout)
        fade = min(fade, dur / 2)
        peak = float(re.search(r"max_volume: (-?[\d.]+) dB", sh(
            ["ffmpeg", "-hide_banner", "-nostats", "-i", tmp, "-af", "volumedetect", "-f", "null", "-"]).stderr).group(1))
        sh(["ffmpeg", "-v", "error", "-y", "-i", tmp, "-af", f"afade=t=out:st={dur - fade:.3f}:d={fade:.3f},volume={-1.0 - peak:.2f}dB",
            "-ar", "48000", "-c:a", "pcm_s16le", dst])
        os.remove(tmp)
        return round(dur, 3)
    
    
    def build(only):
        man_p = os.path.join(SFX, "manifest.json")
        man = json.load(open(man_p))
        today = datetime.date.today().isoformat()
        for sid, fid, user, uid, title, role, tags, max_s, fade, what in PACK:
            if only and sid not in only:
                continue
            url = PREVIEW.format(a=fid // 1000, id=fid, uid=uid)
            with tempfile.TemporaryDirectory() as td:
                src = os.path.join(td, "in.mp3")
                req = urllib.request.Request(url, headers={"User-Agent": "ghost-editor cc0_pack"})
                open(src, "wb").write(urllib.request.urlopen(req, timeout=60).read())
                dur = normalize(src, os.path.join(SFX, f"cc0-{sid}.wav"), max_s, fade)
            man[sid] = {"file": f"cc0-{sid}.wav", "role": role, "tags": tags, "duration": dur, "peak_db": -1.0,
                        "source": f"https://freesound.org/people/{user}/sounds/{fid}/ \"{title}\" by {user} (HQ preview, cdn.freesound.org/previews)",
                        "licence": "CC0 1.0 public domain (Freesound; commercial OK, no credit, redistribution OK)",
                        "licence_url": "https://creativecommons.org/publicdomain/zero/1.0/", "licensed": True,
                        "freesound_id": str(fid), "what": what,
                        "edit": f"silence trimmed, max {max_s} s, {fade} s fade-out, 48 kHz stereo, peak -1 dBFS",
                        "added": man.get(sid, {}).get("added", today), "pack": "cc0",
                        "licence_checked": "2026-10-29 (sound page shows Creative Commons 0; uploader's own recording or synth)"}
            print(f"  {sid:15} {dur:5.2f} s  {role:6}  freesound {fid} by {user}")
        json.dump(man, open(man_p, "w"), indent=2, ensure_ascii=False)
        open(man_p, "a").write("\n")
    
    
    def main():
        ap = argparse.ArgumentParser()
        ap.add_argument("cmd", choices=["list", "build"])
        ap.add_argument("--only", default="")
        a = ap.parse_args()
        if a.cmd == "list":
            for p in PACK:
                print(f"{p[0]:15} {p[5]:6} {','.join(p[6]):28} freesound.org/s/{p[1]}  {p[9]}")
        else:
            build(set(filter(None, a.only.split(","))))
    
    
    if __name__ == "__main__":
        main()
    
  • scripts/components.py8.6 KBec0ded17de00upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/cover_windows.py3.7 KBf65153ffdf46upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/cutout_fx.py84 KBcb9c9a67413bupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/denoise.sh1.4 KB4bf7d4f79c07upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/doctor.sh10 KB65e47284e000upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/emoji_fetch.py10 KBd00c9814ac6cupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/eyestrip.py3.2 KB80670d9ede03upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/face_track.py3.4 KBe7d605996f65upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/facescan.py6.8 KB7e7fe4be7b9aupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/film_look.py13 KBe374219be896upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/finals.py34 KBd9bb358c2785upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/font_metrics.py2.4 KB65e08b20c18aupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/framecheck.py8.1 KB68a0411f2456upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/gem_audit.py8.5 KB6e260f9fe8cdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/gen_luts.py8.5 KB7e9de5b1cb86upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/google_images.py7.6 KBbe3a705b1e88upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/grade_lib.py18 KB9bfd5fab2012upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/headangle.py1.9 KB23fd74d9bc5fupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/headmotion.py3.1 KB596cfdddee6fupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/headpose.py2.3 KB60849f4344aeupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/hf.sh556 B7e8227695909upstream ↗
    #!/usr/bin/env bash
    # The pinned HyperFrames CLI: `$S/scripts/hf.sh render -o build/reel.mp4` = npx -y hyperframes@<scripts/HF_VERSION> ...
    # An HF_VERSION environment variable overrides the file for a one-off test (doctor.sh warns while it is set).
    # HyperFrames runs ffmpeg through hf_ffmpeg.sh, which fixes the audio mix's input order (why: hf_mix_order.py).
    v="${HF_VERSION:-$(cat "$(dirname "$0")/HF_VERSION")}"
    export HYPERFRAMES_FFMPEG_PATH="${HYPERFRAMES_FFMPEG_PATH:-$(cd "$(dirname "$0")" && pwd)/hf_ffmpeg.sh}"
    exec npx -y "hyperframes@$v" "$@"
    
  • scripts/hf_ffmpeg.sh1.3 KB29f76e10cd0fupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/hf_mix_order.py2.4 KB9f4a1e327fbcupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/hf_mix_pcm.sh1.3 KBc82b95dcc05bupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/HF_VERSION8 Bbdc84b0c9177upstream ↗
    0.8.159
    
  • scripts/hf_version.py1.1 KB61b7cc54d3dfupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/house_look.py8.7 KBdd7e65d276fbupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/image_pick.py18 KB883c52152173upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/image_sources.py5.3 KBc25d36e902d3upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/insert_prep.py15 KB96218c3a433aupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/islands_tx.py2.9 KB50ecebe23948upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/lib/ai-tag.mjs4.5 KB3b644bf7a986upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/lib/caption-templates.mjs36 KB02fc0b558f3aupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/lib/emoji-pop.mjs4.8 KB68a88cd162afupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/lib/facereel.py33 KB10790f5efc7cupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/lib/kinetic.mjs40 KB716d931d3319upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/lib/metrics.json101 KBdf44b19508d9upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/lib/motion.mjs35 KBccf86af7f432upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/lib/reelproj.py18 KBc2e700b3a35eupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/lib/safezone.mjs8.0 KB8bc40181cd34upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/lib/shader-layer.mjs9.5 KB8221c649bd21upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/lib/stan.mjs30 KB9a3aff7c2c3bupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/lib/taste.mjs14 KB517ef9e3a3e6upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/library_restore.py4.7 KB3239031e72a7upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/matte-requirements.txt396 Bb8606b7a9860upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/matte.py32 KB26caf6cd802eupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/meme_add.py9.5 KB4e64f6142e6cupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/meme_find.py3.0 KB0ae00cf3ae17upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/ocr_text.js1.9 KB2698e8783513upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/open_pause.py14 KBfbbc5832e9b9upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/own_footage.py19 KBa47bd2cd62c8upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/plan_cut.py19 KBe2f435f0d328upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/prep.sh3.6 KBd250d14bc36fupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/qa.py16 KB6676f3ffeba2upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/qa_cut.py4.9 KB7a03d24cb891upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/rawcut_prep.sh3.9 KBb8ce20b818a1upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/reel_usage.py3.1 KBfb800d2f9372upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/reference_study.py4.1 KB7befb5d3d69fupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/render_report.py40 KB1137f3535e0bupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/save_style.py17 KBb9467bacb63eupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/setup_audioqa.sh1.6 KB498cc7f631e2upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/setup_captions.sh730 Bd36a687fdc52upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/setup_looks.sh990 B0377dbe65591upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/setup_matte.sh1.4 KB36cadc809c2fupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/sfx_fetch.py15 KB88c04b556dfbupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/subcheck.py4.3 KB1cefe32b494dupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/takes.py8.7 KBb08b31f8f690upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/taste.py12 KB51b5ab0b4d6fupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/toolchain.py10 KB3542bc5cf845upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/transcribe.py6.7 KB86aca8f0f8f5upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/transitions.py45 KB4c9238a6e7afupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/trends.py3.0 KB49fa775d056aupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/tts_elevenlabs.py3.7 KB9c6e662a0dcfupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/vad_pauses.py7.8 KBf7c7b84f1aa2upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/venvs/media.txt1.2 KB6bfb8a0c78e1upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/venvs/mlxw.txt806 B215ef011b70bupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/voice_enhance.py11 KB955221df7705upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/voice_smooth.py6.2 KBdfe359c79e67upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/wikimedia_fetch.py12 KB1832f143be1eupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/x264.py1.2 KB19446fe0d952upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • scripts/X264_THREADS3 B48082f72f087upstream ↗
    12
    
  • references/broll.md25 KBaaad5bf4f581upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • references/cutout-fx.md14 KB1d3b17262762upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • references/reel-json.md30 KB14173c8a71b8upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • references/reference-study-prompt.md2.1 KB4f86b6f2b1bbupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • references/sound-and-memes.md5.2 KB7e3c476826deupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • references/styles.md12 KB61afb1a411b1upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • references/take-selection.md11 KBb12fd4562282upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • references/UPSTREAM-LICENSE1.0 KBab1336eb93c7upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • .gitignore1.2 KB29cc62b3bdb7upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • .public-edition57 B12aea9fc69e7upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docs/HOW-IT-WORKS.md5.0 KB71ae6c549772upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docs/img/vector-explainer.jpg55 KBe1bb6333d77eupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docs/INSTALL.md4.3 KBb3d71b3ee8ffupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docs/media/effects-grid.gif3.6 MB38b0a8edf812upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docs/media/pipeline.svg37 KBb1c1de2b1320upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docs/media/raw-to-ready.gif5.1 MBced847b5cb8aupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docs/media/styles-grid.gif6.4 MB7d589e50286fupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docs/PLAYBOOK.md27 KB1ca3f5bf99e6upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • examples/coffer-reach-motion-en.reel.json2.6 KBf4df6b58a55bupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • examples/gallery/cinematic.reel.json1.3 KB83903549559dupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • examples/gallery/clean.reel.json932 B2e1a9bae744cupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • examples/gallery/editorial.reel.json2.2 KB49c91cfc7ab9upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • examples/gallery/kinetic.reel.json1.4 KB872e3ac710daupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • examples/gallery/launch.reel.json1.8 KB9f72efd83eb0upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • examples/gallery/meme.reel.json1.5 KB2742d3180f18upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • examples/gallery/pop.reel.json1.2 KBa628ab16be2aupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • examples/genz-motion-en.reel.json3.4 KB1d42847fa622upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • library/emoji/set.json7.5 KB94ce5390d6b9upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • library/luts/looks.json6.5 KB2ccd5bc64a2aupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • library/models/face_landmarker.task3.6 MBc50c845d113eupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • library/models/LICENSE-mediapipe-face-landmarker.txt12 KBbd9ff6224526upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • library/music/manifest.json9.3 KB88a6861ba563upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • library/sfx/cc0-air-horn.wav300 KB607938d5d0e3upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • library/sfx/cc0-bike-honk.wav131 KB75c9771a914cupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • library/sfx/cc0-cartoon-zip.wav30 KB9e40b8b7e92eupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • library/sfx/cc0-cricket-chirp.wav525 KB1b10bec6e6e5upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • library/sfx/cc0-dark-sting.wav505 KB2cc2a1654828upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • library/sfx/cc0-deep-boom.wav469 KBc68d56ebb068upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • library/sfx/cc0-error-beep.wav46 KB2ad450e72f06upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • library/sfx/cc0-glass-break.wav278 KB7f458bd93a0dupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • library/sfx/cc0-glitch-hit.wav145 KB7e05e35c4312upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • library/sfx/cc0-gong-hit.wav544 KB31cc33c49168upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • library/sfx/cc0-group-ooh.wav525 KBc47df08485ffupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • library/sfx/cc0-huh-voice.wav96 KB1ca1f9ca977fupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • library/sfx/cc0-metal-clang.wav64 KBf3635f7f0d6dupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • library/sfx/cc0-oh-no-voice.wav287 KB2adcc9648957upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • library/sfx/cc0-oof-voice.wav51 KB01c2693e79e2upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • library/sfx/cc0-paper-flip.wav84 KB7487e8aebc33upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • library/sfx/cc0-paper-riffle.wav188 KB34e2b12a1a70upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • library/sfx/cc0-piano-sting.wav328 KB5edaaae07dafupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • library/sfx/cc0-riser-short.wav399 KB08676b0680faupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • library/sfx/cc0-swell-short.wav309 KB16508f079d72upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • library/sfx/cc0-tada.wav270 KB572cafd057f8upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • library/sfx/cc0-vinyl-scratch.wav84 KB3dfbbf311b58upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • library/sfx/cc0-violin-sad.wav1.0 MBfbf947bd0217upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • library/sfx/cc0-whip-crack.wav89 KB4bf1209fd89bupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • library/sfx/cc0-whoosh-reverse.wav116 KB1ba19cf89a03upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • library/sfx/cc0-wood-plane.wav159 KB22808477e367upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • library/sfx/cc0-wow-voice.wav300 KBdf44d25945acupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • library/sfx/manifest.json42 KBb422c8319621upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • LICENSE1.0 KBa11c7fae32eaupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • people-rules.example.json1.7 KB7fd8273f12f0upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • people-rules.json1.0 KBa02c894a0a98upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/caption-news/captionnews.py36 KBdfbd45011ec7upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/caption-news/catalog.json3.4 KBe70b7ae03d82upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/caption-news/CREDITS.txt2.3 KB0307e9f223f2upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/caption-news/house.json6.3 KB8603846ef819upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/caption-news/LICENSE-lemo-opuscar.txt1.0 KB5ba3cce5467fupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/caption-news/SYSTEM.md9.0 KB295c22a7a2b5upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/clean-os/assemble.py14 KB6ebfd815cec0upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/clean-os/catalog.json45 KB54ffa606a329upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/clean-os/cleanos.py40 KBd5c14d171806upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/clean-os/example/build_one_thing.py38 KB4f7b2d187791upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/clean-os/example/cut.json1.1 KB15b552aa4786upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/clean-os/example/script.txt786 B23a43fb01490upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/clean-os/fetch_fonts.py1.6 KB33991dd6862bupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/clean-os/house.json2.0 KB8ef4e10d00d2upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/clean-os/kit.py20 KB46536e2a8587upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/clean-os/SYSTEM.md14 KBaf08d39456d9upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/data-story/catalog.json4.1 KB363e4654871dupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/data-story/CREDITS.txt2.8 KB2b464a014900upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/data-story/datastory.py23 KBff66e14051cdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/data-story/engine.js30 KB1997db502790upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/data-story/house.json7.1 KBeff94b5c87dfupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/data-story/LICENSE-lemo-opuscar.txt1.0 KB5ba3cce5467fupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/data-story/SYSTEM.md9.1 KB087c389ce78aupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/explainer-vector/example/build_two_directions.py32 KB8168ae345f69upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/explainer-vector/example/PLAN.md4.7 KB142941177532upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/explainer-vector/example/script.txt763 Bf862fe11ff69upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/halftone-dossier/catalog.json5.2 KB7a607140f087upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/halftone-dossier/CREDITS.txt2.4 KB7a0696b49520upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/halftone-dossier/dossier.py52 KB96c08e4bb3cdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/halftone-dossier/house.json6.5 KB8fd8e768f1e2upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/halftone-dossier/LICENSE-lemo-opuscar.txt1.0 KB5ba3cce5467fupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/halftone-dossier/SYSTEM.md9.2 KBe4de8e2d1a0eupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/hologram-hud/catalog.json5.2 KB2bb9fbb692ffupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/hologram-hud/CREDITS.txt2.1 KB5c67253a6e7cupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/hologram-hud/engine/holohud.js51 KBe685ec6a4bb5upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/hologram-hud/fonts/exo2.woff2104 KBe825d6d68b29upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/hologram-hud/fonts/LICENSE-JetBrainsMono.txt4.4 KB8f7ed671137eupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/hologram-hud/fonts/OFL-Exo2.txt4.3 KB5bec9840d2e0upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/hologram-hud/hologramhud.py17 KB5bfbad5b75beupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/hologram-hud/house.json7.3 KB9b4d7c20fc48upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/hologram-hud/LICENSE-lemo-opuscar.txt1.0 KB5ba3cce5467fupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/hologram-hud/SYSTEM.md9.6 KBca6a7c006929upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/kinetic-doc/catalog.json15 KBd9b888740933upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/kinetic-doc/example/a_talking_head.py4.3 KB9f9d5ca32b2bupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/kinetic-doc/example/b_voiceover.py6.9 KB165b88ecb03bupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/kinetic-doc/example/c_broll.py6.3 KB9d53899c6f81upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/kinetic-doc/house.json5.3 KB84af03443433upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/kinetic-doc/kdoc.py47 KBf29ce4b00a04upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/kinetic-doc/SYSTEM.md11 KB3e459115a5ddupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/news-package/catalog.json5.4 KBd6c55bf19c77upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/news-package/CREDITS.txt3.1 KB6a1b9e94c25cupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/news-package/fonts/fira-sans-800-cyrillic.woff27.0 KB8f1ce8cff1cdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/news-package/fonts/fira-sans-800-latin.woff217 KB12a186718d27upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/news-package/fonts/fsec-600-cyrillic.woff27.0 KB28723ebca9c9upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/news-package/fonts/fsec-600-latin.woff217 KBe3a85fc98f57upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/news-package/fonts/fsec-600i-cyrillic.woff27.5 KB19e22537ef1dupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/news-package/fonts/fsec-600i-latin.woff218 KB30a193fea5c8upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/news-package/fonts/fsec-800-cyrillic.woff27.0 KBdc278c1131c4upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/news-package/fonts/fsec-800-latin.woff217 KB02a5fd86925fupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/news-package/fonts/OFL-FiraSans.txt4.3 KBa2c1ae225f24upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/news-package/fonts/OFL-IBMPlexMono.txt4.4 KBc35c4c618fabupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/news-package/fonts/ttf/fira-sans-800.ttf326 KB0281f9c8f1a9upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/news-package/fonts/ttf/fsec-600.ttf324 KBd90c7e9de53eupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/news-package/fonts/ttf/fsec-600i.ttf338 KB22b6a18a97b6upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/news-package/fonts/ttf/fsec-800.ttf327 KB61d4655a9ca3upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/news-package/fonts/ttf/plex-mono-500.ttf127 KB54927d50fdd6upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/news-package/house.json9.4 KBf595182f9843upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/news-package/LICENSE-lemo-opuscar.txt1.0 KB5ba3cce5467fupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/news-package/newspackage.py53 KB1aaf62962700upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/news-package/SYSTEM.md12 KBe055808c2117upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/pov-montage/example/assemble.py5.8 KBd9eaa7a36745upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/pov-montage/example/edl.json2.0 KB3d8ddab1a2d9upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/pov-montage/example/gen_words.py2.6 KBa9b6c0b040bdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/pov-montage/example/reel.json4.6 KBeb069b8a62a2upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/pov-montage/example/script.txt826 Be21b2c552d1eupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/product-page/catalog.json18 KB85394707e6afupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/product-page/fontwidths.py2.2 KBec174215b31eupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/product-page/house.json11 KB22c21fcf624dupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/product-page/productpage.py57 KB60ad36a49ed2upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/product-page/SYSTEM.md14 KB3f1a13433684upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/result-podcast/catalog.json36 KBec04221e004aupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/result-podcast/example-face/reel.py24 KBa3fbd6a061c4upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/result-podcast/example-face/script.txt897 Be7e88a6dd2c6upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/result-podcast/example/build.py32 KB090b8686c490upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/result-podcast/example/gen_broll.sh1.7 KB78430eff6a83upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/result-podcast/example/script.txt786 Bd2509c8cf7d4upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/result-podcast/example/takes.py4.8 KB44c8b725affdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/result-podcast/faceresult.py24 KB6c4e361ca241upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/result-podcast/house.json2.0 KBd8c526493454upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/result-podcast/STYLE-LIBRARIES.md18 KB18c11a1b0bffupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/result-podcast/SYSTEM.md4.8 KB10822650721aupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/seoul-list/build.mjs54 KB05bf335fc498upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/seoul-list/catalog.json26 KBb72b81007671upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/seoul-list/example/list.json5.1 KB0fdd45ef6bddupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/seoul-list/example/script.txt430 B52e3f9121704upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/seoul-list/house.json2.3 KB097dc7c33f6eupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/seoul-list/prep.py9.9 KB66bf2432e5c3upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/seoul-list/proxy.sh3.9 KB95ae0e123407upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/seoul-list/seoul.py20 KB548729c3d0dfupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/seoul-list/snap.py9.5 KB54f58ca24bc5upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/seoul-list/SYSTEM.md6.7 KB1d3d1bac3066upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/stan-style/catalog.json2.2 KB688ec697afa1upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/stan-style/example/reel.json3.2 KBf2145deedcc2upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/stan-style/example/script.txt978 B62f0bca5415fupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/stan-style/house.json1.3 KBaa2c5cb7707bupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/stan-style/SYSTEM.md5.5 KB71f3bae641eeupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/step-deck/catalog.json14 KB1cbc66843af4upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/step-deck/house.json13 KB8a062ff3f2caupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/step-deck/stepdeck.py54 KBd79c75337e48upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/step-deck/SYSTEM.md14 KBd76674392471upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/swiss-grid/catalog.json5.5 KBafe3e9fe6116upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/swiss-grid/CREDITS.txt2.7 KB1d19281752c9upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/swiss-grid/house.json6.0 KBd360339175d0upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/swiss-grid/LICENSE-lemo-opuscar.txt1.0 KB5ba3cce5467fupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/swiss-grid/swissgrid.py36 KBaed1ffed59b7upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/swiss-grid/SYSTEM.md9.0 KBb3880d2706f8upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/tactile-paper/catalog.json17 KB097985c9da4aupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/tactile-paper/house.json8.9 KBb0ec51c198a4upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/tactile-paper/props.py17 KB7302bdff8808upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/tactile-paper/SYSTEM.md14 KBe211db8d161cupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/tactile-paper/tactile.js23 KB14418f7dddcdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/tactile-paper/tactile.py31 KB985a11ce5ccaupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/telestrator/catalog.json8.0 KB8fd338ad66b2upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/telestrator/CREDITS.txt2.4 KB68ae5085dcdeupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/telestrator/house.json9.0 KB44c880aa9f1cupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/telestrator/LICENSE-lemo-opuscar.txt1.0 KB5ba3cce5467fupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/telestrator/SYSTEM.md11 KB758c5b28037eupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/telestrator/telestrator.py44 KB4a097936a381upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/whiteboard/board.py33 KB755b930bd13eupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/whiteboard/catalog.json12 KB0afd837480caupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/whiteboard/example/reel.py15 KBe5bb5c88aad9upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/whiteboard/example/script.txt824 B095cc636bce8upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/whiteboard/house.json1.8 KBd238a4bf12bdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • recipes/whiteboard/SYSTEM.md3.0 KB5d8087074c29upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • styles/cinematic.json857 B581cd6df71abupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • styles/clean.json444 B638fc77aa0e0upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • styles/editorial.json552 B4a103c43c287upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • styles/kinetic.json587 B65467c6f330cupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • styles/launch.json575 Bcecbc62e1d8aupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • styles/meme.json438 B2fabf5f5b56cupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • styles/pop.json535 Babddad0e727cupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • taste.json252 B59f56a65cc28upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • templates/agents/reel-helper.md853 B116866b6f6adupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • templates/briefs/build-one-reel.txt4.6 KB3d8e222d693fupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • templates/briefs/change-one-reel.txt2.7 KB57ce36835768upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • templates/briefs/finish-one-reel.txt2.2 KB65649a39d0d7upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • templates/fonts/caveat-cyrillic.woff275 KB390184c9e27aupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • templates/fonts/caveat-latin.woff273 KB836dbda093ebupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • templates/fonts/geist-latin.woff228 KB445e0e55cbb8upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • templates/fonts/geist-mono-latin.woff231 KB68eeb7f4bd4aupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • templates/fonts/inter-cyrillic.woff218 KBd75091476317upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • templates/fonts/inter-latin.woff247 KBd15208de03cdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • templates/fonts/inter-tight-cyrillic.woff217 KBf0a04608afddupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • templates/fonts/inter-tight-italic-cyrillic.woff217 KB70552d21a269upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • templates/fonts/inter-tight-italic-latin.woff247 KB870e9b598292upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • templates/fonts/inter-tight-latin.woff244 KB228154ffb1f2upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • templates/fonts/jetbrains-mono-cyrillic.woff212 KB8ee2d7085520upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • templates/fonts/jetbrains-mono-latin.woff239 KBcd5102a44c76upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • templates/fonts/LICENSE-Caveat.txt4.3 KB5303054dc8feupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • templates/fonts/LICENSE-Geist.txt4.3 KB8d003fec6b8aupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • templates/fonts/LICENSE-Inter.txt4.3 KB9b2ca37b3ffcupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • templates/fonts/LICENSE-InterTight.txt4.3 KB18d0da5dfcf4upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • templates/fonts/LICENSE-JetBrainsMono.txt4.4 KB8f7ed671137eupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • templates/fonts/LICENSE-Montserrat.txt4.3 KBfe576a2ee1f9upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • templates/fonts/LICENSE-Oswald.txt4.3 KB76a02175dbdeupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • templates/fonts/LICENSE-PlayfairDisplay.txt4.3 KB13153890847bupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • templates/fonts/LICENSE-Unbounded.txt4.3 KB28bced243768upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • templates/fonts/montserrat-cyrillic.woff223 KBd5e7d03544e2upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • templates/fonts/montserrat-latin.woff237 KB3b2eaa95e30dupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • templates/fonts/oswald-cyrillic.woff215 KBc35f37a67636upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • templates/fonts/oswald-latin.woff228 KB7b2a5509842eupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • templates/fonts/playfair-display-cyrillic.woff2104 KB9757843ba845upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • templates/fonts/playfair-display-italic-cyrillic.woff2102 KB0f4135078887upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • templates/fonts/playfair-display-italic-latin.woff2102 KB0f4135078887upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • templates/fonts/playfair-display-latin.woff2104 KB9757843ba845upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • templates/fonts/unbounded-cyrillic.woff231 KB102b4544462dupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • templates/fonts/unbounded-latin.woff250 KB3260a1939eb5upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • tests/test_assemble_sync.py8.2 KBcee22cd7460cupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • tests/test_cutout_fx.py8.3 KBed6141c50930upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • tests/test_decode_levels.py5.6 KBe1cbcce825e0upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • tools/paper/build-vendor.mjs2.9 KB5ca8ff146e92upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • tools/paper/package-lock.json15 KBc7f013ab0463upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • tools/paper/package.json358 B797ff5faa9fbupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • tools/paper/src/hf-paper.js10 KB2880a3157df8upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • tools/paper/src/react-shim.js1.0 KBe4f339d4034cupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/kurbaitaev-ghost-editor.md

// REPO STATS

469 stars
3 open issues
Last commit: 16d ago