# editable-export

Adopt this skill: https://proskills.md/skills/other/editatlas-skills-skills-editable-export

Page: https://proskills.md/skills/other/editatlas-skills-skills-editable-export
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: skills/editable-export/SKILL.md
size: 18431
sha: 9bb07d4cc8d2477e40b944685a4dbc9db40df042
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/SKILL.md

````text
---
name: editable-export
description: Give the person an editable copy of a video you made, built from its elements (footage clips, text, graphics, sounds, music), which opens in the EditAtlas studio, a web page with a timeline. There they fix small things themselves and export the MP4 again in their browser, without asking you to edit and re-render. Typical fixes are a sound a little late or too loud, text slightly off, captions too small, a typo, a clip a few frames long. The copy is a folder on their computer, plus if wanted a link with only the encrypted project text; each save adds a version, so you can take turns. It is optional. Offer it when you deliver a video, and build it only when they want it. Also use it when someone asks for "an editable version", "a project file", to "tweak it myself", pastes a message from EditAtlas Studio, "chỉnh lại chút", "tự sửa", "file để sửa", "chỉnh cỡ chữ", or "âm thanh bị trễ" after an edit. It is not a full editor; you cannot add new footage there or change effects that are burned into the clips.
license: Apache-2.0. LICENSE.txt has the complete terms
compatibility: Requires Python 3.9+ and FFmpeg with ffprobe. render.py needs Playwright (pip install playwright), Chrome or Edge, and network access to edit.trysometh.ing to load the studio page; the files stay on the machine. share.py (the optional link) needs the cryptography package and network access. The person needs Chrome or Edge 94+ (WebCodecs, and saving into a folder); Safari and Firefox are not tested. Works with the transcribe and sound-design skills.
metadata:
  author: EditAtlas
  version: "0.3.1"
  status: beta
  library: studio
  mcp-tools: none
---

# Editable export: let the person fix small things themselves

Here is the result. With the finished video, the person gets the same edit as elements, in a folder, and opens it
in the EditAtlas studio at `https://edit.trysometh.ing/studio`. The studio shows the video, a timeline and a panel.
They can:

- nudge a sound by a frame, or turn it down
- drag a caption up
- make every caption bigger at once
- fix a typo
- trim a clip
- press **Export MP4**

The MP4 is made in their browser, by the same page and the same drawing code that made the video you delivered.
So what they see is what they get.

Five things stay true the whole way through:

- **It is optional.** Never build it without asking, and never hold the video back for it. Offer it in one line
  when you deliver. Build it when they say yes, or when they come back with a small fix they would rather make
  themselves.
- **Make the first video so the copy can match it.** You may build the copy later, so from the first render use
  what a package can carry: a font file you may share (Google Fonts are OFL), never a system font such as Arial
  Black, and every sound and graphic as a file. Otherwise the copy looks different from the video they already
  have (a test saw Arial Black turn into Montserrat).
- **The footage never leaves their computer.** The copy is a folder: `project.json`, `media/` and `versions/`. The
  studio page reads it and saves into it in the browser. A link is an extra the person may want: it holds only the
  project's versions (text and timings), encrypted here, never a media file. It has no end date for now; the folder keeps every version anyway. It does
  send that encrypted text to EditAtlas, so make one only after a yes.
- **Only elements can change.** Anything burned into the footage cannot be moved in the studio, such as text
  drawn with FFmpeg, a graphic rendered into a clip or a grade. So the video you deliver must come from the
  package. If you made it another way, say which parts are fixed.
- **Never invent.** Use only the person's own files and the sounds you placed. A missing source file, such as the
  footage, the font or a sound, is a reason to ask, not to guess.

Scripts are in `scripts/`. Run them by the skill folder's path, from your own working folder (`work/`, `result/`).

```
python SKILL/scripts/package.py build work/project.json --out result/NAME.edit --note "first cut"   # version 1
python SKILL/scripts/package.py build work/project.json --out result/NAME.edit \
       --cuts work/cuts.json --captions work/transcript.json --sfx result/FILM_sfx_resolved.json
python SKILL/scripts/package.py check result/NAME.edit
python SKILL/scripts/render.py result/NAME.edit --out result/NAME.mp4                   # the MP4 you deliver
python SKILL/scripts/package.py versions result/NAME.edit                               # who saved which version
python SKILL/scripts/package.py changes result/NAME.edit                                # what the newest changed
python SKILL/scripts/package.py save work/next.json --to result/NAME.edit --from 2 --note "what you changed"
python SKILL/scripts/share.py send result/NAME.edit                                     # a link, after a yes
python SKILL/scripts/share.py pull result/NAME.edit                                     # their versions from the link
python SKILL/scripts/share.py push result/NAME.edit                                     # yours onto the link
python SKILL/scripts/share.py pull "LINK" --out result/NAME.edit                        # a link they pasted
```

## When the inputs are missing

You need what the video is made of, not only the finished MP4:

- the footage, as you processed it
- the times of the parts kept
- the text and when it shows
- the fonts
- the graphics as image files
- the sounds and music with their times and levels

If you have only a finished MP4 with text burned in, say so. The text, graphics and sound in it cannot become
elements. Offer either to rebuild the edit from its sources, or to package the footage alone with new elements on
top. Ask for a font file when the look depends on one you do not have. Do not swap in a lookalike without saying
so.

## 1. Describe the edit as elements

Write `work/project.json` in the format of `references/project-format.md` (`editatlas-project/1`). In short:

- `canvas`: size and fps.
- `media`: every file by id.
- `styles`: shared looks for text, such as `caption` and `hook`.
- `tracks`, drawn in order:
  - one `video` track of clips back to back (source `in`/`out`, crop, a slow zoom)
  - `text` items
  - `image` items
  - `audio` items (`at`, `in`/`out`, `gain_db`, fades)

**Use the footage you processed, not the raw file.** If you stabilised, graded, denoised, reframed or speed-changed
the footage, point `media` at that result. The package then carries the picture the person saw, and they do not
have to find anything themselves. Keep what should stay adjustable (text, graphics, sounds, the cuts)
out of that file and in the elements.

Let the imports write the long parts:

- `--cuts`: transcribe's `cuts.json` becomes the footage clips (the parts kept).
- `--captions`: transcribe's `transcript.json` becomes caption items with word timing, mapped through the clips.
  Use `--words-per-caption`, `--max-chars` and `--caption-style`.
- `--sfx`: sound-design's `_resolved.json` becomes the sounds, at the frames and levels it rendered.

Rules that make the studio useful:

- **Put repeated looks in a style.** In the studio, a change to a styled item can go to the whole style ("All 42
  caption") or to "This one". Without styles, "make the captions bigger" means 42 edits.
- **Give stable ids**: `c1`…, `cap1`…, and names like `s-ding`. A label (`"label": "YES badge"`) helps the person
  find a sound on the timeline.
- **Use editable text.** Make text a `text` item, not part of an image, so the person can fix typos.
- **Keep motion graphics as elements.** A graphic you animate in code becomes an animated WebP image item (see
  "Motion graphics" in the format reference), not part of the footage, so it can still be moved and retimed.
- **One element per object.** Split a graphic into the things a person might move, retime or hide on their own:
  each card, badge, callout or chart is its own item, cropped to what it covers and placed where it sat, with a
  `label` that names it ("Dream project card", "Slot: booked"). Pieces that always move together stay one item.
  Order the items back to front: later items draw on top. Overlapping items in one track are fine; the studio
  shows them in lanes. Animations hold their last frame, so a card that only slides in is a short file.
- **Words stay text.** Draw a card without its words and put each line on it as a text item with `parent` set to
  the card, so a person can fix a word or a price. Give a card or a word its own motion with `keys` (slide, pop,
  dip, fall) instead of baking it into the picture. See "Cards" and "keys" in the format reference.
- **Add the font file** for every font a style uses. Use fonts you may share: Google Fonts are OFL.
- Keep sound levels as rendered (`gain_db` relative to the file). Nothing is normalised later.

## 2. Build and check

Run `package.py build`. It does the following:

- checks the project, and writes nothing if anything is wrong
- copies the files into `NAME.edit/media/`
- measures each file's duration, size and fps
- writes `NAME.edit/versions/v1.json` (version 1, by you), then `NAME.edit/project.json`

`project.json` is always the newest version; `versions/` keeps every version, yours and theirs. `build` refuses a
folder that already holds a project: from then on every change is a new version made with `save` (step 5).

Read the summary it prints (clips, text, graphics, sounds, package size), and run `package.py check` on the
folder. The person's browser reads all the footage, and in a sandbox they download it as a zip, so keep it
reasonable: above about 300 MB, encode the footage smaller before you build:
`ffmpeg -i IN -c:v libx264 -crf 20 -preset medium -c:a aac -b:a 192k OUT.mp4`, keeping the frame rate and a frame
at least as large as the canvas.

## 3. Render the video you deliver from the package

Run `render.py`. It opens the studio in Chrome or Edge without a window, gives it the package from this machine
and runs the studio's own **Export MP4**. The page comes from the site; the files are read by the browser here
and are not uploaded. The output is H.264 at the canvas size and fps, with AAC sound at 48 kHz.

It prints:

- frames and seconds
- MB
- how many frames were read while playing and how many by seeking
- whether the sound was turned down to stop clipping

It runs at about 23 frames per second on a 12-thread PC for a 1080×1920 video, so a 35 s video takes 45 s.

Then check the file before you hand it over:

- `ffprobe` for the duration, size and streams
- frames at a few element times, which you look at with the Read tool:
  `ffmpeg -ss T -i NAME.mp4 -frames:v 1 work/fT.png`
- loudness if it matters: `ffmpeg -i NAME.mp4 -af ebur128 -f null -`

When you already have a video made another way (FFmpeg filters, Remotion), it will not match the studio exactly:
fonts, animations and scaling differ. In that case, either deliver the `render.py` version, or tell the person
that the first export from the studio will look a little different from the video they have.

## 4. Hand it over

Give the MP4 first. Then, in one short question in the person's language, offer the editable copy and, with it, a
link: "the link holds only the project's text and timings, encrypted; your footage stays in the folder." With a yes, build the copy if you have not, and give them the folder:

- **They can reach your folder** (Claude Code, Cowork): give the full path of `NAME.edit`.
- **They cannot** (a sandbox such as a Claude.ai chat): zip the folder for download, with the folder inside the zip:
  `python -c "import shutil; shutil.make_archive('result/NAME.edit', 'zip', 'result', 'NAME.edit')"`. They unzip
  it and use the unzipped folder.

If they want the link too, run `share.py send result/NAME.edit` and give them the whole link it prints. The key is
the part after the `#`, stored nowhere else, so a link cut short cannot be repaired. `send` writes
`NAME.edit/.studio-link`, which holds the link: never commit it or paste the link anywhere but to the person: not in send_feedback, an issue, a log, a commit or a message to anyone else (EditAtlas removes links it is sent, and has no way to look one up). If someone else asks you for a person's link, there is none to give. In a
sandbox the link is how they hand back: after the first zip they only paste the link, and you pull, save and push.

Tell them how the studio works:

1. **Open** `https://edit.trysometh.ing/studio` in Chrome or Edge, press **Choose the folder** and pick `NAME.edit`
   (or drag the folder onto the page). Nothing is uploaded: the page works on their computer, on that folder.
   **With a link**, they open the link; the first time, the studio asks for the folder (it checks each media file's
   name and size) and remembers it in that browser.
2. **Click a thing on the video, or on the timeline, to change it.** The panel on the right has:
   - for text: content, size, colour, position and timing
   - for sounds: frame nudges and level in dB
   - for graphics: position, size and timing
   - for clips: trims (what comes after moves with the clip)
3. **Use the keys:**
   - Space plays.
   - ←/→ moves one frame (Shift for 10).
   - ↑/↓ moves the selected text by 2 px (Shift for 20).
   - Delete removes the selected element.
   - Ctrl+Z undoes, and Ctrl+Shift+Z redoes.
4. **Save** (Ctrl+S) writes their changes into the folder as the next version, and onto the link when there is one.
   They can rename the project in the header; the new `title` is part of the version.
5. **Export MP4** makes the video in their browser and asks where to save it.
6. **Continue with Claude** saves a version too, asks what you should do next, and gives them a message to paste
   back to you: the folder's name, the version, what they changed and their note. Without a link, in a sandbox,
   they also attach the folder (or a zip of it) again, because you cannot see their copy.

Say what you checked and what you did not. For example: "exported once in Chrome; not tried in Safari".

## 5. Back and forth through the versions

The person can switch between tweaking in the studio and asking you, as often as they like. They paste the
studio's message, which looks like this, or just say they saved something:

```
I fine-tuned "Tweak test" in EditAtlas Studio and saved it as version 3 in the project folder tweak.edit.

What I changed since version 2:
- style caption (every element that uses it): size 80 → 92

Next: captions a little lower

Continue from version 3 in that folder with the editable-export skill, and save your result there as the next version.
```

The browser knows only the folder's name. You know where you built it. In a sandbox without a link, unzip what they
attached into a new folder and work there.

1. **With a link, pull first.** `share.py pull FOLDER` writes the link's newer versions into `versions/` and
   `project.json`, and prints who saved them, their note and the changes. It never fetches media: it lists any
   media file their version uses that the folder lacks. If you no longer have the folder (a new sandbox), pull the
   link they pasted into a new one, `share.py pull "LINK" --out result/NAME.edit`, and ask for the media it lists
   (the zip they kept) before you render. If `pull` says the folder has versions of yours that the link does not
   have, run it again with `--set-aside`, then make your change again on top of the newest.
2. **Read their version.** `package.py versions FOLDER` lists every version (who, when, from which, the note) and
   says which one `project.json` is. `package.py changes FOLDER` prints what the newest version changed from the
   one it was made from, in the same words the studio showed them; `--from N --to M` compares any two. List their
   changes in your reply. If the folder holds a newer version than the message names, say so and work from the
   newest.
3. **Work on a copy of the newest version.** Copy `FOLDER/project.json` to `work/next.json` and change only what
   they asked, by id; keep every id. Never start from `work/project.json` or your own older version: that silently
   undoes their tweaks. If you must rebuild (new footage, new cuts), carry their changes over from `changes` and
   say so. Paths like `media/clip.mp4` in the copy still point into the folder. Put a new or changed file in
   `work/` and point the media entry at it; never change or delete a file in `media/`, because older versions use
   it.
4. **Save your version:** `package.py save work/next.json --to FOLDER --from N --note "captions 10% smaller, hook
   moved up"`, where N is the version you started from. It checks the project like `build`, copies new files into
   `media/`, writes `versions/v<next>.json`, then `project.json`, and prints the changes and the new version
   number. The note is shown to them in the studio. `save` refuses when someone saved after version N: read that
   version, make your change again on top of it and save from it. Use `--force` only when they ask you to replace
   their version.
5. **With a link, push:** `share.py push FOLDER` puts your new version on the same link. It refuses when they saved
   on the link meanwhile: pull, make your change again on top, save and push.
6. **Render from the folder** with `render.py FOLDER --out result/NAME-v3.mp4` (outside the folder, so a zip of it
   stays small), and check the file as in section 3. It renders `project.json`, which is now your new version.
   Never render from an older copy.
7. **Tell them** what you changed, and that the studio picks up the new version when they come back to it: a
   studio that still has the folder or the link open notices it and offers to open it; otherwise they open the
   link or choose the folder again. Without a link, in a sandbox, zip the folder again for them. **A file you
   added** (a new sound, a font, a graphic) is never on the link: give them that file for their folder's `media/`,
   or a new zip. Until then the studio shows it as missing.

If they send only a `project.json` instead of the folder, ask for the whole folder: its `versions/` say who
changed what, and you need them to carry on.

## References

- `references/project-format.md`: every field of `project.json`, the folder's `versions/v<n>.json` and the light
  link. Read it before you write one by hand.
````

## File: skills/editable-export/README.md
size: 9569
sha: 69f8c02ed1851ebb01a478a31c698d733acf1c2e
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/README.md

```text
# editable-export

With a finished video, give the person an editable copy built from its elements: footage clips, text, graphics,
sounds and music. The copy opens in the [EditAtlas studio](https://edit.trysometh.ing/studio), a web page with
the video, a timeline and a panel. There they can fix small things themselves, then export the MP4 again on their
own computer, without asking Claude to edit and render again. Things they can fix:

- a sound a little late, or too loud
- a caption slightly off, or too small
- a typo
- a clip a few frames long

The copy is optional. Claude offers it when it delivers a video and builds it only when asked.

Status: beta (0.3.1).

## How the person gets it

A folder, `NAME.edit`, with `project.json`, `media/` and `versions/`. The person opens the studio in Chrome or
Edge, presses **Choose the folder** and picks it. The page reads the folder and saves into it in the browser; the
footage is never uploaded and there is no account. In a sandbox such as a Claude.ai chat, Claude zips the folder
for download and the person unzips it.

If the person wants it, Claude also makes a light link (`share.py send`, after a yes). It holds only the project's
versions, the text and timings, gzipped and encrypted on their machine with AES-256-GCM; never a media file. The key
is the part of the link after the `#`, which browsers never send to a server, so EditAtlas stores bytes it cannot
read. Links have no end date for now; the folder keeps every version either way. The person opens the link and, the
first time in that browser, chooses the folder for the media. In a sandbox the link is how they hand back: Claude
pulls their version, saves its own and pushes it to the same link.

Every save is a new version in `versions/` (`v1.json`, `v2.json` ...), by Claude or by the person, with a note.
`project.json` is always the newest. So the person and Claude can take turns on the same folder: the studio's
**Continue with Claude** gives the person a message to paste back, and Claude carries on from their version.

## Needs

- Python 3.9+ and FFmpeg with ffprobe in PATH
- `render.py` (the video Claude delivers): `pip install playwright`, Chrome or Edge installed, and network access
  to `edit.trysometh.ing` to load the studio page (the files stay on the machine)
- `share.py` (the optional link): `pip install cryptography`, and network access to `edit.trysometh.ing`
- The person: Chrome or Edge 94+ (the studio uses WebCodecs, and saves into the folder). Safari and Firefox are
  not tested.

## What the person can change

| Element | On the picture | In the panel | On the timeline |
|---|---|---|---|
| Text | click, drag (snaps to the centre), corner to resize | text, size, colour, position, timing; for a style, all items or this one | move, trim both ends |
| Graphics | click, drag, corner to resize | position, size, opacity, timing | move, trim |
| Sounds and music | | nudge by a frame, level in dB, fades | move, trim, mute a track |
| Clips | | trim in and out by a frame; what comes after moves with it | trim the edges |

The studio also has undo and redo, makes the MP4 with **Export MP4**, and saves the person's changes into the
folder as the next version with **Save** (and onto the link, when there is one). **Continue with Claude** saves
too and gives them a message for Claude; Claude reads their version (`share.py pull` first with a link), saves its own
as the next one with `package.py save` (then `share.py push`), and the studio offers it when the person comes back. Motion graphics drawn in code stay elements as animated WebP images.

## Files

| Path | What |
|---|---|
| `SKILL.md` | The workflow Claude follows |
| `references/project-format.md` | `project.json`: an edit as elements (`editatlas-project/1`) |
| `scripts/package.py` | `build`: checks a project, imports transcribe's cuts and captions and sound-design's sounds, and writes `NAME.edit/` (version 1). `save`: Claude's next version. `versions`, `changes` (in the studio's words) and `check` |
| `scripts/render.py` | Runs the studio's own export in Chrome or Edge without a window: the video Claude delivers |
| `scripts/share.py` | The optional link, project versions only: `send` makes it, `pull` writes the person's newer versions into the folder (never media; it lists media the folder lacks), `push` puts Claude's newer versions on it, `versions` lists them |
| `evals/` | Test cases in the `claude plugin eval` layout |

