⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

v0.3.8

editable-export

editatlas@editatlas⭐ 36 stars· last commit 2d ago· 0 open issues

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.

Choose how to use this skill

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

1. Native installer

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

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

2. Complete package recommended

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

No complete ProSkills package is published for this listing yet.

3. Prompt-only

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

Need only the instruction file?

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

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

—/10

// RATINGS

⭐GitHub Stars
⭐⭐ 36 on GitHubGitHub ↗

Growing

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

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, 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.2).

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

ElementOn the pictureIn the panelOn the timeline
Textclick, drag (snaps to the centre), corner to resizetext, size, colour, font (the project's, 18 from EditAtlas with Vietnamese, or a file of their own) and weight, position, timing, italic, capitals, align, line width, spacing, shadow, how it appears and leaves; for a style, this one (the default) or all items; copy, paste at the playhead, duplicate; copy the look of one text onto another; add a new text; split at the playhead (between the words when they have timings)move, trim both ends
Graphicsclick, drag, corner to resizeposition, size, opacity, timing; copy, paste, duplicatemove, trim
Sounds and musicnudge by a frame, level in dB, fades; copy, paste, duplicate; split at the playheadmove, trim, mute a track; a volume line: drag it, double-click to add points, drag the fade dots
Clipsdrag to reframe, corner to zoomtrim in and out by a frame; what comes after moves with it; speed (0.25× to 4×); a transition into the clip (dissolve, dip to black or white, slide, wipe); split at the playhead; move earlier or later; duplicate; delete, with the text and sounds on ittrim the edges, split (S), drag to another place; a line for the footage's sound

Add media (or files dropped on the page) adds footage, pictures and sounds from the person's computer: a clip after the one under the playhead, a picture or a sound at the playhead. Save copies the files into the folder.

Several texts, graphics and sounds can be picked at once (Shift or Ctrl+click, a box drawn on the timeline, Ctrl+A for a layer) and moved, nudged, resized, coloured, copied or deleted together. The picture zooms in (up to 400 %) and Bigger picture hides the timeline; Guides show the centre lines and, on a vertical video, the area that app buttons leave clear. 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

PathWhat
SKILL.mdThe workflow Claude follows
references/project-format.mdproject.json: an edit as elements (editatlas-project/1)
scripts/package.pybuild: 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.pyRuns the studio's own export in Chrome or Edge without a window: the video Claude delivers
scripts/share.pyThe 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

// HOW IT'S BUILT

// FILES

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

  • skills/editable-export/SKILL.md18 KB9bb07d4cc8d2upstream ↗
    ---
    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.
    
  • skills/editable-export/README.md9.3 KB69f8c02ed185upstream ↗
    # 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
    
  • skills/editable-export/scripts/package.py39 KBed7c4e7eaf94upstream ↗

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

  • skills/editable-export/scripts/render.py6.8 KB85d430b9f75dupstream ↗
    """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()
    
  • skills/editable-export/scripts/share.py21 KB68bc6a11f8a1upstream ↗
    """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()
    
  • skills/editable-export/references/project-format.md12 KBc63f86c9e5d2upstream ↗
    # 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.
    
  • skills/editable-export/evals/apply-saved-changes/case.yaml643 Bbd95305fb326upstream ↗
    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
    
  • skills/editable-export/evals/apply-saved-changes/graders/01-rendered-from-saved.md214 B2589aaeadeeeupstream ↗
    ---
    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.
    
  • skills/editable-export/evals/apply-saved-changes/graders/02-changes-listed.md241 Ba3925cf34af4upstream ↗
    ---
    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.
    
  • skills/editable-export/evals/apply-saved-changes/graders/03-their-version-kept.md274 Bff18abab6bffupstream ↗
    ---
    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.
    
  • skills/editable-export/evals/apply-saved-changes/place-files.sh2.4 KBf6330c0a55a6upstream ↗
    #!/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
    
  • skills/editable-export/evals/apply-saved-changes/prompt.md345 B3c37ca5001e0upstream ↗
    ---
    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/
    
  • skills/editable-export/evals/burned-in-mp4-only/case.yaml445 B82897d854a10upstream ↗
    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
    
  • skills/editable-export/evals/burned-in-mp4-only/graders/01-says-burned-in.md168 Ba4fcded64974upstream ↗
    ---
    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.
    
  • skills/editable-export/evals/burned-in-mp4-only/graders/02-asks-for-sources.md271 B41862709a6d5upstream ↗
    ---
    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.
    
  • skills/editable-export/evals/burned-in-mp4-only/place-files.sh424 Bf9f19d1d2b91upstream ↗
    #!/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
    
  • skills/editable-export/evals/burned-in-mp4-only/prompt.md309 Bdc1e537d9a1bupstream ↗
    ---
    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
    
  • skills/editable-export/evals/captions-editable/case.yaml670 Bbcae4982d7d2upstream ↗
    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
    
  • skills/editable-export/evals/captions-editable/graders/01-package-built.md223 B4f496f4c9bd8upstream ↗
    ---
    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.
    
  • skills/editable-export/evals/captions-editable/graders/02-rendered-from-package.md223 Bed907a411514upstream ↗
    ---
    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.
    
  • skills/editable-export/evals/captions-editable/graders/03-honest-handover.md219 Bb219f2f1822dupstream ↗
    ---
    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.
    
  • skills/editable-export/evals/captions-editable/graders/04-no-link-without-yes.md289 Bc50f53ebcd01upstream ↗
    ---
    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.
    
  • skills/editable-export/evals/captions-editable/place-files.sh846 B0a4cd23ff88fupstream ↗
    #!/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
    
  • skills/editable-export/evals/captions-editable/prompt.md346 B90d9ffb49821upstream ↗
    ---
    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
    
  • skills/editable-export/evals/continue-from-folder/case.yaml670 Bc415b728e0b0upstream ↗
    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
    
  • skills/editable-export/evals/continue-from-folder/graders/01-read-version-2.md271 B2ceb3a9f13c9upstream ↗
    ---
    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.
    
  • skills/editable-export/evals/continue-from-folder/graders/02-rendered-from-folder.md213 Bdcf6e0125155upstream ↗
    ---
    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.
    
  • skills/editable-export/evals/continue-from-folder/graders/03-changes-listed.md174 Bab72effd4914upstream ↗
    ---
    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.
    
  • skills/editable-export/evals/continue-from-folder/graders/04-saved-version-3.md343 Bd8c3f868dcf0upstream ↗
    ---
    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.
    
  • skills/editable-export/evals/continue-from-folder/place-files.sh3.0 KB8de57631d64cupstream ↗
    #!/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
    
  • skills/editable-export/evals/continue-from-folder/prompt.md406 Bacd93b74519aupstream ↗
    ---
    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/
    
  • skills/editable-export/evals/continue-from-link/case.yaml727 B715bcfd24c9eupstream ↗
    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
    
  • skills/editable-export/evals/continue-from-link/graders/01-pulled-version-2.md270 Bc80d552902a3upstream ↗
    ---
    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.
    
  • skills/editable-export/evals/continue-from-link/graders/02-rendered-from-folder.md192 Bff6e6faf1fb3upstream ↗
    ---
    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.
    
  • skills/editable-export/evals/continue-from-link/graders/03-changes-listed.md174 Bab72effd4914upstream ↗
    ---
    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.
    
  • skills/editable-export/evals/continue-from-link/graders/04-pushed-version-3.md323 B4174bcd28aaaupstream ↗
    ---
    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.
    
  • skills/editable-export/evals/continue-from-link/place-files.sh2.0 KBa6856bb4c18dupstream ↗
    #!/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
    
  • skills/editable-export/evals/continue-from-link/prompt.md399 B3d0027d9cc2fupstream ↗
    ---
    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/
    
  • skills/editable-export/evals/continue-from-link/studio_saves.py2.0 KB48a61910328aupstream ↗
    """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")
    
  • skills/editable-export/evals/no-offer-subtitles-only/case.yaml328 B687b95b74a07upstream ↗
    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
    
  • skills/editable-export/evals/no-offer-subtitles-only/graders/01-srt-written.md129 Bb82702712c9bupstream ↗
    ---
    type: llm
    focus: trace
    weight: 1
    ---
    
    talk.srt exists, with about 3 words per subtitle and times taken from transcript.json.
    
  • skills/editable-export/evals/no-offer-subtitles-only/graders/02-no-studio-copy.md180 Ba2582c39a413upstream ↗
    ---
    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.
    
  • skills/editable-export/evals/no-offer-subtitles-only/place-files.sh831 B95eddfb4e115upstream ↗
    #!/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
    
  • skills/editable-export/evals/no-offer-subtitles-only/prompt.md248 Bf15f97baaaceupstream ↗
    ---
    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
    
  • skills/editable-export/evals/offer-at-delivery/case.yaml416 B64b33c994786upstream ↗
    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
    
  • skills/editable-export/evals/offer-at-delivery/graders/01-delivered-mp4.md163 B36cc93f0db3cupstream ↗
    ---
    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.
    
  • skills/editable-export/evals/offer-at-delivery/graders/02-offers-editable-copy.md213 B37c25c269aceupstream ↗
    ---
    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.
    
  • skills/editable-export/evals/offer-at-delivery/graders/03-builds-only-after-yes.md392 B513095368c4aupstream ↗
    ---
    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.
    
  • skills/editable-export/evals/offer-at-delivery/place-files.sh284 B2a1e4ca281abupstream ↗
    #!/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
    
  • skills/editable-export/evals/offer-at-delivery/prompt.md292 B72985f1b7dd1upstream ↗
    ---
    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
    
  • skills/editable-export/LICENSE.txt11 KBd64569567334upstream ↗
    
                                     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.
    

Plain-text copy, no login: /skill-bundles/editatlas-skills-skills-editable-export.md

// REPO STATS

36 stars
0 open issues
Last commit: 2d ago