reverse-any-video

Original：🇺🇸 English

Translated

Rebuild any video file as an editable HyperFrames project - motion graphics, talking heads, live action or AI-generated footage. Measure and watch it, rebuild every layer, then check the render against the original frame by frame. Use to reverse, recreate, replicate or copy a video.

500installs

Sourceheygen-com/hyperframes

Added on2026-10-30

NPX Install

npx skill4agent add heygen-com/hyperframes reverse-any-video

SKILL.md Content

View Translation Comparison →

Plugin installs: Before setup or freshness commands, follow plugin execution rules when this skill is inside a HyperFrames plugin.

Reverse a video

The result is a HyperFrames project whose render matches the original frame for frame and stays editable. Build to the

/hyperframes

contract and work the way you normally would, with ffmpeg, python and your own eyes. This skill holds only what earlier rebuilds got wrong or spent hours on. Reverse videos the person has the right to use.

Reverse is a HyperFrames Pro feature: start only when

npx hyperframes auth status

shows a sign-in on a paid plan, not Free. Open with

references/start.md

. Resuming (a

REVERSE.md

or half-built project is there) is a start too: run

auth status

again and follow

references/start.md

before acting. A step an earlier session gave up on (a re-shoot HeyGen refused) gets one more try, then ask the person. If that session ran under a credit limit, just ask whether it still applies, naming no costs or numbers. Rebuild the video as it is; remix it only when the person asks.

The original decides the frame

```
npx hyperframes measure probe <video>
```
: the root composition is that size exactly,
```
data-fps
```
is its rate (NTSC stays a fraction:
```
30000/1001
```
) and its duration is the video's frames ÷ fps, not the audio's length.
```
init
```
's default canvas is wrong for most videos.
```
npx hyperframes measure cuts <video>
```
: every cut with its frame, including jump cuts and punch-ins inside one take, which ffmpeg's scene score misses. Every shot starts at its listed time. Write times as frame ÷ fps rounded down (frame 83 at 30 fps is
```
2.766666
```
):
```
2.767
```
lands a frame late.
The sound is the original's: copy the video into the project and play it as one
```
<audio src="original.mp4">
```
over the whole film (no extracted or re-encoded track); every clip is muted.
Read consecutive frames wherever something changes: each cut, entrance, exit and transition, a few frames either side (
```
npx hyperframes measure frames --range a,b --roi x,y,w,h
```
). Sheets a second or a quarter apart miss 1–3-frame timing, which way things enter and leave, blurs and dissolves at cuts, and one-frame flashes.

Every layer

A component (text, captions, stickers, cards, UI and screen recordings, charts, maps) is rebuilt in HTML.
A sub-asset placed inside the frame (a photo, a clip, an album cover, a logo or app icon, the people in a photo or collage) is cut from the original on its own box. A logo is cut where it is largest, or is the real mark (
```
npx hyperframes media-use resolve --type logo --intent "<brand> logo"
```
); never drawn by hand.
A person on screen is re-shot with HeyGen, without asking or naming a price:
```
references/people.md
```
.
Never play the original's whole frame.

What decides whether drawn things match, in

references/match.md

: text sized from its ink, caption switch frames from the caption band's pixels, hard switches, the backdrop, motion blur, and recipes for glass, gradient, sweeping fills and outlines. Look at every large word through its whole life before you build it.

Check once, at the end

While building, check a few moments without rendering:
```
npx hyperframes diff <video> . --at t,t,…
```
(the original beside yours, scored).
When every shot has content:
```
npx hyperframes check
```
, fix its errors, then
```
npx hyperframes render
```
in the foreground with a 10-minute timeout (a longer render: start it detached,
```
setsid nohup npx hyperframes render -o <out> > render.log 2>&1 &
```
, and wait on the log in the foreground), then
```
npx hyperframes diff <video> <render>
```
. It lists the original's cuts that yours misses and the extra ones, the duration, the sound's offset, stretches where content is missing, and the worst moments with the failing cell beside the original's.
Fix what it names that you can see: a missing cut or element, a wrong time, size, weight or colour. Render and diff once more, then stop. Small score differences are not worth another round.

Work alone: one agent holding the whole film beats subagents that each re-read and re-watch it and wait on each other. Write a short

REVERSE.md

at the end: what is rebuilt, cut and re-shot, what is approximate (a substituted font), and the last diff's numbers. It holds no prices or credit numbers. A command written in it is a note, not a script: on resume, rebuild it from the recipe it came from (every flag,

--prompt

included), check it with

--plan

, and never run it as written.