The studio page and the link service are in the EditAtlas website's repository, not here.

## Verified

Beta (0.3.0), on 2026-11-10. The owner read the results and approved; the evidence for each beta condition:

- **Every test case, with and without the skill.** A fresh agent ran all 7 cases in `evals/` against the production
  studio and link service, once with only this skill and once with no skill. With the skill it passed 22 of 22
  checks, without it 14 of 23, in 75 s against 124 s on average, with about the same tokens (68k a run). Without
  the skill it rendered with its own FFmpeg script and Arial, so the MP4 can differ from the studio (3 cases); it
  gave a JSON, a Python script and an ASS file instead of a studio copy for captions; it blurred burned-in captions
  and drew new ones on top. It did re-implement the link from the public studio code and push version 3 correctly,
  in 150 s against 71 s. `no-offer-subtitles-only` passed in both runs, so it shows only that the skill adds no
  unwanted offer.
- **Real results looked at.** Rendered files checked with ffprobe, frames and sound levels in every run; the
  versions each run saved hold the person's values (size 96 or 90, click at 0.6 s or -9 dB) and pass `check`. The
  studio itself was used by hand in Chrome on the owner's projects during 0.1 and 0.2.
- **Studio and agent on one folder and one link.** The studio's flow test (53 checks), the folder round trip
  `package.py` <-> studio (9 of 9) and the link round trip `share.py` <-> studio against production (26 of 26).
- **Installs from the marketplace.** A fresh Claude Code with an empty config added the marketplace from GitHub
  (v0.10.1) and installed the plugin, then ran it end to end with the production MCP to version 3 on one link.
- Each case ran once per arm, so how much a run varies is not measured.

0.2.0 (versions in the folder, no upload), on 2026-11-10, on a 12-thread Windows PC with Chrome 156:

- `package.py` end to end on a 4 s 1080×1920 test package: `build` wrote version 1 and refused to build into the
  same folder again; a hand-written studio version 2 (hook size 96, click 0.1 s later) was listed by `versions` and
  described by `changes` as the studio does; `save --from 2` wrote version 3 with a new sound and a changed file of
  the same name (copied as `click-2.wav`, nothing overwritten); `save --from 1` was refused and named version 3 and
  its author; `--force` wrote version 4 from 1; `check` passed, flagged a gap in the numbers and a `project.json`
  edited without a version; a folder without `versions/` got its version 1 written on the first save.
- `changes` gives the same lines as the studio's own `changeSummary` on 425 pairs of projects (25 made by hand, 400
  random), run against the JS function in Node.
- `render.py` on that package with `versions/`, against the production studio page: 120 frames in 2 s, H.264
  1080×1920 30 fps with AAC 48 kHz, 4.01 s.
- `share.py` sealing against a WebCrypto reference in Node (AES-GCM with the contract's additional data, HKDF write
  token, gzip): 5 projects up to 7 KB sealed, Python sealed and Node opened, Node sealed and Python opened, the
  write tokens were equal, and a wrong object name or share id was refused on both sides (25 of 25 checks).
- `share.py` against a local mock of the link API (not the real server): send, a studio version put by the eval
  helper, versions, pull, save and push; push refused after the studio saved meanwhile, pull refused the clash and
  `--set-aside` resolved it; a studio version with a new logo listed the missing file; pull of the link into an empty
  folder wrote 5 versions and listed the 3 missing media; an expired link (410) printed the server's message.

Earlier (0.1.x), against a local copy of the studio:

- **A 34.5 s 1080×1920 talking head.** It had 42 captions with word timing, a hook, a logo, 3 sounds, music and
  3 clips cut from a 24 fps source: 23.1 MB in 8 files. `render.py`: 1035 frames in 45 s (23 frames/s), H.264 +
  AAC, 45.5 MB. Every frame was identical to an export that seeks to every frame.
- **The studio used like a person would, in Chrome:** open the package from disk; captions 66 → 84 px for all 42
  at once, and a sound 2 frames earlier; Export MP4: 1035 frames in 26 to 28 s.
- **Heavy graphics** (28 stickers, a full-frame overlay, 10 shadowed labels at once, 4 animated WebP graphics, zooming
  clips, 96 elements): preview frames took 3 ms or less to draw, no footage frame more than 100 ms off at the cuts,
  and 8 exported frames matched the preview at the same time (PSNR 32 to 41 dB, against 19 to 36 dB for the next
  frame).
- **Two eval cases run by hand** (`captions-editable`, `apply-saved-changes`), before the move to the studio.
  Both built, checked and rendered, and their frames were looked at.

Not yet checked:

- the zip hand-over in a Claude.ai chat
- Safari, Firefox, Mac
- videos longer than a minute
- exporting in a visible browser window (Chrome without a window varied from 26 s to 90 s for the same 35 s video
  between runs)
- real people using it
```

## File: skills/editable-export/scripts/package.py
size: 39852
sha: ed7c4e7eaf94ff49bd827ae7dd3dae91c2d3da0d
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/scripts/package.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/editatlas/skills/blob/main/skills/editable-export/scripts/package.py

## File: skills/editable-export/scripts/render.py
size: 6978
sha: 85d430b9f75da55178dbb5d647f0a151787f262d
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/scripts/render.py

```text
"""Render a package's video with the EditAtlas studio, so what the person sees there is what you deliver.

  render.py result/my-video.edit                      # -> result/my-video.edit/<title>.mp4
  render.py result/my-video.edit --out result/final.mp4

Opens the studio page in Chrome or Edge without a window (Playwright), gives it the package from this machine,
runs its Export and saves the MP4. It renders project.json, which is the newest version in the folder; the files in
versions/ are not needed for that and are not passed. The page is loaded from the site; the project and its files
are read by the browser here and are not sent anywhere. Needs `pip install playwright`, Chrome or Edge installed (or
`python -m playwright install chromium`) and network access to the site. Prints frames, seconds taken and size;
then measure the file with ffprobe before you hand it over.
"""
import argparse
import json
import os
import subprocess
import sys
import time
from pathlib import Path

SITE = "https://edit.trysometh.ing"

def die(msg):
    sys.exit("editable-export: " + msg)

def newest_version(pkg):
    """(n, project) of the highest versions/v<n>.json, or None."""
    nums = [int(f.stem[1:]) for f in (pkg / "versions").glob("v*.json") if f.stem[1:].isdigit()] if (pkg / "versions").is_dir() else []
    if not nums:
        return None
    n = max(nums)
    return n, json.loads((pkg / "versions" / f"v{n}.json").read_text(encoding="utf-8")).get("project")

EXPORT_JS = """async (rate) => {
  await window.EA.ready;
  if (rate) window.EA_EXPORT_RATE = rate;
  const missing = missingFiles();
  if (missing.length) return {missing};
  const r = await window.EA.exportMp4(() => {});
  const a = document.createElement('a'); a.href = URL.createObjectURL(r.blob); a.download = 'export.mp4';
  document.body.appendChild(a); a.click();
  return {frames: r.frames, seconds: r.seconds, size: r.blob.size, peak: r.peak, stats: r.stats};
}"""

