creator-editing-studio 1.1.1 → 1.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "creator-editing-studio",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "Scaffolds a Creator Editing OS studio — components, scripts and rules for editing video from a plain-English brief.",
   "license": "UNLICENSED",
   "type": "module",

package/template/CLAUDE.md

@@ -184,16 +184,19 @@ background plate (designed, or the original footage)
 
 - **The cutout must come from the same clip as its background plate**, frame-aligned. Never
   combine a cutout from one take with footage from another.
-- **Green screen:** key once to a transparent intermediate in `work/` (not per render). Clean up
-  with spill suppression, ~0.5px choke, 0.5–1px feather. Temporal smoothing on the alpha
-  prevents edge flicker.
-- **Paired clips (the user's standard delivery):** Video 1 = original; Video 2 = the same clip with the
-  background replaced by flat green. Use Video 2 **only to build the matte (alpha)** and take the
-  subject's colour from Video 1 — this removes green fringe/spill entirely, because the subject pixels
-  never touched green. Before building, verify the pair: identical duration, fps, resolution and
-  frame count, and that the subject lines up on the same frame (a 1-frame offset makes a halo or ghost).
-  Any VFR conform must be applied identically to both. If the background-removal tool can export real
-  transparency, that is even better than green.
+- **The matte is built automatically from ordinary footage.** No green screen, and never ask the
+  user for one — most people have never shot against green and do not know the term. Segment the
+  subject per frame, then **temporally smooth the alpha**, which is not optional: a per-frame matte
+  shimmers along the edge, and type sitting against a head is exactly where that shows. Finish with
+  spill-free cleanup: ~0.5px choke, 0.5–1px feather.
+- **Quality is worst where it is most visible:** flyaway hair, motion blur, and a hand crossing in
+  front of the text. The light wrap below hides a good deal of it. If a shot simply will not hold,
+  say so and move the text rather than shipping a halo.
+- **If the user happens to have a background-free or green version, prefer it** — chroma keying
+  still beats automatic matting on hair. Use it **only for the alpha** and take the subject's colour
+  from the original, so no green ever reaches the edges. Verify the pair first: identical duration,
+  fps, resolution and frame count, subject aligned on the same frame (one frame out makes a ghost).
+  This is an upgrade for people who already work that way, never a requirement.
 - **Supplied cutouts** must have real transparency (ProRes 4444, WebM with alpha, or PNG sequence).
   An MP4 cannot hold transparency — if one arrives, stop and tell the user.
 - Play transparent video with `<OffthreadVideo transparent src={staticFile(...)} />`.
@@ -216,7 +219,7 @@ background plate (designed, or the original footage)
      force-align that exact text to the audio with WhisperX's aligner. Never use SRT timings
      directly — they are line-level and padded for readability, not word-accurate.
    - With no script, transcribe with WhisperX, then show the transcript for correction before building.
-3. **Cutouts:** key green screen or validate supplied cutouts (see above).
+3. **Cutouts:** build the matte from the footage automatically, or validate a supplied cutout (see above). Only needed for shots that want text behind the subject.
 4. **Beat sheet:** from the script and the user's marked punch lines, write a short plan — which
    moment gets which treatment — and confirm with the user before building.
    - **Read their saved references first** (`editing_os_references`). They are the whole reason

package/template/requirements.txt

@@ -1,17 +1,23 @@
-# The Python half of the studio: transcription, word alignment, cut detection,
-# green-screen cutouts and colour grading.
-#
-#   python -m venv .venv
-#   .venv/bin/pip install -r requirements.txt        (Windows: .venv\Scripts\pip)
-#
-# Python 3.11 or 3.12. Not 3.13+ — WhisperX's dependencies do not support it yet, and the
-# failure is a wall of build errors rather than a clear message.
-#
-# certifi is not optional on macOS: torch downloads the alignment model with urllib, which
-# on a python.org build has no root certificates at all.
-
-whisperx==3.8.6
-torch>=2.2
-numpy>=1.26
-Pillow>=10.0
-certifi>=2024.2.2
+# The Python half of the studio: transcription, word alignment, cut detection,
+# green-screen cutouts and colour grading.
+#
+#   python -m venv .venv
+#   .venv/bin/pip install -r requirements.txt        (Windows: .venv\Scripts\pip)
+#
+# Python 3.11 or 3.12. Not 3.13+ — WhisperX's dependencies do not support it yet, and the
+# failure is a wall of build errors rather than a clear message.
+#
+# certifi is not optional on macOS: torch downloads the alignment model with urllib, which
+# on a python.org build has no root certificates at all.
+
+whisperx==3.8.6
+# BiRefNet, for cutting the subject out of ordinary footage so text can sit behind them.
+# MIT licensed and self-hosted: nothing uploads, and there is no per-video cost.
+transformers>=4.44
+timm>=1.0
+einops>=0.8
+kornia>=0.7
+torch>=2.2
+numpy>=1.26
+Pillow>=10.0
+certifi>=2024.2.2

package/template/scripts/make_cutout.py

@@ -1,68 +1,181 @@
-"""Build a transparent cutout of the subject for a frame range of a paired clip.
-
-Usage (from the project root):
-    python scripts/make_cutout.py <original> <greenscreen> <out_dir> <first_frame> <last_frame>
-
-The green-screen clip is used ONLY for the matte (alpha). Colour comes from the original clip, so no
-green ever reaches the subject's edges. Writes RGBA PNGs named f<frame>.png (absolute source frame
-numbers) so compositions can map composition frames to cutout frames directly.
-"""
-
-import subprocess
-import sys
-from pathlib import Path
-
-import numpy as np
-from PIL import Image
-import sys as _sys, pathlib as _pl
-_sys.path.insert(0, str(_pl.Path(__file__).resolve().parent / 'lib'))
-from media import FFMPEG, FFPROBE  # resolved per platform - never hardcode a tool path
-
-
-
-W, H, FPS = 1920, 1080, 30
-
-
-def read_frames(path: str, first: int, count: int):
-    proc = subprocess.Popen(
-        [FFMPEG, "-v", "error", "-ss", f"{first / FPS:.6f}", "-i", path, "-frames:v", str(count),
-         "-f", "rawvideo", "-pix_fmt", "rgb24", "-"],
-        stdout=subprocess.PIPE,
-    )
-    size = W * H * 3
-    for _ in range(count):
-        buf = proc.stdout.read(size)
-        if len(buf) < size:
-            break
-        yield np.frombuffer(buf, np.uint8).reshape(H, W, 3)
-    proc.stdout.close()
-    proc.wait()
-
-
-def matte(green: np.ndarray) -> np.ndarray:
-    """Alpha 0..1 from how green each pixel is, relative to the flat background green."""
-    g = green.astype(np.float32)
-    greenness = g[..., 1] - np.maximum(g[..., 0], g[..., 2])
-    background = np.median(greenness[greenness > 60]) if (greenness > 60).any() else 150.0
-    lo, hi = 0.2 * background, 0.7 * background
-    t = np.clip((greenness - lo) / (hi - lo), 0, 1)
-    alpha = 1 - t * t * (3 - 2 * t)  # smoothstep: soft, stable edge
-    # Choke by 1px so the background never leaks in, then feather lightly.
-    choked = np.minimum.reduce([alpha, np.roll(alpha, 1, 0), np.roll(alpha, -1, 0), np.roll(alpha, 1, 1), np.roll(alpha, -1, 1)])
-    feathered = (choked * 4 + np.roll(choked, 1, 0) + np.roll(choked, -1, 0) + np.roll(choked, 1, 1) + np.roll(choked, -1, 1)) / 8
-    return feathered
-
-
-def main() -> None:
-    original, greenscreen, out_dir, first, last = sys.argv[1], sys.argv[2], Path(sys.argv[3]), int(sys.argv[4]), int(sys.argv[5])
-    out_dir.mkdir(parents=True, exist_ok=True)
-    count = last - first + 1
-    for offset, (rgb, green) in enumerate(zip(read_frames(original, first, count), read_frames(greenscreen, first, count))):
-        alpha = (matte(green) * 255).round().astype(np.uint8)
-        rgba = np.dstack([rgb, alpha])
-        Image.fromarray(rgba, "RGBA").save(out_dir / f"f{first + offset}.png", compress_level=1)
-    print(f"wrote {count} frames to {out_dir}")
-
-
-if __name__ == "__main__":
-    main()
+"""Build a transparent cutout of the subject for a frame range, from ordinary footage.
+
+Usage (from the project root):
+    python scripts/make_cutout.py <video> <out_dir> <first_frame> <last_frame>
+    python scripts/make_cutout.py <video> <out_dir> <first> <last> --alpha-from <clip>
+    python scripts/make_cutout.py <video> <out_dir> <first> <last> --model full
+
+Writes RGBA PNGs named f<frame>.png (absolute source frame numbers), so a composition can map
+composition frames to cutout frames directly.
+
+No green screen. The matte is segmented from the footage itself, because asking a customer to
+shoot against green makes the feature unavailable to almost all of them - most have never done
+it and do not know the term.
+
+--alpha-from stays for the case where a background-free or green copy already exists, which is
+faster and still sharper on hair. It is used ONLY for the alpha; colour always comes from the
+original clip, so no green ever reaches the subject's edges.
+
+Two things decide whether this reads as real rather than pasted on:
+
+  * The alpha is smoothed ACROSS frames. A per-frame matte shimmers along the edge, and type
+    sitting against someone's head is precisely where the eye catches it. A 3-frame median kills
+    single-frame flicker without the lag an average introduces on fast motion.
+  * The edge is choked before it is feathered, so the old background cannot leak into the seam.
+
+It is worst where it is most visible: flyaway hair, motion blur, a hand crossing the text. If a
+shot will not hold, move the text rather than ship a halo.
+"""
+
+import argparse
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+import numpy as np
+from PIL import Image
+import sys as _sys, pathlib as _pl
+_sys.path.insert(0, str(_pl.Path(__file__).resolve().parent / 'lib'))
+from media import FFMPEG, FFPROBE  # resolved per platform - never hardcode a tool path
+
+MODELS = {"lite": "ZhengPeng7/BiRefNet_lite", "full": "ZhengPeng7/BiRefNet"}
+SEG_SIZE = 1024
+
+
+def probe(path: str):
+    """Real dimensions and frame rate. Never assume 1920x1080 at 30 - vertical phone footage is normal."""
+    out = subprocess.run(
+        [FFPROBE, "-v", "quiet", "-print_format", "json", "-show_streams", "-select_streams", "v:0", path],
+        capture_output=True, text=True, check=True,
+    ).stdout
+    s = json.loads(out)["streams"][0]
+    num, den = (s.get("r_frame_rate") or "30/1").split("/")
+    return int(s["width"]), int(s["height"]), float(num) / float(den or 1)
+
+
+def read_frames(path: str, first: int, count: int, w: int, h: int, fps: float):
+    proc = subprocess.Popen(
+        [FFMPEG, "-v", "error", "-ss", f"{first / fps:.6f}", "-i", path, "-frames:v", str(count),
+         "-f", "rawvideo", "-pix_fmt", "rgb24", "-"],
+        stdout=subprocess.PIPE,
+    )
+    size = w * h * 3
+    for _ in range(count):
+        buf = proc.stdout.read(size)
+        if len(buf) < size:
+            break
+        yield np.frombuffer(buf, np.uint8).reshape(h, w, 3)
+    proc.stdout.close()
+    proc.wait()
+
+
+def green_matte(green: np.ndarray) -> np.ndarray:
+    """Alpha 0..1 from how green each pixel is, relative to the flat background green."""
+    g = green.astype(np.float32)
+    greenness = g[..., 1] - np.maximum(g[..., 0], g[..., 2])
+    background = np.median(greenness[greenness > 60]) if (greenness > 60).any() else 150.0
+    lo, hi = 0.2 * background, 0.7 * background
+    t = np.clip((greenness - lo) / (hi - lo), 0, 1)
+    return 1 - t * t * (3 - 2 * t)  # smoothstep: soft, stable edge
+
+
+def load_segmenter(which: str):
+    """BiRefNet, lazily. Importing torch costs seconds; do not pay it on the --alpha-from path."""
+    try:
+        import torch
+        from transformers import AutoModelForImageSegmentation
+    except ModuleNotFoundError as exc:
+        print(f"Cannot import {exc.name}. The matting model needs the studio's Python environment.", file=sys.stderr)
+        print("  see what is installed with:  npm run doctor", file=sys.stderr)
+        raise SystemExit(2)
+
+    # trust_remote_code: these repos ship their own model class, which transformers executes.
+    model = AutoModelForImageSegmentation.from_pretrained(MODELS[which], trust_remote_code=True)
+    model.eval()
+    # float32 on CPU: half precision is slower there rather than faster, and can produce NaNs.
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    model.to(device)
+    return torch, model, device
+
+
+def segment(torch, model, device, rgb: np.ndarray) -> np.ndarray:
+    """Alpha 0..1 for one frame, returned at the frame's own resolution."""
+    h, w = rgb.shape[:2]
+    img = Image.fromarray(rgb).resize((SEG_SIZE, SEG_SIZE), Image.BILINEAR)
+    x = np.asarray(img, dtype=np.float32) / 255.0
+    x = (x - np.array([0.485, 0.456, 0.406], np.float32)) / np.array([0.229, 0.224, 0.225], np.float32)
+    t = torch.from_numpy(x).permute(2, 0, 1).unsqueeze(0).to(device)
+    with torch.no_grad():
+        pred = model(t)[-1].sigmoid()[0, 0].cpu().numpy()
+    return np.asarray(Image.fromarray((pred * 255).astype(np.uint8)).resize((w, h), Image.BILINEAR), np.float32) / 255.0
+
+
+def smooth_in_time(alphas):
+    """3-frame median. Removes single-frame flicker without the lag an average would add."""
+    if len(alphas) < 3:
+        return alphas
+    out = [alphas[0]]
+    for i in range(1, len(alphas) - 1):
+        out.append(np.median(np.stack([alphas[i - 1], alphas[i], alphas[i + 1]]), axis=0))
+    out.append(alphas[-1])
+    return out
+
+
+def clean_edge(alpha: np.ndarray) -> np.ndarray:
+    """Choke by a pixel so the old background cannot leak into the seam, then feather lightly."""
+    choked = np.minimum.reduce([alpha, np.roll(alpha, 1, 0), np.roll(alpha, -1, 0), np.roll(alpha, 1, 1), np.roll(alpha, -1, 1)])
+    return (choked * 4 + np.roll(choked, 1, 0) + np.roll(choked, -1, 0) + np.roll(choked, 1, 1) + np.roll(choked, -1, 1)) / 8
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description="Transparent cutout of the subject, from ordinary footage.")
+    ap.add_argument("video")
+    ap.add_argument("out_dir", type=Path)
+    ap.add_argument("first", type=int)
+    ap.add_argument("last", type=int)
+    ap.add_argument("--alpha-from", default=None,
+                    help="Optional background-free or green copy of the SAME take, used only for the alpha.")
+    ap.add_argument("--model", choices=sorted(MODELS), default="lite",
+                    help="lite is several times faster and good enough for most shots; full is sharper on hair.")
+    args = ap.parse_args()
+
+    w, h, fps = probe(args.video)
+    count = args.last - args.first + 1
+    args.out_dir.mkdir(parents=True, exist_ok=True)
+
+    frames = list(read_frames(args.video, args.first, count, w, h, fps))
+    if not frames:
+        print("No frames read - check the frame range against the clip's length.", file=sys.stderr)
+        raise SystemExit(1)
+
+    if args.alpha_from:
+        aw, ah, afps = probe(args.alpha_from)
+        if (aw, ah) != (w, h) or abs(afps - fps) > 0.01:
+            print(f"The alpha clip does not match: {aw}x{ah}@{afps:.2f} against {w}x{h}@{fps:.2f}.", file=sys.stderr)
+            print("A mismatched pair makes a halo or a ghost. Re-export it to match, or drop --alpha-from.", file=sys.stderr)
+            raise SystemExit(1)
+        print(f"Alpha from the supplied clip, colour from the original - {count} frames.")
+        alphas = [green_matte(g) for g in read_frames(args.alpha_from, args.first, count, w, h, fps)]
+    else:
+        print(f"Segmenting {count} frames at {w}x{h} with BiRefNet ({args.model}).")
+        print("The first run downloads the model. On a CPU expect a second or two per frame.")
+        torch, model, device = load_segmenter(args.model)
+        print(f"Running on {device}.")
+        alphas = []
+        for i, rgb in enumerate(frames):
+            alphas.append(segment(torch, model, device, rgb))
+            if (i + 1) % 10 == 0 or i + 1 == count:
+                print(f"  {i + 1}/{count}", flush=True)
+
+    for i, a in enumerate(smooth_in_time(alphas)):
+        alpha = (clean_edge(a).clip(0, 1) * 255).round().astype(np.uint8)
+        Image.fromarray(np.dstack([frames[i], alpha]), "RGBA").save(
+            args.out_dir / f"f{args.first + i}.png", compress_level=1
+        )
+
+    print(f"wrote {len(alphas)} frames to {args.out_dir}")
+
+
+if __name__ == "__main__":
+    main()

