renoise-kit 0.5.1__tar.gz → 0.6.0__tar.gz

{renoise_kit-0.5.1/renoise_kit.egg-info → renoise_kit-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: renoise-kit
-Version: 0.5.1
+Version: 0.6.0
 Summary: rn: frame-exact probing, contact sheets, EDL assembly, finishing and QA for AI video edits
 License-Expression: MIT
 Project-URL: Homepage, https://renoise.ai
@@ -115,16 +115,17 @@ window.renderFrame = i => {
 
 ```json
 {
+  "version": 2,
   "output": {"width": 1080, "height": 1920, "fps": 30},
   "tracks": [
     {"clips": [
       {"id": "open", "src": "shots/s1.mp4", "in": 0.4, "out": 3.2},
       {"id": "hero", "src": "shots/s2.mp4", "ranges": [[0, 1.5], [2.5, 4]],
        "transition": {"type": "fade", "duration": 0.3}},
-      {"id": "end", "image": "card.png", "duration": 1.5, "fit": "contain"}
+      {"id": "end", "image": "card.png", "duration": 1.5, "style": {"object-fit": "contain"}}
     ]},
     {"clips": [
-      {"id": "title", "frames": "title/%05d.png", "fps": 30, "y": 1500,
+      {"id": "title", "frames": "title/%05d.png", "fps": 30, "style": {"top": 1500},
        "at": {"clip": "hero", "offset": 0.2}, "until": {"clip_end": "hero"}}
     ]}
   ],
@@ -210,7 +211,7 @@ rn edit edit.json delete end --lift
 
 | Command | What it gives |
 |---|---|
-| `rn edit EDL ids\|set\|split\|delete\|insert\|move` | Changes an EDL by clip id. Each step is checked against the whole timeline before the file is written |
+| `rn edit EDL ids\|set\|split\|delete\|insert\|move\|upgrade` | Changes an EDL by clip id. Each step is checked against the whole timeline before the file is written |
 | `rn assemble EDL -o OUT [--preview] [--range A-B] [--placeholders]` | Renders the EDL frame-exactly. `--placeholders` turns missing shots into labelled cards |
 
 **Check and deliver**
@@ -224,8 +225,14 @@ rn edit edit.json delete end --lift
 
 ## The EDL in one screen
 
+- **Version.** `"version": 2`. A file without it uses the version-1 names (`x`, `y`, `w`, `h`, `fit`, `blend`) and is
+  upgraded on load; `rn edit FILE upgrade` rewrites it.
 - **Tracks.** `tracks[0]` is the main track: its clips play back to back. Later tracks are overlays, placed with `at`
-  in time and with `x / y / w / h` in space.
+  in time and with `style` in space.
+- **Style.** Placement and look under CSS names and units: `left`, `top`, `width`, `height` (px, `"90px"`, or `"50%"`
+  of the frame), `opacity`, `scale`, `rotate` (degrees), `object-fit` (`cover`, `contain`, `fill`) and
+  `mix-blend-mode` (the CSS modes). The main track fills the frame, so it takes only `object-fit`, `left`, `top`,
+  `scale` and `rotate`.
 - **Audio items.** Items in `audio` are placed with `at`. `role` is `music`, `voice` or `sfx`; music ducks under voice
   when `mix.duck_db` is set.
 - **One time grid.** `output.fps` is the only clock. A clip of N seconds is exactly `round(N × fps)` frames.
@@ -239,14 +246,17 @@ rn edit edit.json delete end --lift
   - `{"beat": n, "listen": file}` and `{"word": n, "listen": file}`
 
   `pivot` places a point inside the source on the anchor instead of the source's start.
-- **Keys.** Written as `[t, value, ease]`. Overlays animate `scale`, `x`, `y`, `rotate`, `opacity` and `speed`; the
-  main track `scale`, `x`, `y`, `rotate`, `speed` and `gain_db`; audio items `gain_db`.
-- **Compositing.** `blend` takes `screen`, `multiply`, `add` and other blend modes. `mask` takes a full-frame matte, as
-  luma or alpha, optionally inverted. `vf` and `af` insert one raw ffmpeg filter chain.
+- **Keys.** Written as `[t, value, ease]`: the moving form of a style value. Overlays animate `scale`, `left`, `top`,
+  `rotate`, `opacity` and `speed`; the main track `scale`, `left`, `top`, `rotate`, `speed` and `gain_db`; audio items
+  `gain_db`.
+- **Compositing.** `mask` takes a full-frame matte, as luma or alpha, optionally inverted. `vf` and `af` insert one raw
+  ffmpeg filter chain.
 - **Bookkeeping.** `id` and `meta` go on anything; `meta` is kept as given. `accept` waives qa warnings judged
   intended.
 
-The full schema is in `rn assemble --help` and [SPEC.md](SPEC.md) §4.
+The full schema is [schema/edit.schema.json](schema/edit.schema.json), with `rn assemble --help` and [SPEC.md](SPEC.md)
+§4. Fields it marks `x-rn-only` (raw filters, masks, image sequences, nested edits, beat and word anchors, delivery
+loudness, subtitles) are rn's own; another program that renders the rest of the format previews what rn delivers.
 
 ## Conventions
 

{renoise_kit-0.5.1 → renoise_kit-0.6.0}/README.md

@@ -79,16 +79,17 @@ window.renderFrame = i => {
 
 ```json
 {
+  "version": 2,
   "output": {"width": 1080, "height": 1920, "fps": 30},
   "tracks": [
     {"clips": [
       {"id": "open", "src": "shots/s1.mp4", "in": 0.4, "out": 3.2},
       {"id": "hero", "src": "shots/s2.mp4", "ranges": [[0, 1.5], [2.5, 4]],
        "transition": {"type": "fade", "duration": 0.3}},
-      {"id": "end", "image": "card.png", "duration": 1.5, "fit": "contain"}
+      {"id": "end", "image": "card.png", "duration": 1.5, "style": {"object-fit": "contain"}}
     ]},
     {"clips": [
-      {"id": "title", "frames": "title/%05d.png", "fps": 30, "y": 1500,
+      {"id": "title", "frames": "title/%05d.png", "fps": 30, "style": {"top": 1500},
        "at": {"clip": "hero", "offset": 0.2}, "until": {"clip_end": "hero"}}
     ]}
   ],
@@ -174,7 +175,7 @@ rn edit edit.json delete end --lift
 
 | Command | What it gives |
 |---|---|
-| `rn edit EDL ids\|set\|split\|delete\|insert\|move` | Changes an EDL by clip id. Each step is checked against the whole timeline before the file is written |
+| `rn edit EDL ids\|set\|split\|delete\|insert\|move\|upgrade` | Changes an EDL by clip id. Each step is checked against the whole timeline before the file is written |
 | `rn assemble EDL -o OUT [--preview] [--range A-B] [--placeholders]` | Renders the EDL frame-exactly. `--placeholders` turns missing shots into labelled cards |
 
 **Check and deliver**
@@ -188,8 +189,14 @@ rn edit edit.json delete end --lift
 
 ## The EDL in one screen
 
+- **Version.** `"version": 2`. A file without it uses the version-1 names (`x`, `y`, `w`, `h`, `fit`, `blend`) and is
+  upgraded on load; `rn edit FILE upgrade` rewrites it.
 - **Tracks.** `tracks[0]` is the main track: its clips play back to back. Later tracks are overlays, placed with `at`
-  in time and with `x / y / w / h` in space.
+  in time and with `style` in space.
+- **Style.** Placement and look under CSS names and units: `left`, `top`, `width`, `height` (px, `"90px"`, or `"50%"`
+  of the frame), `opacity`, `scale`, `rotate` (degrees), `object-fit` (`cover`, `contain`, `fill`) and
+  `mix-blend-mode` (the CSS modes). The main track fills the frame, so it takes only `object-fit`, `left`, `top`,
+  `scale` and `rotate`.
 - **Audio items.** Items in `audio` are placed with `at`. `role` is `music`, `voice` or `sfx`; music ducks under voice
   when `mix.duck_db` is set.
 - **One time grid.** `output.fps` is the only clock. A clip of N seconds is exactly `round(N × fps)` frames.
@@ -203,14 +210,17 @@ rn edit edit.json delete end --lift
   - `{"beat": n, "listen": file}` and `{"word": n, "listen": file}`
 
   `pivot` places a point inside the source on the anchor instead of the source's start.
-- **Keys.** Written as `[t, value, ease]`. Overlays animate `scale`, `x`, `y`, `rotate`, `opacity` and `speed`; the
-  main track `scale`, `x`, `y`, `rotate`, `speed` and `gain_db`; audio items `gain_db`.
-- **Compositing.** `blend` takes `screen`, `multiply`, `add` and other blend modes. `mask` takes a full-frame matte, as
-  luma or alpha, optionally inverted. `vf` and `af` insert one raw ffmpeg filter chain.
+- **Keys.** Written as `[t, value, ease]`: the moving form of a style value. Overlays animate `scale`, `left`, `top`,
+  `rotate`, `opacity` and `speed`; the main track `scale`, `left`, `top`, `rotate`, `speed` and `gain_db`; audio items
+  `gain_db`.
+- **Compositing.** `mask` takes a full-frame matte, as luma or alpha, optionally inverted. `vf` and `af` insert one raw
+  ffmpeg filter chain.
 - **Bookkeeping.** `id` and `meta` go on anything; `meta` is kept as given. `accept` waives qa warnings judged
   intended.
 
-The full schema is in `rn assemble --help` and [SPEC.md](SPEC.md) §4.
+The full schema is [schema/edit.schema.json](schema/edit.schema.json), with `rn assemble --help` and [SPEC.md](SPEC.md)
+§4. Fields it marks `x-rn-only` (raw filters, masks, image sequences, nested edits, beat and word anchors, delivery
+loudness, subtitles) are rn's own; another program that renders the rest of the format previews what rn delivers.
 
 ## Conventions
 

{renoise_kit-0.5.1 → renoise_kit-0.6.0}/pyproject.toml

@@ -23,7 +23,7 @@ all = ["renoise-kit[listen,transcribe,faces,capture,captions,fonts,matte,export]
 # uv run pytest. faster-whisper and rembg are left out (large models); their tests skip, as OCR does without tesseract.
 [dependency-groups]
 dev = ["pytest", "librosa", "matplotlib", "opencv-python-headless>=4.8", "pysubs2", "playwright", "fonttools", "opentimelineio",
-       "otio-fcpx-xml-adapter", "otio-fcp-adapter"]
+       "otio-fcpx-xml-adapter", "otio-fcp-adapter", "jsonschema"]
 
 [project.urls]
 Homepage = "https://renoise.ai"

{renoise_kit-0.5.1 → renoise_kit-0.6.0/renoise_kit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: renoise-kit
-Version: 0.5.1
+Version: 0.6.0
 Summary: rn: frame-exact probing, contact sheets, EDL assembly, finishing and QA for AI video edits
 License-Expression: MIT
 Project-URL: Homepage, https://renoise.ai
@@ -115,16 +115,17 @@ window.renderFrame = i => {
 
 ```json
 {
+  "version": 2,
   "output": {"width": 1080, "height": 1920, "fps": 30},
   "tracks": [
     {"clips": [
       {"id": "open", "src": "shots/s1.mp4", "in": 0.4, "out": 3.2},
       {"id": "hero", "src": "shots/s2.mp4", "ranges": [[0, 1.5], [2.5, 4]],
        "transition": {"type": "fade", "duration": 0.3}},
-      {"id": "end", "image": "card.png", "duration": 1.5, "fit": "contain"}
+      {"id": "end", "image": "card.png", "duration": 1.5, "style": {"object-fit": "contain"}}
     ]},
     {"clips": [
-      {"id": "title", "frames": "title/%05d.png", "fps": 30, "y": 1500,
+      {"id": "title", "frames": "title/%05d.png", "fps": 30, "style": {"top": 1500},
        "at": {"clip": "hero", "offset": 0.2}, "until": {"clip_end": "hero"}}
     ]}
   ],
@@ -210,7 +211,7 @@ rn edit edit.json delete end --lift
 
 | Command | What it gives |
 |---|---|
-| `rn edit EDL ids\|set\|split\|delete\|insert\|move` | Changes an EDL by clip id. Each step is checked against the whole timeline before the file is written |
+| `rn edit EDL ids\|set\|split\|delete\|insert\|move\|upgrade` | Changes an EDL by clip id. Each step is checked against the whole timeline before the file is written |
 | `rn assemble EDL -o OUT [--preview] [--range A-B] [--placeholders]` | Renders the EDL frame-exactly. `--placeholders` turns missing shots into labelled cards |
 
 **Check and deliver**
@@ -224,8 +225,14 @@ rn edit edit.json delete end --lift
 
 ## The EDL in one screen
 
+- **Version.** `"version": 2`. A file without it uses the version-1 names (`x`, `y`, `w`, `h`, `fit`, `blend`) and is
+  upgraded on load; `rn edit FILE upgrade` rewrites it.
 - **Tracks.** `tracks[0]` is the main track: its clips play back to back. Later tracks are overlays, placed with `at`
-  in time and with `x / y / w / h` in space.
+  in time and with `style` in space.
+- **Style.** Placement and look under CSS names and units: `left`, `top`, `width`, `height` (px, `"90px"`, or `"50%"`
+  of the frame), `opacity`, `scale`, `rotate` (degrees), `object-fit` (`cover`, `contain`, `fill`) and
+  `mix-blend-mode` (the CSS modes). The main track fills the frame, so it takes only `object-fit`, `left`, `top`,
+  `scale` and `rotate`.
 - **Audio items.** Items in `audio` are placed with `at`. `role` is `music`, `voice` or `sfx`; music ducks under voice
   when `mix.duck_db` is set.
 - **One time grid.** `output.fps` is the only clock. A clip of N seconds is exactly `round(N × fps)` frames.
@@ -239,14 +246,17 @@ rn edit edit.json delete end --lift
   - `{"beat": n, "listen": file}` and `{"word": n, "listen": file}`
 
   `pivot` places a point inside the source on the anchor instead of the source's start.
-- **Keys.** Written as `[t, value, ease]`. Overlays animate `scale`, `x`, `y`, `rotate`, `opacity` and `speed`; the
-  main track `scale`, `x`, `y`, `rotate`, `speed` and `gain_db`; audio items `gain_db`.
-- **Compositing.** `blend` takes `screen`, `multiply`, `add` and other blend modes. `mask` takes a full-frame matte, as
-  luma or alpha, optionally inverted. `vf` and `af` insert one raw ffmpeg filter chain.
+- **Keys.** Written as `[t, value, ease]`: the moving form of a style value. Overlays animate `scale`, `left`, `top`,
+  `rotate`, `opacity` and `speed`; the main track `scale`, `left`, `top`, `rotate`, `speed` and `gain_db`; audio items
+  `gain_db`.
+- **Compositing.** `mask` takes a full-frame matte, as luma or alpha, optionally inverted. `vf` and `af` insert one raw
+  ffmpeg filter chain.
 - **Bookkeeping.** `id` and `meta` go on anything; `meta` is kept as given. `accept` waives qa warnings judged
   intended.
 
-The full schema is in `rn assemble --help` and [SPEC.md](SPEC.md) §4.
+The full schema is [schema/edit.schema.json](schema/edit.schema.json), with `rn assemble --help` and [SPEC.md](SPEC.md)
+§4. Fields it marks `x-rn-only` (raw filters, masks, image sequences, nested edits, beat and word anchors, delivery
+loudness, subtitles) are rn's own; another program that renders the rest of the format previews what rn delivers.
 
 ## Conventions
 

{renoise_kit-0.5.1 → renoise_kit-0.6.0}/renoise_kit.egg-info/SOURCES.txt

@@ -36,6 +36,7 @@ rn/fx/__init__.py
 rn/fx/fx.js
 tests/test_captions.py
 tests/test_capture.py
+tests/test_edit_v2.py
 tests/test_edl_v3.py
 tests/test_faces.py
 tests/test_fx.py

{renoise_kit-0.5.1 → renoise_kit-0.6.0}/rn/__init__.py

@@ -1,2 +1,2 @@
 """Renoise kit (`rn`, PyPI `renoise-kit`). Released on its own; the media sandbox template pins a version."""
-__version__ = '0.5.1'
+__version__ = '0.6.0'

{renoise_kit-0.5.1 → renoise_kit-0.6.0}/rn/cli.py

@@ -215,20 +215,21 @@ def _parser() -> argparse.ArgumentParser:
                    'ducking, LUFS target and encoded true peak <= limit. Output: H.264 High yuv420p bt709, moov first.\n'
                    'The EDL handles the mechanical assembly; render anything creative with your own code (rn capture for\n'
                    'HTML/canvas, numpy + rn.fx, Manim, Blender) to a PNG sequence or alpha clip and place it in the EDL.\n\n'
-                   'edit.json (paths relative to it; times in seconds; {"frame": n} also works for in/out;\n'
-                   '# marks notes below, not JSON; a "note" field is allowed on any clip):\n'
+                   'edit.json version 2 (paths relative to it; times in seconds; # marks notes below, not JSON; a "note"\n'
+                   'field is allowed anywhere; schema: schema/edit.schema.json in the renoise-kit repository):\n'
                    '{\n'
+                   '  "version": 2,\n'
                    '  "output": {"width": 1080, "height": 1920, "fps": 30, "background": "#000000", "crf": 18},\n'
                    '  "tracks": [\n'
                    '    {"clips": [                                  # track 0 = main track, clips back to back\n'
-                   '      {"src": "s1.mp4", "in": 0.4, "out": 3.2, "fit": "cover"},\n'
+                   '      {"src": "s1.mp4", "in": 0.4, "out": 3.2},\n'
                    '      {"src": "s2.mp4", "in": {"frame": 6}, "duration": 2.5, "speed": 0.5, "audio": false,\n'
                    '       "transition": {"type": "fade", "duration": 0.4}},   # any xfade name: dissolve, wipeleft, slideup...\n'
-                   '      {"image": "card.png", "duration": 1.5, "fit": "contain"},\n'
+                   '      {"image": "card.png", "duration": 1.5, "style": {"object-fit": "contain"}},\n'
                    '      {"color": "#000000", "duration": 0.5}]},\n'
-                   '    {"clips": [                                  # later tracks = overlays, positioned in time and space\n'
-                   '      {"image": "title.png", "at": 0.5, "duration": 2, "x": 90, "y": 1400, "w": 900,\n'
-                   '       "opacity": 1, "fade_in": 0.2, "fade_out": 0.2}]}],\n'
+                   '    {"clips": [                                  # later tracks = overlays, placed in time and space\n'
+                   '      {"image": "title.png", "at": 0.5, "duration": 2, "fade_in": 0.2, "fade_out": 0.2,\n'
+                   '       "style": {"left": 90, "top": "73%", "width": 900, "opacity": 0.9, "mix-blend-mode": "screen"}}]},\n'
                    '    {"clips": [{"frames": "title/%05d.png", "fps": 30, "at": {"clip": 1, "offset": 0.2},\n'
                    '                "until": {"clip_end": 1}, "keys": {"scale": [[0, 0.9], [0.3, 1, "out3"]], "opacity": [[0, 0], [0.2, 1]]}}]}],\n'
                    '  "markers": {"drop": 4.5},                                   # named times for anchors\n'
@@ -237,21 +238,27 @@ def _parser() -> argparse.ArgumentParser:
                    '  "subtitles": {"file": "captions.ass"},\n'
                    '  "mix": {"lufs": -14, "true_peak": -1.0, "duck_db": 10}            # duck music under voice\n'
                    '}\n'
+                   '"style" uses CSS names: overlays left/top/width/height (px: 90 or "90px"; "50%" of the frame), opacity,\n'
+                   'scale, rotate (degrees: 5 or "5deg"), object-fit (cover | contain | fill), mix-blend-mode (normal multiply\n'
+                   'screen overlay darken lighten color-dodge color-burn hard-light soft-light difference exclusion\n'
+                   'plus-lighter); the main track fills the frame: object-fit, left/top, scale, rotate.\n'
                    'Positions: in/out take seconds, {"frame": n} or {"shot": n, "offset": s} (shots from rn cuts).\n'
                    'Overlay "at"/"until" and audio "at" take seconds or an anchor + "offset": {"clip": i or "id"},\n'
                    '{"clip_end": i or "id"} (main-track clip as laid out, or an earlier overlay by id), {"marker": name},\n'
                    '{"frame": n}, {"beat": n, "listen": f.json}, {"word": n, "listen": f.json, "edge": "start"|"end"}.\n'
-                   'Keys [t, value, ease?] (t from the clip start; eases linear in out inout in3 out3 inout3 hold):\n'
-                   'main track scale/x/y/rotate (x, y as fractions of the frame), speed (a ramp; drops the clip\'s sound),\n'
-                   'gain_db; overlays scale/x/y/rotate/opacity/speed (x, y in px, about the layer centre); audio gain_db.\n'
-                   'Keep main-track scale >= 1: edges smear.\n'
+                   'Keys [t, value, ease?] (t from the clip start; eases linear in out inout in3 out3 inout3 hold), the\n'
+                   'moving form of a style value: main track scale/left/top/rotate (left, top: px the frame moves), speed\n'
+                   '(a ramp; drops the clip\'s sound), gain_db; overlays scale/left/top/rotate/opacity/speed (scale and rotate\n'
+                   'about the layer centre); audio gain_db. Keep main-track scale >= 1: edges smear.\n'
                    'Any clip or audio item: "id" (anchors, rn edit), "meta" (anything, kept as is), "vf" / "af" (one raw\n'
                    'ffmpeg filter chain, e.g. "eq=saturation=1.2,unsharp"; af on main-track clips and audio).\n'
                    'Main track: "ranges": [[in, out], ...] plays spans of one source back to back; "src": "part.json"\n'
-                   'plays another EDL. Overlays: "blend": screen|multiply|add|overlay|... ; "mask": {"frames"|"image"|"src":\n'
-                   '..., "mode": "luma"|"alpha", "invert": bool} (full frame, e.g. from rn matte). Overlays and audio:\n'
-                   '"pivot": s puts that point of the source (a hit, a downbeat) on "at". "mix": {"cut_fade": 0.01} fades\n'
-                   'every hard cut\'s own sound. "accept": [{"check", "at", "note"}] waives qa warnings judged intended.')
+                   'plays another edit. Overlays: "mask": {"frames"|"image"|"src": ..., "mode": "luma"|"alpha", "invert": bool}\n'
+                   '(full frame, e.g. from rn matte). Overlays and audio: "pivot": s puts that point of the source (a hit, a\n'
+                   'downbeat) on "at". "mix": {"cut_fade": 0.01} fades every hard cut\'s own sound. "accept": [{"check", "at",\n'
+                   '"note"}] waives qa warnings judged intended. A file without "version" uses the version-1 names (x, y, w,\n'
+                   'h, fit, blend; main-track keys x/y as fractions of the frame) and is upgraded on load; rn edit FILE\n'
+                   'upgrade rewrites it.')
     assemble.add_argument('edl')
     assemble.add_argument('-o', '--out', default='out.mp4')
     assemble.add_argument('--dry-run', action='store_true', help='validate and print the timeline without rendering')
@@ -278,6 +285,7 @@ def _parser() -> argparse.ArgumentParser:
     edit.add_argument('edl')
     ops = edit.add_subparsers(dest='op', required=True, metavar='op')
     ops.add_parser('ids', help='give every clip and audio item without an id one (c1.. main, o1.. overlays, a1.. audio)')
+    ops.add_parser('upgrade', help='rewrite a version-1 edit.json under version-2 names (style, keys left/top)')
     op_set = ops.add_parser('set', help='set fields: key=value (JSON when it parses), dotted keys reach into objects')
     op_set.add_argument('ref')
     op_set.add_argument('assignments', nargs='*', metavar='key=value')
@@ -443,6 +451,8 @@ def _run_summarized(args) -> tuple[dict, list[str]]:
         path = Path(args.edl)
         if args.op == 'ids':
             result = editops.ids_op(path)
+        elif args.op == 'upgrade':
+            result = editops.upgrade_op(path)
         elif args.op == 'set':
             result = editops.set_op(path, args.ref, args.assignments, args.unset)
         elif args.op == 'split':

{renoise_kit-0.5.1 → renoise_kit-0.6.0}/rn/editops.py

@@ -11,7 +11,7 @@ import os
 from fractions import Fraction
 from pathlib import Path
 
-from .edl import Clip, load
+from .edl import Clip, load, upgrade
 from .ff import RnError
 
 
@@ -236,8 +236,17 @@ def move_op(path: Path, ref: str, before: str | None, after: str | None, track:
     return {'op': 'move', 'clip': ref, 'timeline': _write_checked(path, raw)}
 
 
+def upgrade_op(path: Path) -> dict:
+    """Rewrites a version-1 edit under version-2 names ("style", keys left / top); the timeline stays the same."""
+    raw = _read(path)
+    if raw.get('version') == 2:
+        raise RnError(f'{path.name} is already version 2')
+    return {'op': 'upgrade', 'timeline': _write_checked(path, upgrade(raw))}
+
+
 def summary_lines(result: dict) -> list[str]:
-    head = {'ids': lambda r: f'ids added: {", ".join(r["added"]) or "none (every clip has one)"}',
+    head = {'upgrade': lambda r: 'upgraded to version 2',
+            'ids': lambda r: f'ids added: {", ".join(r["added"]) or "none (every clip has one)"}',
             'set': lambda r: f'set {r["clip"]}',
             'split': lambda r: f'split {r["clip"]} into {r["into"][0]} + {r["into"][1]}',
             'delete': lambda r: f'deleted {r["clip"]}' + (' (lifted: gap kept)' if r['lift'] else ''),

{renoise_kit-0.5.1 → renoise_kit-0.6.0}/rn/edl.py

@@ -23,14 +23,26 @@ XFADE = {
     'vuslice', 'vdslice', 'hblur', 'squeezeh', 'squeezev', 'zoomin', 'coverleft', 'coverright', 'coverup', 'coverdown',
     'revealleft', 'revealright', 'revealup', 'revealdown',
 }
-FITS = {'cover', 'contain', 'stretch'}
 EASES = {'linear', 'in', 'out', 'inout', 'in3', 'out3', 'inout3', 'hold'}
-KEYS_MAIN = {'scale', 'x', 'y', 'rotate', 'speed', 'gain_db'}
-KEYS_OVERLAY = {'scale', 'x', 'y', 'rotate', 'opacity', 'speed'}
+# Version 2 names keyed properties as CSS does: left / top in px. Inside, rn keeps x / y (main track: fractions of the frame).
+KEYS_MAIN = {'scale', 'left', 'top', 'rotate', 'speed', 'gain_db'}
+KEYS_OVERLAY = {'scale', 'left', 'top', 'rotate', 'opacity', 'speed'}
 KEYS_AUDIO = {'gain_db'}
-# ffmpeg blend modes, computed in RGB; "add" is accepted for "addition".
-BLENDS = {'normal', 'addition', 'multiply', 'screen', 'overlay', 'darken', 'lighten', 'difference', 'exclusion', 'softlight',
-          'hardlight', 'colordodge', 'colorburn', 'linearlight', 'vividlight', 'pinlight', 'average', 'negation', 'phoenix'}
+# "style" holds placement and look under CSS property names, so a model's CSS habits apply.
+STYLE_MAIN = {'object-fit', 'left', 'top', 'scale', 'rotate'}
+STYLE_OVERLAY = STYLE_MAIN | {'width', 'height', 'opacity', 'mix-blend-mode'}
+CSS_FITS = {'cover': 'cover', 'contain': 'contain', 'fill': 'stretch'}
+# CSS mix-blend-mode -> ffmpeg blend (computed in RGB). The ffmpeg-only modes after them are rn's own: other hosts of the
+# format may not render them (edit.schema.json marks them x-rn-only).
+CSS_BLENDS = {'normal': 'normal', 'multiply': 'multiply', 'screen': 'screen', 'overlay': 'overlay', 'darken': 'darken',
+              'lighten': 'lighten', 'color-dodge': 'colordodge', 'color-burn': 'colorburn', 'hard-light': 'hardlight',
+              'soft-light': 'softlight', 'difference': 'difference', 'exclusion': 'exclusion', 'plus-lighter': 'addition'}
+RN_BLENDS = {'linearlight', 'vividlight', 'pinlight', 'average', 'negation', 'phoenix'}
+# Version 1 fields and where version 2 keeps them.
+V1_FIELDS = {'x': 'style.left', 'y': 'style.top', 'w': 'style.width', 'h': 'style.height', 'opacity': 'style.opacity',
+             'blend': 'style["mix-blend-mode"]', 'fit': 'style["object-fit"]'}
+_LENGTH = re.compile(r'^(-?\d+(?:\.\d+)?)(px|%)$')
+_DEGREES = re.compile(r'^(-?\d+(?:\.\d+)?)deg$')
 _GRAPH_BREAKERS = re.compile(r'[;\[\]]')
 # The same curves as assemble's ffmpeg expressions (assemble._EASE), for what rn computes itself (speed ramps).
 EASE_FN = {
@@ -178,9 +190,9 @@ class Edit:
         }
 
 
-def _num(value, where: str, *, minimum: float | None = None, positive: bool = False) -> float:
+def _num(value, where: str, *, minimum: float | None = None, positive: bool = False, what: str = 'a number of seconds') -> float:
     if isinstance(value, bool) or not isinstance(value, (int, float)):
-        raise RnError(f'{where}: expected a number of seconds, got {json.dumps(value)}')
+        raise RnError(f'{where}: expected {what}, got {json.dumps(value)}')
     if positive and value <= 0:
         raise RnError(f'{where}: must be > 0')
     if minimum is not None and value < minimum:
@@ -340,6 +352,55 @@ def _keys(raw, where: str, allowed: set[str]) -> dict | None:
     return keys
 
 
+def _length(value, where: str, frame: int) -> float:
+    """px as a number or "90px", or a percentage of the frame's width (left, width) or height (top, height)."""
+    match = _LENGTH.match(value.strip()) if isinstance(value, str) else None
+    if match:
+        number = float(match.group(1))
+        return number * frame / 100 if match.group(2) == '%' else number
+    return _num(value, where, what='px as a number or "90px", or a share of the frame like "50%"')
+
+
+def _style(raw, where: str, overlay: bool, size: tuple[int, int]) -> dict:
+    """Placement and look under CSS names: left / top / width / height (px), opacity, scale, rotate (degrees),
+    object-fit (cover | contain | fill), mix-blend-mode. Returned in rn's own terms (x, y, w, h, fit, blend)."""
+    if raw is None:
+        return {}
+    where = f'{where}.style'
+    if not isinstance(raw, dict):
+        raise RnError(f'{where}: {{"left": 90, "top": "70%", "width": 900, "opacity": 0.8, "mix-blend-mode": "screen"}}')
+    allowed = STYLE_OVERLAY if overlay else STYLE_MAIN
+    unknown = set(raw) - allowed
+    if unknown:
+        hint = '' if overlay else '; main-track clips fill the frame: put a sized or see-through clip on another track'
+        raise RnError(f'{where}: {sorted(unknown)} not supported here (supported: {sorted(allowed)}){hint}')
+    look = {}
+    if 'object-fit' in raw:
+        if raw['object-fit'] not in CSS_FITS:
+            raise RnError(f'{where}.object-fit: one of {sorted(CSS_FITS)}')
+        look['fit'] = CSS_FITS[raw['object-fit']]
+    for css, key, frame in (('left', 'x', size[0]), ('top', 'y', size[1]), ('width', 'w', size[0]), ('height', 'h', size[1])):
+        if css in raw:
+            look[key] = _length(raw[css], f'{where}.{css}', frame)
+            if key in ('w', 'h') and look[key] <= 0:
+                raise RnError(f'{where}.{css}: must be > 0')
+    if 'opacity' in raw:
+        look['opacity'] = _num(raw['opacity'], f'{where}.opacity', minimum=0, what='a number between 0 and 1')
+        if look['opacity'] > 1:
+            raise RnError(f'{where}.opacity: between 0 and 1')
+    if 'scale' in raw:
+        look['scale'] = _num(raw['scale'], f'{where}.scale', positive=True, what='a number (1 = own size)')
+    if 'rotate' in raw:
+        match = _DEGREES.match(raw['rotate'].strip()) if isinstance(raw['rotate'], str) else None
+        look['rotate'] = float(match.group(1)) if match else _num(raw['rotate'], f'{where}.rotate', what='degrees as a number or "5deg"')
+    if 'mix-blend-mode' in raw:
+        mode = raw['mix-blend-mode']
+        if mode not in CSS_BLENDS and mode not in RN_BLENDS:
+            raise RnError(f'{where}.mix-blend-mode: one of {sorted(CSS_BLENDS)} (rn also renders {sorted(RN_BLENDS)})')
+        look['blend'] = CSS_BLENDS.get(mode, mode)
+    return look
+
+
 def _sequence(edit_dir: Path, pattern, where: str) -> tuple[Path, int, int, tuple[int, int]]:
     """A numbered image sequence (printf pattern like "title/%05d.png") -> (pattern path, first number, count, size)."""
     if not isinstance(pattern, str) or not _SEQ.search(pattern):
@@ -476,7 +537,8 @@ def _placeholder(raw: dict, where: str, edit_dir: Path, size: tuple[int, int], w
     card = _card(edit_dir, size, [raw.get('id') or Path(value).name, *([str(label)] if label else []), f'missing: {value}'])
     warnings.append(f'{where}: {value} is missing; placeholder card for {seconds}s')
     keep = {k: v for k, v in raw.items() if k not in ('src', 'frames', 'image', 'fps', 'in', 'out', 'speed', 'audio', 'gain_db', 'duration', 'until')}
-    return {**keep, 'image': str(card), 'duration': seconds, 'fit': raw.get('fit', 'contain')}
+    style = raw.get('style') if isinstance(raw.get('style'), dict) else {}
+    return {**keep, 'image': str(card), 'duration': seconds, 'style': {'object-fit': 'contain', **style}}
 
 
 def _clip(raw: dict, where: str, edit_dir: Path, fps: Fraction, *, overlay: bool, warnings: list[str],
@@ -502,20 +564,28 @@ def _clip(raw: dict, where: str, edit_dir: Path, fps: Fraction, *, overlay: bool
             raw = {**raw, 'duration': until - at_s}
     elif 'until' in raw:
         raise RnError(f'{where}.until: main-track clips play back to back; "until" is for overlays')
-    fit = raw.get('fit', 'cover')
-    if fit not in FITS:
-        raise RnError(f'{where}.fit: one of {sorted(FITS)}')
+    look = _style(raw.get('style'), where, overlay, size)
     speed = _num(raw.get('speed', 1.0), f'{where}.speed', positive=True)
     if not 0.1 <= speed <= 8:
         raise RnError(f'{where}.speed: keep between 0.1 and 8')
     gain = _num(raw.get('gain_db', 0.0), f'{where}.gain_db')
-    clip = Clip(where=where, kind='video', source=None, color=None, start_s=0.0, speed=speed, frames=0, fit=fit,
+    clip = Clip(where=where, kind='video', source=None, color=None, start_s=0.0, speed=speed, frames=0, fit=look.get('fit', 'cover'),
                 audio=bool(raw.get('audio', not overlay)), gain_db=gain)
     clip.id, clip.meta = _ident(raw, where)
     clip.vf, clip.af = _filters(raw, 'vf', where), _filters(raw, 'af', where)
     if overlay and clip.af:
         raise RnError(f'{where}.af: overlays are silent; filter their sound in "audio"')
     clip.keys = _keys(raw.get('keys'), f'{where}.keys', KEYS_OVERLAY if overlay else KEYS_MAIN)
+    # A still style value is a key held for the whole clip; a main-track move is a fraction of the frame inside rn.
+    still = {p: look[p] for p in ('scale', 'rotate', *(() if overlay else ('x', 'y'))) if p in look}
+    for css, key in (('left', 'x'), ('top', 'y'), ('scale', 'scale'), ('rotate', 'rotate')):
+        if key in still and clip.keys and css in clip.keys:
+            raise RnError(f'{where}: give style.{css} or keys.{css}, not both')
+        if key in still:
+            clip.keys = {**(clip.keys or {}), css: [(0.0, still[key], 'linear')]}
+        if clip.keys and css in clip.keys and css != key:
+            frame = size[0] if key == 'x' else size[1]
+            clip.keys[key] = [(t, v if overlay else v / frame, ease) for t, v, ease in clip.keys.pop(css)]
     ramp = (clip.keys or {}).get('speed')
     if ramp and 'speed' in raw:
         raise RnError(f'{where}: give "speed" or keys.speed, not both')
@@ -626,29 +696,20 @@ def _clip(raw: dict, where: str, edit_dir: Path, fps: Fraction, *, overlay: bool
             at_s = 0.0
     if overlay:
         clip.timeline_start = _frames(at_s, fps)
-        clip.x = int(_num(raw.get('x', 0), f'{where}.x'))
-        clip.y = int(_num(raw.get('y', 0), f'{where}.y'))
-        clip.w = int(_num(raw['w'], f'{where}.w', positive=True)) if 'w' in raw else None
-        clip.h = int(_num(raw['h'], f'{where}.h', positive=True)) if 'h' in raw else None
-        clip.opacity = _num(raw.get('opacity', 1.0), f'{where}.opacity', minimum=0)
-        if clip.opacity > 1:
-            raise RnError(f'{where}.opacity: between 0 and 1')
+        clip.x, clip.y = round(look.get('x', 0)), round(look.get('y', 0))
+        clip.w, clip.h = (round(look[k]) if k in look else None for k in ('w', 'h'))
+        clip.opacity = look.get('opacity', 1.0)
+        clip.blend = look.get('blend')
         clip.fade_in = _num(raw.get('fade_in', 0), f'{where}.fade_in', minimum=0)
         clip.fade_out = _num(raw.get('fade_out', 0), f'{where}.fade_out', minimum=0)
         if 'transition' in raw:
             raise RnError(f'{where}.transition: transitions are for the first (main) track; use fade_in / fade_out on overlays')
         if 'audio' in raw or 'gain_db' in raw:
             raise RnError(f'{where}: overlay clips are silent; add their sound to "audio" with "at" (role "sfx")')
-        blend = raw.get('blend')
-        if blend is not None:
-            blend = {'add': 'addition'}.get(blend, blend)
-            if blend not in BLENDS:
-                raise RnError(f'{where}.blend: one of {sorted(BLENDS | {"add"})}')
-            clip.blend = blend
         if 'mask' in raw:
             clip.mask, clip.mask_mode, clip.mask_invert = _mask(raw['mask'], where, clip, edit_dir, fps, warnings, timeline, size)
     else:
-        for key in ('at', 'x', 'y', 'w', 'h', 'opacity', 'fade_in', 'fade_out', 'blend', 'mask'):
+        for key in ('at', 'fade_in', 'fade_out', 'mask'):
             if key in raw:
                 raise RnError(f'{where}.{key}: main-track clips play back to back; put positioned clips on another track')
         transition = raw.get('transition')
@@ -660,13 +721,20 @@ def _clip(raw: dict, where: str, edit_dir: Path, fps: Fraction, *, overlay: bool
     if clip.keys and 'gain_db' in clip.keys and not (clip.audio and clip.has_audio):
         raise RnError(f'{where}.keys.gain_db: the clip plays no sound of its own')
     if clip.keys and overlay and ('scale' in clip.keys or 'rotate' in clip.keys) and clip.kind == 'color' and not (clip.w and clip.h):
-        raise RnError(f'{where}.keys: give a colour overlay "w" and "h" to scale or rotate it')
-    unknown = set(raw) - {'src', 'frames', 'fps', 'image', 'color', 'in', 'out', 'duration', 'until', 'speed', 'fit', 'audio', 'gain_db',
-                          'at', 'x', 'y', 'w', 'h', 'opacity', 'fade_in', 'fade_out', 'transition', 'keys', 'note', 'id', 'meta',
-                          'pivot', 'vf', 'af', 'blend', 'mask'}
+        raise RnError(f'{where}: give a colour overlay style.width and style.height to scale or rotate it')
+    unknown = set(raw) - {'src', 'frames', 'fps', 'image', 'color', 'in', 'out', 'duration', 'until', 'speed', 'audio', 'gain_db',
+                          'at', 'style', 'fade_in', 'fade_out', 'transition', 'keys', 'note', 'id', 'meta', 'pivot', 'vf', 'af', 'mask'}
+    _reject_unknown(unknown, where)
+    return clip
+
+
+def _reject_unknown(unknown: set[str], where: str) -> None:
+    old = sorted(unknown & set(V1_FIELDS))
+    if old:
+        raise RnError(f'{where}: {", ".join(f"{k} is now {V1_FIELDS[k]}" for k in old)} (edit.json version 2; '
+                      '"rn edit FILE upgrade" rewrites a version-1 file)')
     if unknown:
         raise RnError(f'{where}: unknown field(s) {sorted(unknown)}')
-    return clip
 
 
 def _mask(raw, where: str, layer: Clip, edit_dir: Path, fps: Fraction, warnings: list[str], timeline: Timeline,
@@ -679,14 +747,14 @@ def _mask(raw, where: str, layer: Clip, edit_dir: Path, fps: Fraction, warnings:
     mode, invert = raw.get('mode', 'luma'), raw.get('invert', False)
     if mode not in ('luma', 'alpha') or not isinstance(invert, bool):
         raise RnError(f'{where}: "mode" luma or alpha, "invert" true or false')
-    placed = {'x', 'y', 'w', 'h', 'blend', 'mask', 'opacity'} & set(raw)
-    if placed:
-        raise RnError(f'{where}: a mask covers the whole frame; {sorted(placed)} do not apply')
+    style = raw.get('style') or {}
+    if 'mask' in raw or not isinstance(style, dict) or set(style) - {'object-fit'}:
+        raise RnError(f'{where}: a mask covers the whole frame; only style["object-fit"] applies (default fill)')
     matte = {k: v for k, v in raw.items() if k not in ('mode', 'invert')}
     matte.setdefault('at', float(layer.timeline_start / fps))
     if not {'duration', 'out', 'until'} & set(matte):
         matte['duration'] = float(layer.frames / fps)
-    matte.setdefault('fit', 'stretch')
+    matte['style'] = {'object-fit': 'fill', **style}
     clip = _clip(matte, where, edit_dir, fps, overlay=True, warnings=warnings, timeline=timeline, size=size)
     clip.w, clip.h = size
     return clip, mode, invert
@@ -768,8 +836,53 @@ def _expand_ranges(clips: list) -> tuple[list[tuple[str, dict]], dict[str, tuple
     return pieces, groups
 
 
+def _upgrade_clip(clip, frame: tuple[float, float] | None) -> None:
+    """In place: a version-1 clip's placement and look into "style"; keys x / y into left / top in px. frame: the
+    output size for main-track keys, whose x / y were fractions of it (None when the output size is not a number)."""
+    if not isinstance(clip, dict) or 'style' in clip:
+        return  # not a clip, or already mixed with version 2: the parser names what is wrong
+    style = {}
+    for old, new in (('x', 'left'), ('y', 'top'), ('w', 'width'), ('h', 'height'), ('opacity', 'opacity')):
+        if old in clip:
+            style[new] = clip.pop(old)
+    if 'fit' in clip:
+        style['object-fit'] = {'stretch': 'fill'}.get(clip['fit'], clip['fit'])
+        del clip['fit']
+    if 'blend' in clip:
+        css = {ff: css for css, ff in CSS_BLENDS.items()} | {'add': 'plus-lighter'}
+        style['mix-blend-mode'] = css.get(clip['blend'], clip['blend'])
+        del clip['blend']
+    if style:
+        clip['style'] = style
+    keys = clip.get('keys')
+    if isinstance(keys, dict):
+        for old, new, side in (('x', 'left', 0), ('y', 'top', 1)):
+            points = keys.pop(old, None)
+            if points is not None:
+                if frame and isinstance(points, list):
+                    points = [[p[0], p[1] * frame[side], *p[2:]] if isinstance(p, list) and len(p) > 1
+                              and isinstance(p[1], (int, float)) else p for p in points]
+                keys[new] = points
+    _upgrade_clip(clip.get('mask'), None)
+
+
+def upgrade(raw: dict) -> dict:
+    """A version-1 edit (no "version") in version-2 terms, as a new dict: placement and look move into "style" under CSS
+    names, and keys x / y become left / top in px (main-track x / y were fractions of the frame)."""
+    raw = json.loads(json.dumps(raw))
+    output = raw.get('output') if isinstance(raw.get('output'), dict) else {}
+    size = (output.get('width'), output.get('height'))
+    frame = size if all(isinstance(v, (int, float)) and not isinstance(v, bool) for v in size) else None
+    tracks = raw.get('tracks') if isinstance(raw.get('tracks'), list) else []
+    for t, track in enumerate(tracks):
+        for clip in (track.get('clips') if isinstance(track, dict) and isinstance(track.get('clips'), list) else []):
+            _upgrade_clip(clip, frame if t == 0 else None)
+    return {'version': 2, **{k: v for k, v in raw.items() if k != 'version'}}
+
+
 def load(path: str | Path, *, placeholders: bool = False, _stack: tuple[Path, ...] = ()) -> Edit:
-    """Parses and lays out an EDL. placeholders: a missing source becomes a card for its time span instead of an error."""
+    """Parses and lays out an EDL. placeholders: a missing source becomes a card for its time span instead of an error.
+    A version-1 edit (no "version") is upgraded on the way in."""
     path = Path(path).resolve()
     stack = (*_stack, path)
     try:
@@ -778,6 +891,13 @@ def load(path: str | Path, *, placeholders: bool = False, _stack: tuple[Path, ..
         raise RnError(f'no such file: {path}') from None
     except json.JSONDecodeError as error:
         raise RnError(f'{path}: invalid JSON: {error}') from None
+    if not isinstance(raw, dict):
+        raise RnError(f'{path}: expected a JSON object')
+    version = raw.get('version', 1)
+    if version == 1:
+        raw = upgrade(raw)
+    elif version != 2:
+        raise RnError('version: 2 (or 1 / absent for the old field names, upgraded on load)')
     edit_dir = path.parent
     output = raw.get('output') or {}
     width = int(_num(output.get('width'), 'output.width', positive=True))

renoise_kit-0.6.0/tests/test_edit_v2.py

@@ -0,0 +1,95 @@
+"""edit.json version 2: placement and look in "style" under CSS names, keys left / top in px, version 1 upgraded on load,
+and schema/edit.schema.json agreeing with rn on the shared fixtures other hosts test against."""
+import json
+from pathlib import Path
+
+import pytest
+
+from rn.edl import load
+from rn.editops import upgrade_op
+from rn.ff import RnError
+
+SCHEMA_DIR = Path(__file__).resolve().parents[1] / 'schema'
+FIXTURES = SCHEMA_DIR / 'fixtures'
+# Why rn rejects each invalid fixture: part of its error message.
+REJECTED_FOR = {
+    'blend-hue': 'mix-blend-mode', 'fit-stretch': 'object-fit', 'key-x': 'keyable here', 'length-space': 'style.left',
+    'main-width': "['width'] not supported here", 'odd-width': 'must be even', 'opacity-range': 'between 0 and 1',
+    'two-sources': 'exactly one of', 'until-on-main': 'main-track clips play back to back', 'v1-field': 'x is now style.left',
+    'version-3': 'version: 2',
+}
+
+
+def schema_validator():
+    jsonschema = pytest.importorskip('jsonschema')
+    schema = json.loads((SCHEMA_DIR / 'edit.schema.json').read_text(encoding='utf-8'))
+    jsonschema.Draft202012Validator.check_schema(schema)
+    return jsonschema.Draft202012Validator(schema)
+
+
+@pytest.mark.parametrize('path', sorted((FIXTURES / 'valid').glob('*.json')), ids=lambda p: p.stem)
+def test_valid_fixtures_pass_the_schema_and_rn(path):
+    schema_validator().validate(json.loads(path.read_text(encoding='utf-8')))
+    load(path)
+
+
+@pytest.mark.parametrize('path', sorted((FIXTURES / 'invalid').glob('*.json')), ids=lambda p: p.stem)
+def test_invalid_fixtures_fail_the_schema_and_rn(path):
+    assert not schema_validator().is_valid(json.loads(path.read_text(encoding='utf-8')))
+    with pytest.raises(RnError, match=REJECTED_FOR[path.stem].replace('[', r'\[').replace(']', r'\]')):
+        load(path)
+
+
+V1 = {'output': {'width': 1080, 'height': 1920, 'fps': 30}, 'tracks': [
+    {'clips': [{'color': '#203040', 'duration': 2, 'fit': 'contain',
+                'keys': {'scale': [[0, 1], [2, 1.2, 'out']], 'x': [[0, 0], [2, 0.05]], 'y': [[0, -0.1]]}}]},
+    {'clips': [{'color': '#ffffff', 'at': 0.5, 'duration': 1, 'x': 90, 'y': 1400, 'w': 900, 'h': 200, 'opacity': 0.8, 'blend': 'add',
+                'keys': {'y': [[0, 1400], [1, 1300, 'out3']]}}]}]}
+V2 = {'version': 2, 'output': {'width': 1080, 'height': 1920, 'fps': 30}, 'tracks': [
+    {'clips': [{'color': '#203040', 'duration': 2, 'style': {'object-fit': 'contain', 'top': -192},
+                'keys': {'scale': [[0, 1], [2, 1.2, 'out']], 'left': [[0, 0], [2, 54]]}}]},
+    {'clips': [{'color': '#ffffff', 'at': 0.5, 'duration': 1,
+                'style': {'left': '8.333333%', 'top': 1400, 'width': '900px', 'height': 200, 'opacity': 0.8, 'mix-blend-mode': 'plus-lighter'},
+                'keys': {'top': [[0, 1400], [1, 1300, 'out3']]}}]}]}
+
+
+def laid_out(edit):
+    """What rn renders from: fit, placement, look and keys (rounded: px <-> fractions of the frame round-trip)."""
+    keys = lambda c: {p: [(t, round(v, 9), e) for t, v, e in pts] for p, pts in (c.keys or {}).items()}  # noqa: E731
+    return [(c.fit, c.x, c.y, c.w, c.h, c.opacity, c.blend, keys(c), c.timeline_start, c.frames) for c in edit.base + edit.overlays]
+
+
+def write(tmp_path, name, raw):
+    path = tmp_path / name
+    path.write_text(json.dumps(raw), encoding='utf-8')
+    return path
+
+
+def test_version_1_and_version_2_lay_out_the_same(tmp_path):
+    v1, v2 = load(write(tmp_path, 'v1.json', V1)), load(write(tmp_path, 'v2.json', V2))
+    assert laid_out(v1) == laid_out(v2)
+    main, overlay = v2.base[0], v2.overlays[0]
+    assert main.keys['x'][-1][1] == pytest.approx(0.05) and main.keys['y'] == [(0.0, -0.1, 'linear')]  # px -> fraction of the frame
+    assert (overlay.x, overlay.w, overlay.blend) == (90, 900, 'addition')
+
+
+def test_upgrade_rewrites_the_file_and_keeps_the_timeline(tmp_path):
+    path = write(tmp_path, 'e.json', V1)
+    before = laid_out(load(path))
+    upgrade_op(path)
+    raw = json.loads(path.read_text(encoding='utf-8'))
+    assert raw['version'] == 2 and raw['tracks'][1]['clips'][0]['style']['mix-blend-mode'] == 'plus-lighter'
+    assert 'x' not in raw['tracks'][1]['clips'][0] and 'left' in raw['tracks'][0]['clips'][0]['keys']
+    assert laid_out(load(path)) == before
+    with pytest.raises(RnError, match='already version 2'):
+        upgrade_op(path)
+
+
+def test_a_style_value_is_a_held_key_and_cannot_also_be_keyed(tmp_path):
+    raw = json.loads(json.dumps(V2))
+    raw['tracks'][1]['clips'][0]['style'] |= {'rotate': '5deg', 'scale': 1.5}
+    overlay = load(write(tmp_path, 'held.json', raw)).overlays[0]
+    assert overlay.keys['rotate'] == [(0.0, 5.0, 'linear')] and overlay.keys['scale'] == [(0.0, 1.5, 'linear')]
+    raw['tracks'][1]['clips'][0]['keys']['scale'] = [[0, 1], [1, 2]]
+    with pytest.raises(RnError, match='style.scale or keys.scale'):
+        load(write(tmp_path, 'both.json', raw))