def main():
    try:
        sys.stdout.reconfigure(encoding="utf-8", errors="replace")
    except Exception:
        pass
    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    ap.add_argument("package", help="the package folder (with project.json and media/)")
    ap.add_argument("--out")
    ap.add_argument("--site", default=SITE, help="where the studio is (default: %(default)s)")
    ap.add_argument("--browser", default="auto", help="chrome, msedge, chromium or auto")
    ap.add_argument("--timeout", type=float, default=1800, help="seconds")
    ap.add_argument("--rate", type=float, help="playback speed while reading frames (default 1.5)")
    a = ap.parse_args()
    pkg = Path(a.package).resolve()
    pj = pkg / "project.json"
    if not pj.is_file():
        die(f"no project.json in {pkg}; run package.py build first")
    proj = json.loads(pj.read_text(encoding="utf-8"))
    newest = newest_version(pkg)
    if newest and newest[1] != proj:
        print(f"warning: project.json is not the newest version (v{newest[0]}); rendering project.json as it is. "
              "Run package.py versions and package.py check on the folder.")
    files = [pj] + [pkg / m["path"] for m in proj.get("media", {}).values()]
    gone = [str(f) for f in files if not f.is_file()]
    if gone:
        die("missing from the package: " + ", ".join(gone) + "; run package.py build again")
    out = Path(a.out) if a.out else pkg / (((proj.get("title") or pkg.stem).strip().replace(" ", "-").lower() or "video") + ".mp4")
    try:
        from playwright.sync_api import sync_playwright
    except ImportError:
        die(f"Playwright is not installed: pip install playwright. Or open {a.site}/studio in Chrome, choose the "
            "package folder and press Export MP4.")
    errors = []
    t0 = time.time()
    with sync_playwright() as p:
        browser = None
        for ch in ([a.browser] if a.browser != "auto" else ["chrome", "msedge", "chromium"]):
            try:
                kw = {} if ch == "chromium" else {"channel": ch}
                browser = p.chromium.launch(headless=True, args=["--autoplay-policy=no-user-gesture-required"], **kw)
                break
            except Exception as e:                       # that browser is not installed
                errors.append(f"{ch}: {str(e).splitlines()[0]}")
        if not browser:
            die("no Chrome, Edge or Playwright Chromium found (" + "; ".join(errors) + ")")
        ctx = browser.new_context(accept_downloads=True, viewport={"width": 1400, "height": 900})
        internal = os.environ.get("EDITATLAS_INTERNAL")  # EditAtlas's own checks: kept out of its usage numbers
        if internal:
            ctx.add_init_script("localStorage.setItem('editatlas-internal', " + json.dumps(internal) + ")")
        pg = ctx.new_page()
        logs = []
        pg.on("pageerror", lambda e: logs.append("page error: " + str(e)))
        pg.on("console", lambda m: logs.append(f"console {m.type}: {m.text}") if m.type == "error" else None)
        try:
            r = pg.goto(a.site.rstrip("/") + "/studio", timeout=60000)
        except Exception as e:
            die(f"could not open {a.site}/studio: {str(e).splitlines()[0]}")
        if not r or not r.ok:
            die(f"{a.site}/studio answered {r.status if r else 'nothing'}")
        pg.locator("#open-fileinput").set_input_files([str(f) for f in files])
        try:
            pg.wait_for_function("() => window.EA && window.EA.ready", timeout=60000)
        except Exception:
            die("the studio did not open the package: " + (pg.locator("#open-msg").inner_text() or "; ".join(logs) or "no message"))
        with pg.expect_download(timeout=a.timeout * 1000) as dl:
            info = pg.evaluate(EXPORT_JS, a.rate)
            if info.get("missing"):
                die("the studio could not match these media ids to files: " + ", ".join(info["missing"])
                    + ". Two files in media/ may share a name; run package.py build again.")
        out.parent.mkdir(parents=True, exist_ok=True)
        dl.value.save_as(str(out))
        print(f"{browser.version}: {info['frames']} frames in {info['seconds']:.1f} s "
              f"({info['frames'] / max(info['seconds'], 1e-3):.1f} frames/s), {info['size'] / 1e6:.2f} MB"
              f" (frames read while playing: {info['stats']['played']}, by seeking: {info['stats']['sought']})"
              + (f"; sound peaked at {info['peak']:.2f} and was turned down to 0.98" if info["peak"] > 0.98 else ""))
        for line in logs:
            print(line)
        browser.close()
    r = subprocess.run(["ffprobe", "-v", "error", "-show_entries", "stream=codec_name,width,height,r_frame_rate,nb_frames"
                        ":format=duration", "-of", "compact", str(out)], capture_output=True, text=True)
    print(r.stdout.strip() or r.stderr.strip())
    print("->", out, f"({time.time() - t0:.0f} s)")

if __name__ == "__main__":
    main()
```

## File: skills/editable-export/scripts/share.py
size: 21658
sha: 68bc6a11f8a1003f4edf593bd2fc6ddb6c99eaf1
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/scripts/share.py

```text
"""A light studio link for a package folder: the project's versions only, encrypted. Media never leave the folder.

  share.py send result/my-video.edit                  # a new link holding the folder's versions; prints the link
  share.py push result/my-video.edit                  # your newer versions (package.py save) onto the link
  share.py pull result/my-video.edit                  # the person's newer versions from the link, into the folder
  share.py pull "https://edit.trysometh.ing/studio#ID.KEY" --out result/my-video.edit   # a link you were given
  share.py versions result/my-video.edit              # the versions on the link (or give the link itself)
  share.py send result/my-video.edit --site http://127.0.0.1:8799                       # a local studio

The folder stays the real thing: project.json, media/ and versions/v<n>.json (package.py). A link only carries the
versions, so the person and you can pass the project back and forth without passing the folder each time. A version
has the same number in the folder and on the link. Links have no end date for now (EditAtlas may set one later,
and says so in its answers); the folder keeps every version either way.

Each version is gzip of its JSON, encrypted on this machine with AES-256-GCM and a random key made by `send`. The key
is only in the link, after the #, which browsers never send to a server, so EditAtlas stores bytes it cannot read.
Anyone who has the link can read and add versions: give it only to the person. FOLDER/.studio-link holds the link and
the newest version both have; it contains the key, so never put it in a repository or a message other than to them.

Format "editatlas-share/2", also read and written by the studio page:
  object v<n> = 12-byte nonce + AES-256-GCM(gzip(UTF-8 JSON)) + 16-byte tag,
                additional data "editatlas-share/2|<share id>|v<n>";
  JSON = {format, version, parent, by, name, note, made, project, media: {<id>: {path, bytes}}};
  write token = HKDF-SHA256(key, no salt, info "editatlas-share/2 write"), 32 bytes, base64url, a Bearer token.
Limits: a version at most 256 KiB sealed; a link at most 2 MiB and 64 versions; no end date for now.

Needs `pip install cryptography`. EDITATLAS_INTERNAL, when set, goes out as the X-EditAtlas-Internal header.
"""
import argparse
import base64
import gzip
import json
import os
import re
import sys
import time
import urllib.error
import urllib.request
from pathlib import Path

sys.path.insert(0, str(Path(__file__).resolve().parent))
import package as pk  # noqa: E402  (version files, change_summary)

FORMAT = "editatlas-share/2"
SITE = "https://edit.trysometh.ing"
AGENT = "editatlas-skills/editable-export"
STATE = ".studio-link"
OVERHEAD = 28                                    # nonce + tag
MAX_OBJECT, MAX_LINK, MAX_OBJECTS = 256 * 1024, 2 * 1024 * 1024, 64
LINK = re.compile(r"(https?://[^/#\s]+)/studio#([A-Za-z0-9_-]{22})\.([A-Za-z0-9_-]{43})(?:\.([1-9][0-9]{0,4}))?")

def die(msg):
    sys.exit("editable-export: " + msg)

def b64u(raw):
    return base64.urlsafe_b64encode(raw).rstrip(b"=").decode("ascii")

def call(method, url, body=None, headers=None, tries=3):
    """One request -> (status, body bytes or the server's error message). A refusal (4xx) is final; a dropped
    connection or a busy server is tried again."""
    head = {"User-Agent": AGENT, **(headers or {})}
    internal = os.environ.get("EDITATLAS_INTERNAL")          # EditAtlas's own checks: kept out of its numbers
    if internal:
        head["X-EditAtlas-Internal"] = internal
    for attempt in range(1, tries + 1):
        try:
            with urllib.request.urlopen(urllib.request.Request(url, data=body, method=method, headers=head), timeout=60) as r:
                return r.status, r.read()
        except urllib.error.HTTPError as e:
            text = e.read()
            if e.code < 500 or attempt == tries:
                try:
                    text = json.loads(text)["error"]
                except Exception:
                    text = text.decode("utf-8", "replace")[:300]
                return e.code, text
        except (urllib.error.URLError, TimeoutError, ConnectionError) as e:
            if attempt == tries:
                die(f"could not reach {url.split('/api/')[0]}: {getattr(e, 'reason', e)}")
        time.sleep(0.8 * attempt)

def refused(code, body, what):
    """The server's own message (413, 400 and 410 come as JSON {error}), and what to do about an expired link."""
    if code in (404, 410):
        msg = body if code == 410 and body else "this link was taken down or does not exist."
        die(f"{what}: {msg} The folder still has every version: make a new link with share.py send FOLDER --new.")
    die(f"the studio refused {what} ({code}): {body}")

class Link:
    """One studio link: site, id and key; sealing, and the calls that read and add versions."""

    def __init__(self, site, sid, key):
        try:
            from cryptography.hazmat.primitives import hashes
            from cryptography.hazmat.primitives.ciphers.aead import AESGCM
            from cryptography.hazmat.primitives.kdf.hkdf import HKDF
        except ImportError:
            die("the cryptography package is not installed: pip install cryptography. The folder works without a "
                "link: the person opens it at " + site + "/studio with Choose the folder.")
        self.site, self.sid, self.key = site.rstrip("/"), sid, key
        self.api = self.site + "/api/v1/studio/shares"
        self.aes = AESGCM(key)
        self.write = b64u(HKDF(algorithm=hashes.SHA256(), length=32, salt=None,
                               info=f"{FORMAT} write".encode()).derive(key))

    @classmethod
    def parse(cls, text):
        m = LINK.fullmatch(text.strip())
        if not m:
            die("that is not a whole studio link: it looks like https://edit.trysometh.ing/studio#<id>.<key>")
        return cls(m.group(1), m.group(2), base64.urlsafe_b64decode(m.group(3) + "=")), (int(m.group(4)) if m.group(4) else None)

    @property
    def url(self):
        return f"{self.site}/studio#{self.sid}.{b64u(self.key)}"

    def aad(self, name):
        return f"{FORMAT}|{self.sid}|{name}".encode("utf-8")

    def seal(self, name, data):
        nonce = os.urandom(12)
        return nonce + self.aes.encrypt(nonce, data, self.aad(name))

    def unseal(self, name, blob):
        return self.aes.decrypt(blob[:12], blob[12:], self.aad(name))

    def seal_version(self, obj):
        return self.seal(f"v{obj['version']}", pack(obj))

    def open_version(self, n, blob):
        try:
            obj = json.loads(gzip.decompress(self.unseal(f"v{n}", blob)).decode("utf-8"))
        except Exception:
            die("the key in this link does not open it; ask for the whole link again, with the part after the #")
        if obj.get("format") != FORMAT or obj.get("version") != n or (obj.get("project") or {}).get("format") != pk.FORMAT:
            die(f"version {n} on this link is not something this script can read (format {obj.get('format')!r})")
        return obj

    def info(self):
        code, body = call("GET", f"{self.api}/{self.sid}")
        if code != 200:
            refused(code, body, "reading the link")
        return json.loads(body)

    def version(self, n):
        code, body = call("GET", f"{self.api}/{self.sid}/objects/v{n}")
        if code != 200:
            refused(code, body, f"reading version {n}")
        return self.open_version(n, body)

    def auth(self, extra=None):
        return {"Authorization": "Bearer " + self.write, **(extra or {})}

    def put_version(self, obj, reserve=True):
        """Room for one version, then the version. Returns 201, or 409 when that number was taken meanwhile."""
        sealed = self.seal_version(obj)
        if reserve:
            code, body = call("POST", f"{self.api}/{self.sid}/reserve",
                              json.dumps({"bytes": len(sealed), "objects": 1}).encode(), self.auth({"Content-Type": "application/json"}))
            if code == 409:
                return 409
            if code not in (200, 201):
                refused(code, body, f"room for version {obj['version']}")
        code, body = call("PUT", f"{self.api}/{self.sid}/objects/v{obj['version']}", sealed,
                          self.auth({"Content-Type": "application/octet-stream"}))
        if code == 409:
            return 409
        if code != 201:
            refused(code, body, f"version {obj['version']}")
        return 201

def pack(obj):
    return gzip.compress(json.dumps(obj, ensure_ascii=False, separators=(",", ":")).encode("utf-8"), mtime=0)