package/template/templates/BRIEF.md

@@ -1,88 +1,90 @@
-# Brief: {{name}}
-
-Fill in what you can. Plain words are fine. Leave a line blank if you don't care.
-When done: drop your files in this folder's `footage/` (and `screenshots/`), then run
-`npm run prep -- {{name}}` and start the session with "start {{name}}".
-
-## Basics
-Format: 16:9            <!-- 16:9, 9:16, or both -->
-Language: en            <!-- en, hi, ar ... the language you speak in the video -->
-Talking head file:      <!-- file name in footage/, e.g. —.mp4. Leave blank if there's only one clip. -->
-Green-screen twin:      <!-- e.g. —-GS.mp4 — only if you want text behind you -->
-Length target:          <!-- e.g. 25s, 90s -->
-
-## Script
-<!-- Paste the script exactly as you read it. Numbers as digits: $99, 11 minutes, 3 days. -->
-
-
-## The one thing viewers must remember
-<!-- One sentence. Everything in the edit serves this. -->
-
-
-## Must-have moments
-<!-- By the words you say, not by time. Plain words are fine.
-- When I say "look at this" → my clip shrinks and other creators' clips appear
-- "millions of views" → a counter racing up to 1M+ -->
-
-
-## Moments from references
-<!-- You DON'T need the name of the effect. Clip + time + what you like about it.
-     Format: - clip-file.mp4 mm:ss-mm:ss — what you like (feel words are fine: snappy, floaty, punchy)
-- a-reel-you-like.mp4 00:02-00:04 — the colour screens flipping with each phrase, feels punchy -->
-
-
-## Effects from the library
-<!-- Optional: pick any by name (see the list at the bottom), and say where.
-- colour flip → "different person, different story" -->
-
-
-## B-roll
-<!-- Which clip where, by the words you say. Mark clips you DON'T want used.
-- creators' clips → "all of these people"  -->
-
-
-## Screenshots / things to blur
-<!-- Names, emails, prices, logos that must not be readable. -->
-
-
-## CTA / ending
-<!-- What the viewer should do, and what the last frame shows. -->
-
-
-## Sound
-SFX library: audio/     <!-- put sound effects in this folder's audio/, or say "none" -->
-Music: added by me in Premiere / Instagram     <!-- or a file name in audio/ -->
-
-## Don't want
-<!-- Anything you dislike: e.g. boxes over my footage, huge text, bouncy motion. -->
-
-
----
-
-### Effects library (names you can use)
-| Name | What it looks like |
-|---|---|
-| Text behind me | Big headline sits behind your head (needs the green-screen twin) |
-| Card swap | You shrink into a rounded card, turn into another clip mid-shrink, a row of cards slides in and drifts |
-| Colour flip | Hard cuts to solid accent / ink screens on each phrase; a word rolls into the next and the colours swap |
-| Counter race | A number races up from 0 and lands on a value (e.g. 1,000,000+) |
-| Zoom-through cut | A jump cut hidden by a quick push-in that eases back — used on every cut by default |
-| Gradient CTA | Dark gradient rises from the bottom, small label + big word typed on the VO, then ticked pointers |
-| Browser mockup | Screenshots inside a clean browser window that pans and zooms to the detail |
-| Pointer click | An arrow glides to a spot and clicks, with a ripple |
-| Rolling number | Digits roll from one value to another (e.g. $26.50 → $48.94) |
-| Highlight marker | Accent marker wipes behind a key phrase |
-| Side card | You move into a card beside the graphics (16:9) or below them (9:16) |
-| Headline to pill | A big headline shrinks into a small corner tag that stays on screen |
-| Word-by-word captions | On by default (looks: clean, block, highlight, pop) |
-| Whip pan | Fast blurred pan between two unrelated shots |
-| Push | The next scene pushes the last one out |
-| Mask wipe | A soft-edged wipe reveals the next scene |
-| Match cut | Cut hidden inside a shared shape or movement |
-| Dip | Quick dip through the background colour |
-| Speed ramp | Glide into slow-mo (or speed-up) and back out |
-| Beat cut | Cuts land on the beat of your music |
-| Tighten it | Silence and filler words removed, every join hidden as a punch-in |
-| Cut to the music | Whole edit built off the track: slow intro, faster build, hardest on the drop |
-| Film look | Grain, halation, light leak, gate weave (looks: clean, film, super8, cinema) |
-| Sound pass | Whooshes, impacts and risers placed off the cut list, ducked under the voice |
+# Brief: {{name}}
+
+Fill in what you can. Plain words are fine. Leave a line blank if you don't care.
+When done: drop your files in this folder's `footage/` (and `screenshots/`), then run
+`npm run prep -- {{name}}` and start the session with "start {{name}}".
+
+## Basics
+Format: 16:9            <!-- 16:9, 9:16, or both -->
+Language: en            <!-- en, hi, ar ... the language you speak in the video -->
+Talking head file:      <!-- file name in footage/, e.g. —.mp4. Leave blank if there's only one clip. -->
+Background-free copy:   <!-- Optional. Leave blank. Only fill this in if you already export a
+                             version with the background removed or replaced by flat green; the
+                             cutout is built automatically from your normal footage otherwise. -->
+Length target:          <!-- e.g. 25s, 90s -->
+
+## Script
+<!-- Paste the script exactly as you read it. Numbers as digits: $99, 11 minutes, 3 days. -->
+
+
+## The one thing viewers must remember
+<!-- One sentence. Everything in the edit serves this. -->
+
+
+## Must-have moments
+<!-- By the words you say, not by time. Plain words are fine.
+- When I say "look at this" → my clip shrinks and other creators' clips appear
+- "millions of views" → a counter racing up to 1M+ -->
+
+
+## Moments from references
+<!-- You DON'T need the name of the effect. Clip + time + what you like about it.
+     Format: - clip-file.mp4 mm:ss-mm:ss — what you like (feel words are fine: snappy, floaty, punchy)
+- a-reel-you-like.mp4 00:02-00:04 — the colour screens flipping with each phrase, feels punchy -->
+
+
+## Effects from the library
+<!-- Optional: pick any by name (see the list at the bottom), and say where.
+- colour flip → "different person, different story" -->
+
+
+## B-roll
+<!-- Which clip where, by the words you say. Mark clips you DON'T want used.
+- creators' clips → "all of these people"  -->
+
+
+## Screenshots / things to blur
+<!-- Names, emails, prices, logos that must not be readable. -->
+
+
+## CTA / ending
+<!-- What the viewer should do, and what the last frame shows. -->
+
+
+## Sound
+SFX library: audio/     <!-- put sound effects in this folder's audio/, or say "none" -->
+Music: added by me in Premiere / Instagram     <!-- or a file name in audio/ -->
+
+## Don't want
+<!-- Anything you dislike: e.g. boxes over my footage, huge text, bouncy motion. -->
+
+
+---
+
+### Effects library (names you can use)
+| Name | What it looks like |
+|---|---|
+| Text behind me | Big headline sits behind your head (works from normal footage) |
+| Card swap | You shrink into a rounded card, turn into another clip mid-shrink, a row of cards slides in and drifts |
+| Colour flip | Hard cuts to solid accent / ink screens on each phrase; a word rolls into the next and the colours swap |
+| Counter race | A number races up from 0 and lands on a value (e.g. 1,000,000+) |
+| Zoom-through cut | A jump cut hidden by a quick push-in that eases back — used on every cut by default |
+| Gradient CTA | Dark gradient rises from the bottom, small label + big word typed on the VO, then ticked pointers |
+| Browser mockup | Screenshots inside a clean browser window that pans and zooms to the detail |
+| Pointer click | An arrow glides to a spot and clicks, with a ripple |
+| Rolling number | Digits roll from one value to another (e.g. $26.50 → $48.94) |
+| Highlight marker | Accent marker wipes behind a key phrase |
+| Side card | You move into a card beside the graphics (16:9) or below them (9:16) |
+| Headline to pill | A big headline shrinks into a small corner tag that stays on screen |
+| Word-by-word captions | On by default (looks: clean, block, highlight, pop) |
+| Whip pan | Fast blurred pan between two unrelated shots |
+| Push | The next scene pushes the last one out |
+| Mask wipe | A soft-edged wipe reveals the next scene |
+| Match cut | Cut hidden inside a shared shape or movement |
+| Dip | Quick dip through the background colour |
+| Speed ramp | Glide into slow-mo (or speed-up) and back out |
+| Beat cut | Cuts land on the beat of your music |
+| Tighten it | Silence and filler words removed, every join hidden as a punch-in |
+| Cut to the music | Whole edit built off the track: slow intro, faster build, hardest on the drop |
+| Film look | Grain, halation, light leak, gate weave (looks: clean, film, super8, cinema) |
+| Sound pass | Whooshes, impacts and risers placed off the cut list, ducked under the voice |