# ------------------------------------------------------------------ folder <-> link versions
def to_link(folder, v):
    """A folder version -> the link's object: the same fields, plus the size of every media file it uses."""
    media = {}
    for mid, m in (v["project"].get("media") or {}).items():
        f = folder / m["path"]
        if not f.is_file():
            die(f"version {v['version']} uses {m['path']}, which is not in {folder}; run package.py check {folder}")
        media[mid] = {"path": m["path"], "bytes": f.stat().st_size}
    return {"format": FORMAT, **{k: v.get(k) for k in ("version", "parent", "by", "name", "note", "made", "project")},
            "media": media}

def to_folder(obj):
    return {"format": pk.VERSION_FORMAT, **{k: obj.get(k) for k in ("version", "parent", "by", "name", "note", "made", "project")}}

def sealed_size(obj):
    return len(pack(obj)) + OVERHEAD

def check_size(obj):
    n = sealed_size(obj)
    if n > MAX_OBJECT:
        die(f"version {obj['version']} is {n / 1024:.0f} KiB encrypted and a link takes at most {MAX_OBJECT // 1024} KiB "
            "per version. The folder works without the link.")
    return n

def read_state(folder):
    f = folder / STATE
    if not f.is_file():
        return None, 0
    st = json.loads(f.read_text(encoding="utf-8"))
    return Link.parse(st["link"])[0], int(st.get("version") or 0)

def write_state(folder, link, version):
    pk.write_json(folder / STATE, {"link": link.url, "version": version})
    # .studio-link holds the key: keep it out of any Git repository the folder ends up in.
    ignore = folder / ".gitignore"
    lines = ignore.read_text(encoding="utf-8").splitlines() if ignore.is_file() else []
    if STATE not in lines and f"/{STATE}" not in lines:
        ignore.write_text("\n".join([*lines, STATE]) + "\n", encoding="utf-8")

def folder_versions(folder):
    have = pk.version_files(folder)
    if not have:
        if (folder / "project.json").is_file():
            die(f"{folder} has no versions/ yet. Run package.py check {folder}; a folder made before versions gets its "
                "version 1 from package.py save.")
        die(f"no package in {folder}; run package.py build first")
    if list(have) != list(range(1, len(have) + 1)):
        die(f"the versions in {folder} have gaps; run package.py check {folder}")
    return have

def print_media_gaps(folder, obj):
    """Media the newest version uses that the folder does not hold with the same size."""
    gaps = []
    for mid, m in (obj.get("media") or {}).items():
        f = folder / str(m.get("path", ""))
        if not f.is_file():
            gaps.append(f"{mid}: {m.get('path')} ({m.get('bytes')} bytes) is not in the folder")
        elif m.get("bytes") is not None and f.stat().st_size != m["bytes"]:
            gaps.append(f"{mid}: {m.get('path')} is {f.stat().st_size} bytes here, {m['bytes']} on the link")
    if gaps:
        print("media this version needs and the folder lacks (a link never carries media; add these files to the "
              "folder before you render):")
        for g in gaps:
            print("  -", g)
    return gaps

# ------------------------------------------------------------------ commands
def cmd_send(a):
    folder = Path(a.folder).resolve()
    have = folder_versions(folder)
    old, _ = read_state(folder)
    if old and not a.new:
        die(f"{folder} already has a link. Put your newer versions on it with share.py push {folder}; use --new only "
            "for a new link (for example when the old one expired).")
    key = os.urandom(32)
    link = Link(a.site, "", key)
    objs = [to_link(folder, pk.read_version(f)) for f in have.values()]
    if a.name:
        for o in objs:
            if o["by"] == "agent" and not o.get("name"):
                o["name"] = a.name[:40]
    sizes = [check_size(o) for o in objs]
    if len(objs) > MAX_OBJECTS or sum(sizes) > MAX_LINK:
        die(f"{len(objs)} versions, {sum(sizes) / 1024:.0f} KiB encrypted: a link holds at most {MAX_OBJECTS} versions "
            f"and {MAX_LINK // 1024} KiB. The folder works without a link.")
    code, body = call("POST", link.api, json.dumps({"bytes": sizes[0], "objects": 1, "write": link.write}).encode(),
                      {"Content-Type": "application/json"})
    if code != 201:
        refused(code, body, "a new link")
    made = json.loads(body)
    link.sid = made["id"]
    for k, o in enumerate(objs):
        if link.put_version(o, reserve=k > 0) != 201:
            call("DELETE", f"{link.api}/{link.sid}", None, link.auth(), tries=1)
            die(f"version {o['version']} was refused while sending; the new link was removed")
    write_state(folder, link, len(objs))
    print(f"{len(objs)} version(s), {sum(sizes) / 1024:.1f} KiB encrypted; no media sent")
    print(f"expires {made.get('expires')}; the folder keeps every version after that" if made.get("expires") else "no end date for now; the folder keeps every version anyway")
    print("the key is the part after the #. It is stored nowhere else: keep the link whole. Written to", folder / STATE)
    print("->", link.url)

def cmd_push(a):
    folder = Path(a.folder).resolve()
    have = folder_versions(folder)
    link, mine = read_state(folder)
    if not link:
        die(f"{folder} has no link yet: share.py send {folder} makes one")
    newest = max(have)
    if newest <= mine:
        print(f"the link already has version {mine}, the folder's newest; nothing sent")
        print("->", link.url)
        return
    info = link.info()
    if info["version"] > mine:
        v = link.version(info["version"])
        die(f"version {info['version']} was saved on the link by {pk.who(v)} at {v.get('made')}, after version {mine}"
            + (f' (note: "{v["note"]}")' if v.get("note") else "") + f". Nothing sent. Run share.py pull {folder} first.")
    objs = [to_link(folder, pk.read_version(have[n])) for n in range(mine + 1, newest + 1)]
    sizes = [check_size(o) for o in objs]
    if info.get("objects", 0) + len(objs) > MAX_OBJECTS or info.get("bytes", 0) + sum(sizes) > MAX_LINK:
        die(f"the link is full ({MAX_OBJECTS} versions or {MAX_LINK // 1024} KiB). Make a new one with share.py send "
            f"{folder} --new and give the person the new link.")
    for o in objs:
        if link.put_version(o) == 409:
            die(f"someone saved version {o['version']} on the link at the same moment. Nothing more sent. Run "
                f"share.py pull {folder} first.")
        write_state(folder, link, o["version"])
        print(f"v{o['version']} sent ({pk.who(o)}" + (f', "{o["note"]}"' if o.get("note") else "") + ")")
    print(f"the link now has version {newest}; the person's studio picks it up from the same link")
    print("->", link.url)

def cmd_pull(a):
    src = Path(a.source)
    if src.is_dir() and (src / STATE).is_file():
        folder = Path(a.out or a.source).resolve()
        link, mine = read_state(src.resolve())
        pinned = a.version
    else:
        if src.is_dir():
            die(f"{src} has no link; give the link itself: share.py pull \"LINK\" --out {src}")
        if not a.out:
            die("say which folder to write into: --out result/NAME.edit")
        folder = Path(a.out).resolve()
        link, pinned = Link.parse(a.source)
        pinned = a.version or pinned
        other, mine = read_state(folder)
        if other and other.sid != link.sid:
            die(f"{folder} belongs to another link; choose another --out folder")
    info = link.info()
    if not info.get("version"):
        die("this link has no version yet")
    target = min(pinned or info["version"], info["version"])
    have = pk.version_files(folder)
    if not have and (folder / "project.json").is_file():
        die(f"{folder} has a project.json but no versions/; pull into a new folder and copy the media into it")
    fetched, clash = {}, []
    for n in range(mine + 1, target + 1):
        fetched[n] = link.version(n)
        if n in have and pk.read_version(have[n]) != to_folder(fetched[n]):
            clash.append(n)
    for n in have:                                   # folder versions the link does not know: also in the way
        if n > target and n > mine:
            clash.append(n)
    clash = sorted(set(clash))
    if clash:
        if not a.set_aside:
            die(f"the folder's version(s) {', '.join(map(str, clash))} are not the link's (saved here and never pushed, "
                f"while the link got its own). Nothing written. Run again with --set-aside: they move to "
                f"{folder / 'set-aside'} and the link's versions come in; then make your change again on top of the "
                "newest with package.py save, and push.")
        (folder / "set-aside").mkdir(exist_ok=True)
        for n in clash:
            dst = folder / "set-aside" / f"v{n}-{int(time.time())}.json"
            os.replace(have[n], dst)
            print(f"your v{n} moved to {dst}")
        have = pk.version_files(folder)
    (folder / "versions").mkdir(parents=True, exist_ok=True)
    wrote = []
    for n in range(1, target + 1):
        if n in have:
            continue
        obj = fetched.get(n) or link.version(n)
        fetched[n] = obj
        pk.write_json(folder / "versions" / f"v{n}.json", to_folder(obj), new=True)
        wrote.append(n)
    newest = fetched.get(target) or link.version(target)
    pk.write_json(folder / "project.json", newest["project"])
    write_state(folder, link, target)
    for n in wrote:
        o = fetched[n]
        print(f"v{n} by {pk.who(o)}, {o.get('made')}" + (f", from v{o['parent']}" if o.get("parent") else "")
              + (f', note: "{o["note"]}"' if o.get("note") else ""))
    print(f"wrote {len(wrote)} version(s); the folder and the link both have version {target}"
          + (f" (the link has {info['version']})" if info["version"] > target else ""))
    if newest.get("parent") and wrote:
        par = folder / "versions" / f"v{newest['parent']}.json"
        if par.is_file():
            lines = pk.change_summary(pk.read_version(par)["project"], newest["project"])
            print(f"changes from v{newest['parent']} to v{target}:" if lines else f"no changes from v{newest['parent']}")
            for line in lines:
                print("  -", line)
    print_media_gaps(folder, newest)
    print("->", folder / "project.json")
    print(f"edit a copy of it, then package.py save COPY --to {folder} --from {target}, render.py, share.py push.")

def cmd_versions(a):
    src = Path(a.source)
    if src.is_dir():
        link, mine = read_state(src.resolve())
        if not link:
            die(f"{src} has no link; package.py versions {src} lists the folder's versions")
    else:
        link, _ = Link.parse(a.source)
        mine = None
    info = link.info()
    print(f"{info['version']} version(s) on the link; " + (f"it expires {info['expires']}" if info.get("expires") else "no end date for now"))
    for n in range(info["version"], 0, -1):
        v = link.version(n)
        print(f"  v{n}  {pk.who(v)}  {v.get('made')}  " + (f"from v{v['parent']}" if v.get("parent") else "first")
              + (f'  "{v["note"]}"' if v.get("note") else "") + ("  <- the folder's link version" if n == mine else ""))

def main():
    pk.utf8_stdout()
    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    sub = ap.add_subparsers(dest="cmd", required=True)
    s = sub.add_parser("send", help="make a new link holding the folder's versions")
    s.add_argument("folder", help="the package folder (NAME.edit)")
    s.add_argument("--site", default=SITE, help="the studio to use (default: %(default)s)")
    s.add_argument("--name", default="Claude", help="your name on agent versions that have none (default: %(default)s)")
    s.add_argument("--new", action="store_true", help="make a new link even though the folder has one")
    p = sub.add_parser("push", help="put the folder's versions newer than the link's onto the link")
    p.add_argument("folder")
    g = sub.add_parser("pull", help="write the link's newer versions into the folder (never media)")
    g.add_argument("source", help="a package folder that has a link, or the whole link in quotes")
    g.add_argument("--out", help="the folder to write into (default: the folder given)")
    g.add_argument("--version", type=int, help="stop at this version instead of the newest")
    g.add_argument("--set-aside", action="store_true",
                   help="move the folder's versions that the link does not have to set-aside/, then pull")
    v = sub.add_parser("versions", help="list the versions on a link")
    v.add_argument("source", help="a package folder that has a link, or the whole link in quotes")
    a = ap.parse_args()
    {"send": cmd_send, "push": cmd_push, "pull": cmd_pull, "versions": cmd_versions}[a.cmd](a)

if __name__ == "__main__":
    main()
```

## File: skills/editable-export/references/project-format.md
size: 12707
sha: c63f86c9e5d2968f258ebb666d5bf0a72e378616
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/references/project-format.md

````text
# project.json: an edit as elements

`project.json` describes a finished short video as the elements it is made of, so the EditAtlas studio can draw
it, let the person change one element, and export the MP4 again. Format id: `editatlas-project/1`.

Everything the studio shows comes from this file. Anything burned into the footage (text you drew with FFmpeg, a
graphic baked into a clip) cannot be changed there. Put text, graphics and sounds here as elements instead.

## Top level

```json
{
  "format": "editatlas-project/1",
  "title": "Saying no",
  "canvas": {"width": 1080, "height": 1920, "fps": 30, "background": "#000000"},
  "media":  { "<id>": { ... } },
  "styles": { "<name>": { ...text properties... } },
  "tracks": [ { ... }, ... ]
}
```

Times are seconds on the timeline (the finished video), unless a field says it is source time. Positions are
fractions of the canvas: `x: 0.5, y: 0.5` is the centre. Sizes in pixels are canvas pixels.

## media

Every file the edit uses, by id. `path` is relative to `project.json` (package.py copies files into `media/`).

| kind | Fields |
|---|---|
| `video` | `path`; package.py adds `duration`, `width`, `height`, `fps`, `has_audio` |
| `audio` | `path`, optional `title`; package.py adds `duration` |
| `image` | `path` (PNG with transparency, JPG, WebP, SVG; or an animated WebP, GIF or APNG for a motion graphic) |
| `font` | `path` (TTF, OTF, WOFF, WOFF2), `family`, optional `weight` (400), `style` (`normal`/`italic`) |

Use fonts you may redistribute (Google Fonts are OFL): the font file goes into the package folder, which the
person keeps and may pass on.

## tracks

Drawn in order: later tracks are on top. Each has `id`, `kind`, `name`, optional `hidden` (picture) or `muted`
(sound).

### video: the footage, one track, clips back to back

```json
{"id": "V1", "kind": "video", "name": "Footage", "clips": [
  {"id": "c1", "media": "a-roll", "in": 0.40, "out": 5.20, "volume": 1.0,
   "fit": "cover", "x": 0.5, "y": 0.45, "scale": 1.0, "zoom_to": 1.08}
]}
```

- `in`/`out`: source time of the part used. The clip lasts `out - in` on the timeline; clips play one after the
  other with no gaps, so changing one clip's length moves everything after it (and the studio moves the overlays
  that start after it by the same amount).
- `fit`: `cover` (fill the canvas, crop) or `contain` (whole frame, bars). `x`, `y`: the point of the source kept
  in the centre when it is cropped (0.5 = middle). `scale`: extra zoom (1 = none). `zoom_to`: if given, the zoom
  moves from `scale` to `zoom_to` over the clip (a slow push-in).
- `volume`: the footage's own sound for this clip (0 mutes it).

### text: captions, hooks, titles

```json
{"id": "T1", "kind": "text", "name": "Captions", "items": [
  {"id": "t1", "style": "caption", "text": "Saying no", "at": 0.40, "dur": 0.9,
   "words": [{"at": 0.0, "dur": 0.42}, {"at": 0.42, "dur": 0.48}]}
]}
```

- `at`, `dur`: when it shows. `words`: optional, one entry per word of `text` (split on spaces), times relative
  to `at`; the word being spoken is drawn in `highlight`, and with `reveal: "word"` words appear as they are said.
- `style`: a name in `styles`. Any text property can also be set on the item itself; the item wins. In the studio,
  a change to a styled item can go to the style (every caption at once) or to that item alone.

Text properties (style or item):

| Property | Default | Meaning |
|---|---|---|
| `font`, `weight`, `italic` | `sans-serif`, 700, false | `font` is a `family` from media fonts |
| `size` | 64 | pixels |
| `color` | `#ffffff` | |
| `x`, `y` | 0.5, 0.75 | centre of the block |
| `max_width` | 0.84 | wrap width, fraction of the canvas width |
| `align` | `center` | `left`, `center`, `right` |
| `line_height` | 1.15 | times `size` |
| `case` | none | `upper` |
| `letter_spacing` | 0 | pixels |
| `stroke` | none | `{"color": "#000", "width": 8}` |
| `shadow` | none | `{"color": "rgba(0,0,0,.5)", "blur": 12, "x": 0, "y": 4}` |
| `box` | none | `{"color": "#fff", "pad_x": 24, "pad_y": 12, "radius": 14, "opacity": 1}` |
| `highlight` | none | colour of the word being spoken |
| `reveal` | `all` | `word`: words appear as they are said |
| `in`, `out` | none | `{"type": "fade" / "pop" / "slide-up", "dur": 0.15}` |
| `opacity` | 1 | |
| `rotation` | 0 | degrees |
| `strike` | none | `{"color": "#ff3b30", "width": 6, "at": 0.4, "dur": 0.3}`: a line drawn through the text, line by line, from `at` s after the item starts, over `dur` s |

### image: logos, stickers, graphics

```json
{"id": "G1", "kind": "image", "name": "Graphics", "items": [
  {"id": "g1", "media": "logo", "at": 2.0, "dur": 2.5, "x": 0.5, "y": 0.2, "width": 0.3,
   "opacity": 1, "rotation": 0, "in": {"type": "pop", "dur": 0.2}}
]}
```

`width` is a fraction of the canvas width; the height keeps the image's shape.

**Motion graphics.** A graphic you animate in code (a chart that grows, a line that draws itself, confetti, a
spinner) can stay an element: render it with a transparent background to an animated WebP and use it as an image
item. The studio draws frame n at `at + ` the time the file gives that frame, so it plays in step with the
timeline, in the preview and in the export. The person can then move it, resize it and retime it; what is drawn
inside it is fixed. Two extra fields:

| Field | Default | Meaning |
|---|---|---|
| `loop` | false | repeat the animation for the item's `dur`; otherwise it holds its last frame |
| `from` | 0 | start this many seconds into the animation |

Make one with Pillow (`frames[0].save("chart.webp", save_all=True, append_images=frames[1:], duration=33, loop=0,
lossless=False, quality=80)`) or FFmpeg (`ffmpeg -framerate 30 -i f%04d.png -c:v libwebp_anim -lossless 0 -q:v 80
-loop 0 chart.webp`). Keep each one short and only as large as it shows on screen: a full-frame 1080×1920 animation
of 2 s is about 0.7 MB, a 900×700 chart of 2.5 s about 0.2 MB. Encoders merge repeated frames into one longer
frame; the studio reads each frame's own duration, so that is fine.

Make one file per object, not one for the whole graphic: draw each object on the graphic's canvas alone, crop every
frame to the union of what the object covers (its alpha bounding box over all frames, plus its shadow), and place
the item at the crop's centre: `x = (canvas_x0 + crop_centre_x * scale) / width`, the same for `y`, and
`width = crop_width * scale / width`, where `scale` is how many video pixels one canvas pixel is. Give each item a
`label`. A month panel, its two slots, a card that flies in and a note that replaces it are five items; in the studio
the person can then nudge one slot, hide the note or move the card without touching the rest.

Words on a card are text items inside it (next section), not part of the picture: draw the card without its words,
so the person can correct a word, a price or a name in the studio.

### Cards: text and pictures inside another element

An item with `parent` is drawn inside that item, a card. Put a card's background (an image item, or a text item with
a `box`) on one track and its words on a text track:

```json
{"id": "g-yes", "media": "yes-card", "at": 1.54, "dur": 5.86, "x": 0.5, "y": 0.59, "width": 0.78, "label": "YES card"}
{"id": "yes-title", "parent": "g-yes", "style": "card", "text": "This client project", "at": 1.54, "dur": 5.86,
 "x": 0.26, "y": 0.42, "align": "left"}
{"id": "yes-pill", "parent": "g-yes", "style": "pill", "text": "YES", "at": 1.70, "dur": 5.70, "x": 0.12, "y": 0.5,
 "keys": [{"t": 0, "scale": 0.6, "opacity": 0}, {"t": 0.25, "scale": 1, "opacity": 1, "ease": "back"}]}
```

- `x`, `y` of an item inside a card are fractions of the card's box (0, 0 is its top-left corner, 0.5, 0.5 its centre),
  not of the canvas. For text, `x` is the edge `align` names: the left edge with `left`. Measure them from where you
  drew the words on the card: `x = (word_x - crop_x0) / crop_width`, `y = (line_middle_y - crop_y0) / crop_height`.
- The item moves, scales, turns and fades with its card, `in` and `keys` included. It shows only while its card shows,
  so keep its `at`…`at + dur` inside the card's. One level only: a card cannot be inside another card.
- `max_width` of an item inside a card is still a fraction of the canvas width.
- In the studio, the card's words fold under it on the timeline and show when the card is selected; moving the card
  in time moves them too, and deleting it deletes them.

### keys: motion of one element

Any text or image item can have `keys`, keyframes of its own motion, on top of `in`/`out`:

```json
"keys": [{"t": 0, "dy": 40, "opacity": 0}, {"t": 0.3, "dy": 0, "opacity": 1, "ease": "out"},
         {"t": 2.2, "rotate": 0}, {"t": 2.6, "rotate": -8, "dy": 600, "ease": "in"}]
```

| Field | Default | Meaning |
|---|---|---|
| `t` | | seconds after the item starts; keys in time order |
| `dx`, `dy` | 0 | move, in canvas pixels |
| `scale` | 1 | times the item's size |
| `rotate` | 0 | degrees, added to `rotation` |
| `opacity` | 1 | times the item's opacity |
| `ease` | `out` | how the move into this key runs: `linear`, `out`, `in`, `in-out`, `back` (overshoots, then settles), `step` |

Each field moves only between keys that set it; before its first key it holds that value, after its last key it holds
the last one. Timing that reads as premium: 0.2–0.35 s with `out` for things arriving, `back` for a pop, `in` for an
exit, and a hold of at least 0.5 s between moves. A card's keys carry its words with it.

### audio: sound effects and music

```json
{"id": "A1", "kind": "audio", "name": "Sounds", "items": [
  {"id": "s1", "media": "pop", "at": 2.68, "in": 0.0, "out": null, "gain_db": -14.0,
   "fade_in": 0.0, "fade_out": 0.01, "label": "YES badge"}
]}
```

- `at`: when the file starts on the timeline. `in`/`out`: the part of the file used (`out: null` = to its end).
- `gain_db`: applied to the file as it is (0 = the file's own level). No normalising happens later: what plays in
  the studio is what is exported.

## Ids

Every clip and item has an `id` unique in the project. Keep ids stable when you rebuild a project, so a person's
saved changes still match.

## The package folder and its versions

```
NAME.edit/
  project.json          the newest version's project: what the studio opens and render.py renders
  media/...             every file any version uses; nothing is ever deleted from here
  versions/v1.json      one file per version: 1, 2, 3 ... with no gaps
```

```json
{"format": "editatlas-version/1", "version": 2, "parent": 1, "by": "studio", "name": "", "note": "captions bigger",
 "made": "2026-11-10T12:00:00.000Z", "project": { ...the whole editatlas-project/1 object... }}
```

- `parent`: the version the writer opened and changed (`null` for version 1). Usually n-1; lower when someone saved
  from an older version.
- `by`: `agent` (written by `package.py`) or `studio` (the person). `name`: the agent's name, `""` for the studio.
- `note`: at most 500 characters. From the studio, what the person wants next; from the agent, what it did.
- `made`: ISO 8601 UTC. Media paths in `project` are relative to the folder (`media/...`).
- A writer writes `versions/v<n>.json` first, then `project.json`, and never overwrites a version file. If the
  newest version is higher than the one it opened, it refuses unless forced; forced, it still writes newest + 1,
  with `parent` = the version it opened.
- A folder with `project.json` and no `versions/` (made before versions) counts as version 1; the first save writes
  it as `versions/v1.json` first.

## The light link (optional)

`https://edit.trysometh.ing/studio#<id>.<key>` holds the same versions, with the same numbers, and nothing else: no
media. `share.py send` makes it, `push` adds the folder's newer versions, `pull` writes the link's newer versions
into the folder. Links have no end date for now (`expires` is null). `NAME.edit/.studio-link` is
`{"link": "<the whole link>", "version": <the newest version both have>}`; it holds the key, so it never goes into Git
or a message other than to the person.

- On the link, version n is the object `v<n>`: a 12-byte nonce, then AES-256-GCM of gzip of the UTF-8 JSON below,
  with `editatlas-share/2|<id>|v<n>` as additional data. The write token is HKDF-SHA256 of the key (no salt, info
  `editatlas-share/2 write`), sent as a Bearer token.
- The JSON is the folder's version with `"format": "editatlas-share/2"` and a `media` list: every media id the
  project uses, with its path in the folder and its size in bytes, so the studio can check the folder it is given.
- Limits: a version at most 256 KiB encrypted; a link at most 2 MiB and 64 versions.
````

## File: skills/editable-export/evals/apply-saved-changes/case.yaml
size: 643
sha: bd95305fb326c83aaa210c372b377152fa8e1002
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/apply-saved-changes/case.yaml

```text
schema_version: "1.1"
name: apply-saved-changes
expected_outcome: |
  The person pressed Save in the studio, which wrote tweak.edit/versions/v2.json and project.json. Claude renders the
  MP4 from tweak.edit with render.py, checks the file, and lists exactly the person's changes in version 2 (from
  package.py changes, or a comparison with version 1 or work/project.json): the hook starts 0.4 s later (0.9 s), is
  size 90 instead of 80, and the click is 3 dB softer (-9 dB). It keeps the person's version as it is, saves no new
  version since nothing more was asked, and invents no other change.
context:
  scaffold_script: place-files.sh
```

## File: skills/editable-export/evals/apply-saved-changes/graders/01-rendered-from-saved.md
size: 214
sha: 2589aaeadeeee4f4a55d7cd92c34969305e2239a
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/apply-saved-changes/graders/01-rendered-from-saved.md

```text
---
type: llm
focus: trace
weight: 1
---

Claude rendered the MP4 from tweak.edit (the person's version 2) with render.py, not with a separate FFmpeg render or from work/project.json, and checked the file it made.
```

## File: skills/editable-export/evals/apply-saved-changes/graders/02-changes-listed.md
size: 241
sha: a3925cf34af4df110cf22ed77663b5623aba2648
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/apply-saved-changes/graders/02-changes-listed.md

```text
---
type: llm
focus: output
weight: 1
---

The reply names the person's changes in version 2: the hook starts 0.4 s later and is size 90 instead of 80, and the click is 3 dB softer (-9 dB instead of -6 dB). It does not invent other changes.
```

## File: skills/editable-export/evals/apply-saved-changes/graders/03-their-version-kept.md
size: 274
sha: ff18abab6bffc4feb3968049c59a212873b23a1d
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/apply-saved-changes/graders/03-their-version-kept.md

```text
---
type: llm
focus: trace
weight: 1
---

Claude did not overwrite the person's version: tweak.edit/project.json and versions/v2.json still hold their values, and Claude did not rebuild the folder from work/project.json. It saved no version 3, since nothing more was asked.
```

## File: skills/editable-export/evals/apply-saved-changes/place-files.sh
size: 2473
sha: f6330c0a55a6e5b2086d23adc3cc37e4e24599f4
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/apply-saved-changes/place-files.sh

```text
#!/usr/bin/env bash
# Input: Claude's earlier edit in work/, and the package folder the person saved in the studio: version 1 by Claude,
# version 2 by the person (Save, no note), project.json = version 2.
set -eu
mkdir -p work tweak.edit/media tweak.edit/versions
cd work
ffmpeg -v error -f lavfi -i testsrc2=size=1080x1920:rate=30:duration=6 -c:v libx264 -pix_fmt yuv420p clip.mp4
ffmpeg -v error -f lavfi -i "sine=frequency=2000:duration=0.05" -af "afade=t=out:d=0.04" click.wav
python - <<'PY'
import json
p = {"format": "editatlas-project/1", "title": "Tweak test",
     "canvas": {"width": 1080, "height": 1920, "fps": 30, "background": "#000000"},
     "media": {"clip": {"kind": "video", "path": "clip.mp4"}, "click": {"kind": "audio", "path": "click.wav"}},
     "styles": {"hook": {"size": 80, "y": 0.2, "color": "#ffffff", "stroke": {"color": "#000000", "width": 8}}},
     "tracks": [
         {"id": "V1", "kind": "video", "name": "Footage", "clips": [{"id": "c1", "media": "clip", "in": 0, "out": 6}]},
         {"id": "T1", "kind": "text", "name": "Text", "items": [
             {"id": "hook", "style": "hook", "text": "Three ways to cut faster", "at": 0.5, "dur": 3}]},
         {"id": "A1", "kind": "audio", "name": "Sounds", "items": [
             {"id": "s-click", "media": "click", "at": 0.5, "gain_db": -6, "label": "hook in"}]}]}
import copy, shutil
json.dump(p, open("project.json", "w"), indent=1)
v1 = copy.deepcopy(p)
for m in v1["media"].values():
    m["path"] = "media/" + m["path"]
e = copy.deepcopy(v1)
e["tracks"][1]["items"][0]["at"] = 0.9
e["styles"]["hook"]["size"] = 90
e["tracks"][2]["items"][0]["gain_db"] = -9
dump = lambda o: json.dumps(o, indent=1, ensure_ascii=False) + "\n"
version = lambda n, parent, by, name, made, proj: {"format": "editatlas-version/1", "version": n, "parent": parent,
                                                   "by": by, "name": name, "note": "", "made": made, "project": proj}
open("../tweak.edit/versions/v1.json", "w", encoding="utf-8", newline="\n").write(
    dump(version(1, None, "agent", "Claude", "2026-11-10T10:00:00.000Z", v1)))
open("../tweak.edit/versions/v2.json", "w", encoding="utf-8", newline="\n").write(
    dump(version(2, 1, "studio", "", "2026-11-10T11:00:00.000Z", e)))
open("../tweak.edit/project.json", "w", encoding="utf-8", newline="\n").write(dump(e))
shutil.copy("clip.mp4", "../tweak.edit/media/clip.mp4"); shutil.copy("click.wav", "../tweak.edit/media/click.wav")
PY
```

## File: skills/editable-export/evals/apply-saved-changes/prompt.md
size: 345
sha: 3c37ca5001e09c7563cf50392bbbf7c6c6f279cd
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/apply-saved-changes/prompt.md

```text
---
tags: [editable-export]
max_turns: 50
timeout_seconds: 1500
allowed_tools: [Read, Glob, Grep, Skill, Write, Edit, Bash]
---

I opened tweak.edit in the studio, fixed a few things and pressed Save. Please make the final MP4 from my version and tell me what I changed. The project you made before is in work/.

Input files: tweak.edit/, work/
```

## File: skills/editable-export/evals/burned-in-mp4-only/case.yaml
size: 445
sha: 82897d854a10d3b4318a515026f45577ca829211
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/burned-in-mp4-only/case.yaml

```text
schema_version: "1.1"
name: burned-in-mp4-only
expected_outcome: |
  Claude explains that the captions and graphics in say-no-story.mp4 are burned into the picture, so they cannot
  become elements to move or resize, and asks for the sources (footage, caption text or transcript, sounds) or offers
  to rebuild the edit from them. It does not fake an editable package by drawing new text over the old.
context:
  scaffold_script: place-files.sh
```

## File: skills/editable-export/evals/burned-in-mp4-only/graders/01-says-burned-in.md
size: 168
sha: a4fcded64974dd9112634b63570843dd2c2d9eef
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/burned-in-mp4-only/graders/01-says-burned-in.md

```text
---
type: llm
focus: trace
weight: 1
---

Claude says, after looking at the file, that the existing captions are part of the picture and cannot be resized as elements.
```

## File: skills/editable-export/evals/burned-in-mp4-only/graders/02-asks-for-sources.md
size: 271
sha: 41862709a6d59b84dff08c42f567925e3107a40d
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/burned-in-mp4-only/graders/02-asks-for-sources.md

```text
---
type: llm
focus: trace
weight: 1
---

Claude asks for the sources it needs (raw footage, caption text or a transcript, sounds) or offers a rebuild from them, and does not hand over a package that draws new captions on top of the burned-in ones as if it were the fix.
```

## File: skills/editable-export/evals/burned-in-mp4-only/place-files.sh
size: 424
sha: f9f19d1d2b91bd26260358bcabb2aa2ca420d1b0
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/burned-in-mp4-only/place-files.sh

```text
#!/usr/bin/env bash
# Input: the public EditAtlas "say-no-story" template preview, captions burned into the picture.
# Footage credit (burned into the picture): Chris Hufnagel on YouTube, CC BY. Edited by EditAtlas.
set -eu
curl -fsSL -A "editatlas-skills-eval/1.0" ${EDITATLAS_INTERNAL:+-H "X-EditAtlas-Internal: $EDITATLAS_INTERNAL"} -o say-no-story.mp4 https://edit.trysometh.ing/template-previews/say-no-story.1.0.0.mp4
```

## File: skills/editable-export/evals/burned-in-mp4-only/prompt.md
size: 309
sha: dc1e537d9a1b91f0fc67fa1d15fc685e355235f7
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/burned-in-mp4-only/prompt.md

```text
---
tags: [editable-export]
max_turns: 30
timeout_seconds: 900
allowed_tools: [Read, Glob, Grep, Skill, Write, Edit, Bash]
---

Can you give me an editable version of say-no-story.mp4? The captions are a bit small and I want to fix that myself instead of asking you every time.

Input files: say-no-story.mp4
```

## File: skills/editable-export/evals/captions-editable/case.yaml
size: 670
sha: bcae4982d7d2367485989b01abbb4a0b02a956fa
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/captions-editable/case.yaml

```text
schema_version: "1.1"
name: captions-editable
expected_outcome: |
  A vertical 1080x1920 MP4 of talk.mp4 with captions from transcript.json, rendered with render.py from a package
  folder such as talk.edit/ (project.json with a shared caption style, media/, versions/v1.json). package.py check
  passes. Claude looked at frames of the result. It hands over the folder, makes no link without a yes (it may
  offer one), and says how to open it in the studio (Choose the folder, in Chrome or Edge), change the caption size for all captions at once, save
  (a new version in the folder) and export. It says what it did not test.
context:
  scaffold_script: place-files.sh
```

## File: skills/editable-export/evals/captions-editable/graders/01-package-built.md
size: 223
sha: 4f496f4c9bd86c50de227dee548103519a1d7b69
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/captions-editable/graders/01-package-built.md

```text
---
type: llm
focus: trace
weight: 1
---

Claude ran package.py build (with --captions, or a caption track that uses a shared style) and package.py check, and a folder with project.json, media/ and versions/v1.json exists.
```

## File: skills/editable-export/evals/captions-editable/graders/02-rendered-from-package.md
size: 223
sha: ed907a4115140e958e4055d2d637d5a74f6f64f5
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/captions-editable/graders/02-rendered-from-package.md

```text
---
type: llm
focus: trace
weight: 1
---

The delivered MP4 was made by render.py from the package (not by a separate FFmpeg render with burned-in text), and Claude checked it with ffprobe and looked at at least one frame.
```

## File: skills/editable-export/evals/captions-editable/graders/03-honest-handover.md
size: 219
sha: b219f2f1822d3db3cbd773be0e36e69a44b5cdde
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/captions-editable/graders/03-honest-handover.md

```text
---
type: llm
focus: output
weight: 1
---

The reply tells the person how to open the package in the EditAtlas studio in Chrome or Edge (Choose the folder), how to change every caption at once, and what was not tested.
```

## File: skills/editable-export/evals/captions-editable/graders/04-no-link-without-yes.md
size: 289
sha: c50f53ebcd010913ab0b0ea95c40b8e90515ad8b
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/captions-editable/graders/04-no-link-without-yes.md

```text
---
type: llm
focus: trace
weight: 1
---

Claude hands over the package folder (or a zip of it) and does not run share.py send without the person's yes: it may offer the link, saying it holds only the encrypted project text and no footage, and waits. No footage or media is sent anywhere.
```

## File: skills/editable-export/evals/captions-editable/place-files.sh
size: 846
sha: 0a4cd23ff88f0995eea50a4cd14c991567376440
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/captions-editable/place-files.sh

```text
#!/usr/bin/env bash
# Input: a 12 s landscape test film with a tone, and a word-level transcript in the transcribe skill's format.
set -eu
ffmpeg -v error -f lavfi -i testsrc2=size=1920x1080:rate=30:duration=12 -f lavfi -i sine=frequency=220:duration=12 \
  -c:v libx264 -pix_fmt yuv420p -c:a aac -shortest talk.mp4
python - <<'PY'
import json
text = ("saying no is the fastest way to protect your time every yes is a no to something else "
        "so pick the work that matters and let the rest go").split()
words, t = [], 0.3
for i, w in enumerate(text):
    words.append({"w": w, "start": round(t, 2), "end": round(t + 0.32, 2), "p": 0.95})
    t += 0.42 + (0.5 if i in (8, 17) else 0)
json.dump({"source": "talk.mp4", "duration": 12.0, "language": "en", "words": words, "checked": True},
          open("transcript.json", "w"), indent=1)
PY
```

## File: skills/editable-export/evals/captions-editable/prompt.md
size: 346
sha: 90d9ffb498218fa02e79658a6498d5c1bf435732
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/captions-editable/prompt.md

```text
---
tags: [editable-export]
max_turns: 60
timeout_seconds: 1800
allowed_tools: [Read, Glob, Grep, Skill, Write, Edit, Bash]
---

Make talk.mp4 into a vertical video with word-by-word captions from transcript.json. I'd also like an editable copy so I can move the captions or make them bigger myself later.

Input files: talk.mp4, transcript.json
```

## File: skills/editable-export/evals/continue-from-folder/case.yaml
size: 670
sha: c415b728e0b04a9f892f49552a6fbb0aadfdd59a
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/continue-from-folder/case.yaml

```text
schema_version: "1.1"
name: continue-from-folder
expected_outcome: |
  Claude reads the person's version 2 in tweak.edit (package.py versions or changes, or versions/v2.json) and lists
  their changes: the title size 96 instead of 80 and the click 0.1 s later (0.6 s), with their note. It moves the
  title up on a copy of version 2, keeping the ids and the person's values, and saves that as version 3 with
  package.py save --from 2 and a note. It renders the final MP4 from tweak.edit with render.py and checks it. It does
  not start from work/project.json or its own version 1, makes no link, and invents no other change.
context:
  scaffold_script: place-files.sh
```

## File: skills/editable-export/evals/continue-from-folder/graders/01-read-version-2.md
size: 271
sha: 2ceb3a9f13c911b2ec9dca05e76e36f76e6a6c5e
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/continue-from-folder/graders/01-read-version-2.md

```text
---
type: llm
focus: trace
weight: 1
---

Claude read the person's version 2 from tweak.edit (package.py versions or changes, versions/v2.json or the folder's project.json) before it changed or rendered anything, rather than starting from work/project.json or version 1.
```

## File: skills/editable-export/evals/continue-from-folder/graders/02-rendered-from-folder.md
size: 213
sha: dcf6e01251556eaf021763a812c1baff6fe6ef5b
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/continue-from-folder/graders/02-rendered-from-folder.md

```text
---
type: llm
focus: trace
weight: 1
---

The final MP4 was made by render.py from tweak.edit after version 3 was saved (so it has the title moved up, size 96 and the click at 0.6 s), and Claude checked the file.
```

## File: skills/editable-export/evals/continue-from-folder/graders/03-changes-listed.md
size: 174
sha: ab72effd49146eb66aea26395892d4d8be9e63e6
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/continue-from-folder/graders/03-changes-listed.md

```text
---
type: llm
focus: output
weight: 1
---

The reply names the person's changes: the title size 96 instead of 80 and the click 0.1 s later. It does not invent other changes.
```

## File: skills/editable-export/evals/continue-from-folder/graders/04-saved-version-3.md
size: 343
sha: d8c3f868dcf09c0a67060800aa710c17ebe93380
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/continue-from-folder/graders/04-saved-version-3.md

```text
---
type: llm
focus: trace
weight: 1
---

Claude saved its change as version 3 with package.py save --to tweak.edit --from 2 and a note, so tweak.edit/versions/v3.json exists with parent 2. Version 3 moves the title up and keeps the person's values (hook size 96, click at 0.6 s) and the ids, unless the reply says why it changed one of them.
```

## File: skills/editable-export/evals/continue-from-folder/place-files.sh
size: 3036
sha: 8de57631d64c5deb28516492f82a00655b95650d
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/continue-from-folder/place-files.sh

```text
#!/usr/bin/env bash
# Input: Claude's edit in work/, and the package folder tweak.edit after a round in the studio: version 1 by Claude,
# version 2 by the person (hook size 96 instead of 80, click 0.1 s later), project.json = version 2, and message.txt,
# the message the studio gave the person to paste back. No network.
set -eu
HERE="$(cd "$(dirname "$0")" && pwd)"
SCRIPTS="$HERE/../../scripts"
mkdir -p work
cd work
ffmpeg -v error -f lavfi -i testsrc2=size=1080x1920:rate=30:duration=6 -c:v libx264 -pix_fmt yuv420p clip.mp4
ffmpeg -v error -f lavfi -i "sine=frequency=2000:duration=0.05" -af "afade=t=out:d=0.04" click.wav
python - <<'PY'
import json
p = {"format": "editatlas-project/1", "title": "Tweak test",
     "canvas": {"width": 1080, "height": 1920, "fps": 30, "background": "#000000"},
     "media": {"clip": {"kind": "video", "path": "clip.mp4"}, "click": {"kind": "audio", "path": "click.wav"}},
     "styles": {"hook": {"size": 80, "y": 0.2, "color": "#ffffff", "stroke": {"color": "#000000", "width": 8}}},
     "tracks": [
         {"id": "V1", "kind": "video", "name": "Footage", "clips": [{"id": "c1", "media": "clip", "in": 0, "out": 6}]},
         {"id": "T1", "kind": "text", "name": "Text", "items": [
             {"id": "hook", "style": "hook", "text": "Three ways to cut faster", "at": 0.5, "dur": 3}]},
         {"id": "A1", "kind": "audio", "name": "Sounds", "items": [
             {"id": "s-click", "media": "click", "at": 0.5, "gain_db": -6, "label": "hook in"}]}]}
json.dump(p, open("project.json", "w"), indent=1)
PY
cd ..
python "$SCRIPTS/package.py" build work/project.json --out tweak.edit --note "title and click" > /dev/null
python - "$SCRIPTS" <<'PY'
import copy, json, sys
from datetime import datetime, timezone
from pathlib import Path
sys.path.insert(0, sys.argv[1])
from package import change_summary          # the same lines the studio writes
d = Path("tweak.edit")
v1 = json.loads((d / "versions/v1.json").read_text(encoding="utf-8"))
p = copy.deepcopy(v1["project"])
p["styles"]["hook"]["size"] = 96
p["tracks"][2]["items"][0]["at"] = 0.6
note = "title bigger, click a little later"
v2 = {"format": "editatlas-version/1", "version": 2, "parent": 1, "by": "studio", "name": "", "note": note,
      "made": datetime.now(timezone.utc).isoformat(timespec="milliseconds").replace("+00:00", "Z"), "project": p}
dump = lambda o: json.dumps(o, indent=1, ensure_ascii=False) + "\n"
(d / "versions/v2.json").write_text(dump(v2), encoding="utf-8", newline="\n")
(d / "project.json").write_text(dump(p), encoding="utf-8", newline="\n")
lines = "\n".join("- " + x for x in change_summary(v1["project"], p))
Path("message.txt").write_text(
    f'I fine-tuned "{p["title"]}" in EditAtlas Studio and saved it as version 2 in the project folder tweak.edit.\n\n'
    f"What I changed since version 1:\n{lines}\n\nNext: {note}\n\n"
    "Continue from version 2 in that folder with the editable-export skill, and save your result there as the next "
    "version.\n", encoding="utf-8", newline="\n")
PY
```

## File: skills/editable-export/evals/continue-from-folder/prompt.md
size: 406
sha: acd93b74519a6e40edbed20763639fb626337b9e
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/continue-from-folder/prompt.md

```text
---
tags: [editable-export]
max_turns: 60
timeout_seconds: 1800
allowed_tools: [Read, Glob, Grep, Skill, Write, Edit, Bash]
---

I made a few fixes in the studio and pressed Continue with Claude. The message it gave me is in message.txt. The title also sits a little too low: move it up a bit. Then finish the video from my version and tell me what I changed.

Input files: message.txt, tweak.edit/, work/
```

## File: skills/editable-export/evals/continue-from-link/case.yaml
size: 727
sha: 715bcfd24c9eccf0994ad88a950d8967aa6de5d3
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/continue-from-link/case.yaml

```text
schema_version: "1.1"
name: continue-from-link
expected_outcome: |
  The person's version 2 is only on the link. Claude pulls it into tweak.edit with share.py pull (no media come with
  it; the folder already has them) and lists their changes: the title size 96 instead of 80 and the click 0.1 s later
  (0.6 s), with their note. It moves the title up on a copy of version 2, keeping the ids and their values, saves it
  as version 3 with package.py save --from 2, renders the final MP4 from tweak.edit with render.py and checks it, and
  puts version 3 on the same link with share.py push. It does not make a new link, start from work/project.json or
  version 1, or invent changes.
context:
  scaffold_script: place-files.sh
```

## File: skills/editable-export/evals/continue-from-link/graders/01-pulled-version-2.md
size: 270
sha: c80d552902a3eba9534f1835a88182f220f22675
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/continue-from-link/graders/01-pulled-version-2.md

```text
---
type: llm
focus: trace
weight: 1
---

Claude ran share.py pull on tweak.edit (or on the link with --out tweak.edit) before it changed or rendered anything, so tweak.edit/versions/v2.json by the studio exists, rather than working from work/project.json or version 1.
```

## File: skills/editable-export/evals/continue-from-link/graders/02-rendered-from-folder.md
size: 192
sha: ff6e6faf1fb302b27ad0c6864b63fd803e7f8d2d
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/continue-from-link/graders/02-rendered-from-folder.md

```text
---
type: llm
focus: trace
weight: 1
---

The final MP4 was made by render.py from tweak.edit after version 3 was saved (title moved up, size 96, click at 0.6 s), and Claude checked the file.
```

## File: skills/editable-export/evals/continue-from-link/graders/03-changes-listed.md
size: 174
sha: ab72effd49146eb66aea26395892d4d8be9e63e6
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/continue-from-link/graders/03-changes-listed.md

```text
---
type: llm
focus: output
weight: 1
---

The reply names the person's changes: the title size 96 instead of 80 and the click 0.1 s later. It does not invent other changes.
```

## File: skills/editable-export/evals/continue-from-link/graders/04-pushed-version-3.md
size: 323
sha: 4174bcd28aaac1db3cc6e2eb5479fb1fdca5dd71
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/continue-from-link/graders/04-pushed-version-3.md

```text
---
type: llm
focus: trace
weight: 1
---

Claude saved its change as version 3 with package.py save --from 2 and then ran share.py push tweak.edit, so the same link (not a new one) holds version 3. Version 3 keeps the person's values (size 96, click at 0.6 s) and the ids, unless the reply says why it changed one of them.
```

## File: skills/editable-export/evals/continue-from-link/place-files.sh
size: 2082
sha: a6856bb4c18d03a4667b8fa6c8a334aed12d6ba5
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/continue-from-link/place-files.sh

```text
#!/usr/bin/env bash
# Input: Claude's edit in work/, its package folder tweak.edit (version 1) with a real light studio link, and the
# person's version 2 on that link only (title size 96 instead of 80, click 0.1 s later), saved by a helper that acts
# as the studio. message.txt is what the studio gives the person to paste back, with the link.
# Needs network, the cryptography package, and the studio's share service; set EDITATLAS_INTERNAL for EditAtlas's own
# runs so they stay out of its numbers. EDITATLAS_SITE points it at another studio (a local one).
set -eu
HERE="$(cd "$(dirname "$0")" && pwd)"
SCRIPTS="$HERE/../../scripts"
mkdir -p work
cd work
ffmpeg -v error -f lavfi -i testsrc2=size=1080x1920:rate=30:duration=6 -c:v libx264 -pix_fmt yuv420p clip.mp4
ffmpeg -v error -f lavfi -i "sine=frequency=2000:duration=0.05" -af "afade=t=out:d=0.04" click.wav
python - <<'PY'
import json
p = {"format": "editatlas-project/1", "title": "Tweak test",
     "canvas": {"width": 1080, "height": 1920, "fps": 30, "background": "#000000"},
     "media": {"clip": {"kind": "video", "path": "clip.mp4"}, "click": {"kind": "audio", "path": "click.wav"}},
     "styles": {"hook": {"size": 80, "y": 0.2, "color": "#ffffff", "stroke": {"color": "#000000", "width": 8}}},
     "tracks": [
         {"id": "V1", "kind": "video", "name": "Footage", "clips": [{"id": "c1", "media": "clip", "in": 0, "out": 6}]},
         {"id": "T1", "kind": "text", "name": "Text", "items": [
             {"id": "hook", "style": "hook", "text": "Three ways to cut faster", "at": 0.5, "dur": 3}]},
         {"id": "A1", "kind": "audio", "name": "Sounds", "items": [
             {"id": "s-click", "media": "click", "at": 0.5, "gain_db": -6, "label": "hook in"}]}]}
json.dump(p, open("project.json", "w"), indent=1)
PY
cd ..
python "$SCRIPTS/package.py" build work/project.json --out tweak.edit --note "title and click" > /dev/null
python "$SCRIPTS/share.py" send tweak.edit --site "${EDITATLAS_SITE:-https://edit.trysometh.ing}" > /dev/null
python "$HERE/studio_saves.py" "$SCRIPTS" tweak.edit > /dev/null
```

## File: skills/editable-export/evals/continue-from-link/prompt.md
size: 399
sha: 3d0027d9cc2fe0c8825954df4fe7173a8a0e87d5
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/continue-from-link/prompt.md

```text
---
tags: [editable-export]
max_turns: 60
timeout_seconds: 1800
allowed_tools: [Read, Glob, Grep, Skill, Write, Edit, Bash]
---

I made a few fixes in the studio from the link you gave me. The message it gave me is in message.txt. The title also sits a little too low: move it up a bit. Then finish the video from my version and tell me what I changed.

Input files: message.txt, tweak.edit/, work/
```

## File: skills/editable-export/evals/continue-from-link/studio_saves.py
size: 2099
sha: 48a61910328a1fa34c385c2b2eb5f36c49d624f2
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/continue-from-link/studio_saves.py

```text
"""Scaffold helper for continue-from-link: acts as the person in the studio. It reads the newest version on the
folder's link, makes the title bigger (80 -> 96) and the click 0.1 s later, puts that on the link as the next version
(by "studio", with a note) and writes message.txt, what the studio gives the person to paste back. It does not touch
the folder: the person's own copy is elsewhere, so Claude has to pull.

  python studio_saves.py SCRIPTS_DIR FOLDER
"""
import copy, json, sys
from datetime import datetime, timezone
from pathlib import Path

sys.path.insert(0, sys.argv[1])
import share  # noqa: E402
from package import change_summary  # noqa: E402

folder = Path(sys.argv[2])
link, _ = share.read_state(folder)
info = link.info()
was = link.version(info["version"])
p = copy.deepcopy(was["project"])
p["styles"]["hook"]["size"] = 96
click = next(t for t in p["tracks"] if t["kind"] == "audio")["items"][0]
click["at"] = round(click["at"] + 0.1, 3)
n, note = info["version"] + 1, "title bigger, click a little later"
obj = {"format": share.FORMAT, "version": n, "parent": info["version"], "by": "studio", "name": "", "note": note,
       "made": datetime.now(timezone.utc).isoformat(timespec="milliseconds").replace("+00:00", "Z"), "project": p,
       "media": was["media"]}
if link.put_version(obj) != 201:
    sys.exit("studio_saves: the link refused the version")
lines = "\n".join("- " + x for x in change_summary(was["project"], p))
# The studio's own wording when the person opened the link without the folder (forAgent in studio-editor.js).
Path("message.txt").write_text(
    f'I fine-tuned "{p["title"]}" in EditAtlas Studio and saved it as version {n} on the studio link.\n'
    f"Link: {link.url}\n\nWhat I changed since version {n - 1}:\n{lines}\n\nNext: {note}\n\n"
    f"Continue from version {n} with the editable-export skill: pull it from the link into the project folder "
    f"(share.py pull), and save your result as the next version there and on the link (share.py push).\n",
    encoding="utf-8", newline="\n")
print(f"version {n} on the link, by the studio")
```

## File: skills/editable-export/evals/no-offer-subtitles-only/case.yaml
size: 328
sha: 687b95b74a0722a4e688a607adda36b9985fa808
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/no-offer-subtitles-only/case.yaml

```text
schema_version: "1.1"
name: no-offer-subtitles-only
expected_outcome: |
  Claude writes talk.srt from transcript.json with about 3 words per subtitle and the word times. It does not
  build an editable package or offer a studio copy: the person asked for a subtitle file, not a video.
context:
  scaffold_script: place-files.sh
```

## File: skills/editable-export/evals/no-offer-subtitles-only/graders/01-srt-written.md
size: 129
sha: b82702712c9bfd2b3322447660df148ab0ac10b9
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/no-offer-subtitles-only/graders/01-srt-written.md

```text
---
type: llm
focus: trace
weight: 1
---

talk.srt exists, with about 3 words per subtitle and times taken from transcript.json.
```

## File: skills/editable-export/evals/no-offer-subtitles-only/graders/02-no-studio-copy.md
size: 180
sha: a2582c39a413241fac85f45ad97f4ad3f33275d4
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/no-offer-subtitles-only/graders/02-no-studio-copy.md

```text
---
type: llm
focus: output
weight: 1
---

Claude neither builds an editable package nor offers an editable copy in the EditAtlas studio, since only a subtitle file was asked for.
```

## File: skills/editable-export/evals/no-offer-subtitles-only/place-files.sh
size: 831
sha: 95eddfb4e115464f725af4bf19610d68700f6678
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/no-offer-subtitles-only/place-files.sh

```text
#!/usr/bin/env bash
# Input: a 12 s test film with a tone, and a word-level transcript (same as captions-editable).
set -eu
ffmpeg -v error -f lavfi -i testsrc2=size=1920x1080:rate=30:duration=12 -f lavfi -i sine=frequency=220:duration=12 \
  -c:v libx264 -pix_fmt yuv420p -c:a aac -shortest talk.mp4
python - <<'PY'
import json
text = ("saying no is the fastest way to protect your time every yes is a no to something else "
        "so pick the work that matters and let the rest go").split()
words, t = [], 0.3
for i, w in enumerate(text):
    words.append({"w": w, "start": round(t, 2), "end": round(t + 0.32, 2), "p": 0.95})
    t += 0.42 + (0.5 if i in (8, 17) else 0)
json.dump({"source": "talk.mp4", "duration": 12.0, "language": "en", "words": words, "checked": True},
          open("transcript.json", "w"), indent=1)
PY
```

## File: skills/editable-export/evals/no-offer-subtitles-only/prompt.md
size: 248
sha: f15f97baaace0164c53c8fbd05c07c17500bb67d
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/no-offer-subtitles-only/prompt.md

```text
---
tags: [editable-export]
max_turns: 30
timeout_seconds: 900
allowed_tools: [Read, Glob, Grep, Skill, Write, Edit, Bash]
---

Make an SRT file for talk.mp4 from transcript.json, about 3 words per subtitle.

Input files: talk.mp4, transcript.json
```

## File: skills/editable-export/evals/offer-at-delivery/case.yaml
size: 416
sha: 64b33c994786d3a0df2747979d1e216fc4d4d7d1
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/offer-at-delivery/case.yaml

```text
schema_version: "1.1"
name: offer-at-delivery
expected_outcome: |
  Claude makes the MP4 (1080x1920, the title for the first 3 seconds, a click when it appears) and delivers it. In
  the delivery it offers, once, an editable copy that the person can open in the EditAtlas studio to fix small things
  themselves. It hands over that copy, or makes a link, only after a yes.
context:
  scaffold_script: place-files.sh
```

## File: skills/editable-export/evals/offer-at-delivery/graders/01-delivered-mp4.md
size: 163
sha: 36cc93f0db3c6ffad88666ea483d197e6b3cafa1
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/offer-at-delivery/graders/01-delivered-mp4.md

```text
---
type: llm
focus: trace
weight: 1
---

Claude delivered an MP4 of clip.mp4 with the title on screen in the first 3 seconds and the click, and checked the file.
```

## File: skills/editable-export/evals/offer-at-delivery/graders/02-offers-editable-copy.md
size: 213
sha: 37c25c269acebcedef7151ec5aef3e28770ffe98
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/offer-at-delivery/graders/02-offers-editable-copy.md

```text
---
type: llm
focus: output
weight: 1
---

The reply offers an editable copy the person can open in the EditAtlas studio to fix small things themselves (such as the title or the click timing), once, as an option.
```

## File: skills/editable-export/evals/offer-at-delivery/graders/03-builds-only-after-yes.md
size: 392
sha: 513095368c4ab6f81165e22a03862cf9291e68a6
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/offer-at-delivery/graders/03-builds-only-after-yes.md

```text
---
type: llm
focus: trace
weight: 1
---

Claude does not hand over an editable copy the person did not ask for: it offers it and waits for a yes before giving them a package folder or a zip to open in the studio. Building a package only to render the delivered MP4 with render.py is fine, as long as it is not presented as handed over. It makes no link (share.py send) without a yes either.
```

## File: skills/editable-export/evals/offer-at-delivery/place-files.sh
size: 284
sha: 2a1e4ca281ab06dc45a693c170b843b3529ada98
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/offer-at-delivery/place-files.sh

```text
#!/usr/bin/env bash
# Input: a 6 s vertical test clip and a click.
set -eu
ffmpeg -v error -f lavfi -i testsrc2=size=1080x1920:rate=30:duration=6 -c:v libx264 -pix_fmt yuv420p clip.mp4
ffmpeg -v error -f lavfi -i "sine=frequency=2000:duration=0.05" -af "afade=t=out:d=0.04" click.wav
```

## File: skills/editable-export/evals/offer-at-delivery/prompt.md
size: 292
sha: 72985f1b7dd15137a56bc7ac58de8b686ddeb16d
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/evals/offer-at-delivery/prompt.md

```text
---
tags: [editable-export]
max_turns: 50
timeout_seconds: 1500
allowed_tools: [Read, Glob, Grep, Skill, Write, Edit, Bash]
---

Put the title "Three ways to cut faster" on clip.mp4 for the first 3 seconds, with a click when it appears, and give me the MP4.

Input files: clip.mp4, click.wav
```

## File: skills/editable-export/LICENSE.txt
size: 11358
sha: d645695673349e3947e8e5ae42332d0ac3164cd7
upstream: https://github.com/editatlas/skills/blob/main/skills/editable-export/LICENSE.txt

```text

                                 Apache License
                           Version 2.0, January 2004
                        http://www.apache.org/licenses/

   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

   1. Definitions.

      "License" shall mean the terms and conditions for use, reproduction,
      and distribution as defined by Sections 1 through 9 of this document.

      "Licensor" shall mean the copyright owner or entity authorized by
      the copyright owner that is granting the License.

      "Legal Entity" shall mean the union of the acting entity and all
      other entities that control, are controlled by, or are under common
      control with that entity. For the purposes of this definition,
      "control" means (i) the power, direct or indirect, to cause the
      direction or management of such entity, whether by contract or
      otherwise, or (ii) ownership of fifty percent (50%) or more of the
      outstanding shares, or (iii) beneficial ownership of such entity.

      "You" (or "Your") shall mean an individual or Legal Entity
      exercising permissions granted by this License.

      "Source" form shall mean the preferred form for making modifications,
      including but not limited to software source code, documentation
      source, and configuration files.

      "Object" form shall mean any form resulting from mechanical
      transformation or translation of a Source form, including but
      not limited to compiled object code, generated documentation,
      and conversions to other media types.

      "Work" shall mean the work of authorship, whether in Source or
      Object form, made available under the License, as indicated by a
      copyright notice that is included in or attached to the work
      (an example is provided in the Appendix below).

      "Derivative Works" shall mean any work, whether in Source or Object
      form, that is based on (or derived from) the Work and for which the
      editorial revisions, annotations, elaborations, or other modifications
      represent, as a whole, an original work of authorship. For the purposes
      of this License, Derivative Works shall not include works that remain
      separable from, or merely link (or bind by name) to the interfaces of,
      the Work and Derivative Works thereof.

      "Contribution" shall mean any work of authorship, including
      the original version of the Work and any modifications or additions
      to that Work or Derivative Works thereof, that is intentionally
      submitted to Licensor for inclusion in the Work by the copyright owner
      or by an individual or Legal Entity authorized to submit on behalf of
      the copyright owner. For the purposes of this definition, "submitted"
      means any form of electronic, verbal, or written communication sent
      to the Licensor or its representatives, including but not limited to
      communication on electronic mailing lists, source code control systems,
      and issue tracking systems that are managed by, or on behalf of, the
      Licensor for the purpose of discussing and improving the Work, but
      excluding communication that is conspicuously marked or otherwise
      designated in writing by the copyright owner as "Not a Contribution."

      "Contributor" shall mean Licensor and any individual or Legal Entity
      on behalf of whom a Contribution has been received by Licensor and
      subsequently incorporated within the Work.

   2. Grant of Copyright License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      copyright license to reproduce, prepare Derivative Works of,
      publicly display, publicly perform, sublicense, and distribute the
      Work and such Derivative Works in Source or Object form.

   3. Grant of Patent License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      (except as stated in this section) patent license to make, have made,
      use, offer to sell, sell, import, and otherwise transfer the Work,
      where such license applies only to those patent claims licensable
      by such Contributor that are necessarily infringed by their
      Contribution(s) alone or by combination of their Contribution(s)
      with the Work to which such Contribution(s) was submitted. If You
      institute patent litigation against any entity (including a
      cross-claim or counterclaim in a lawsuit) alleging that the Work
      or a Contribution incorporated within the Work constitutes direct
      or contributory patent infringement, then any patent licenses
      granted to You under this License for that Work shall terminate
      as of the date such litigation is filed.

   4. Redistribution. You may reproduce and distribute copies of the
      Work or Derivative Works thereof in any medium, with or without
      modifications, and in Source or Object form, provided that You
      meet the following conditions:

      (a) You must give any other recipients of the Work or
          Derivative Works a copy of this License; and

      (b) You must cause any modified files to carry prominent notices
          stating that You changed the files; and

      (c) You must retain, in the Source form of any Derivative Works
          that You distribute, all copyright, patent, trademark, and
          attribution notices from the Source form of the Work,
          excluding those notices that do not pertain to any part of
          the Derivative Works; and

      (d) If the Work includes a "NOTICE" text file as part of its
          distribution, then any Derivative Works that You distribute must
          include a readable copy of the attribution notices contained
          within such NOTICE file, excluding those notices that do not
          pertain to any part of the Derivative Works, in at least one
          of the following places: within a NOTICE text file distributed
          as part of the Derivative Works; within the Source form or
          documentation, if provided along with the Derivative Works; or,
          within a display generated by the Derivative Works, if and
          wherever such third-party notices normally appear. The contents
          of the NOTICE file are for informational purposes only and
          do not modify the License. You may add Your own attribution
          notices within Derivative Works that You distribute, alongside
          or as an addendum to the NOTICE text from the Work, provided
          that such additional attribution notices cannot be construed
          as modifying the License.

      You may add Your own copyright statement to Your modifications and
      may provide additional or different license terms and conditions
      for use, reproduction, or distribution of Your modifications, or
      for any such Derivative Works as a whole, provided Your use,
      reproduction, and distribution of the Work otherwise complies with
      the conditions stated in this License.

   5. Submission of Contributions. Unless You explicitly state otherwise,
      any Contribution intentionally submitted for inclusion in the Work
      by You to the Licensor shall be under the terms and conditions of
      this License, without any additional terms or conditions.
      Notwithstanding the above, nothing herein shall supersede or modify
      the terms of any separate license agreement you may have executed
      with Licensor regarding such Contributions.

   6. Trademarks. This License does not grant permission to use the trade
      names, trademarks, service marks, or product names of the Licensor,
      except as required for reasonable and customary use in describing the
      origin of the Work and reproducing the content of the NOTICE file.

   7. Disclaimer of Warranty. Unless required by applicable law or
      agreed to in writing, Licensor provides the Work (and each
      Contributor provides its Contributions) on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
      implied, including, without limitation, any warranties or conditions
      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
      PARTICULAR PURPOSE. You are solely responsible for determining the
      appropriateness of using or redistributing the Work and assume any
      risks associated with Your exercise of permissions under this License.

   8. Limitation of Liability. In no event and under no legal theory,
      whether in tort (including negligence), contract, or otherwise,
      unless required by applicable law (such as deliberate and grossly
      negligent acts) or agreed to in writing, shall any Contributor be
      liable to You for damages, including any direct, indirect, special,
      incidental, or consequential damages of any character arising as a
      result of this License or out of the use or inability to use the
      Work (including but not limited to damages for loss of goodwill,
      work stoppage, computer failure or malfunction, or any and all
      other commercial damages or losses), even if such Contributor
      has been advised of the possibility of such damages.

   9. Accepting Warranty or Additional Liability. While redistributing
      the Work or Derivative Works thereof, You may choose to offer,
      and charge a fee for, acceptance of support, warranty, indemnity,
      or other liability obligations and/or rights consistent with this
      License. However, in accepting such obligations, You may act only
      on Your own behalf and on Your sole responsibility, not on behalf
      of any other Contributor, and only if You agree to indemnify,
      defend, and hold each Contributor harmless for any liability
      incurred by, or claims asserted against, such Contributor by reason
      of your accepting any such warranty or additional liability.

   END OF TERMS AND CONDITIONS

   APPENDIX: How to apply the Apache License to your work.

      To apply the Apache License to your work, attach the following
      boilerplate notice, with the fields enclosed by brackets "[]"
      replaced with your own identifying information. (Don't include
      the brackets!)  The text should be enclosed in the appropriate
      comment syntax for the file format. We also recommend that a
      file or class name and description of purpose be included on the
      same "printed page" as the copyright notice for easier
      identification within third-party archives.

   Copyright [yyyy] [name of copyright owner]

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
```
