diff --git a/ATTRIBUTION.md b/ATTRIBUTION.md
index abe06308d..38a3d624e 100644
--- a/ATTRIBUTION.md
+++ b/ATTRIBUTION.md
@@ -12,6 +12,9 @@ iconography, images or other Adobe assets; open licences only; every asset attri
 | `assets/fonts/Inter-Regular.ttf` | The Inter Project Authors | https://github.com/rsms/inter | OFL-1.1 (`assets/fonts/OFL-Inter.txt`) |
 | `assets/fonts/Inter-Medium.ttf` | The Inter Project Authors | https://github.com/rsms/inter | OFL-1.1 (`assets/fonts/OFL-Inter.txt`) |
 | `assets/fonts/Inter-SemiBold.ttf` | The Inter Project Authors | https://github.com/rsms/inter | OFL-1.1 (`assets/fonts/OFL-Inter.txt`) |
+| `assets/fonts/Inter-Bold.ttf` | The Inter Project Authors | https://github.com/rsms/inter | OFL-1.1 (`assets/fonts/OFL-Inter.txt`) |
+| `assets/fonts/Inter-Italic.ttf` | The Inter Project Authors | https://github.com/rsms/inter | OFL-1.1 (`assets/fonts/OFL-Inter.txt`) |
+| `assets/fonts/NotoSerif-Regular.ttf` | The Noto Project Authors | https://github.com/notofonts/latin-greek-cyrillic | OFL-1.1 (`assets/fonts/OFL-NotoSerif.txt`) |
 | `assets/fonts/JetBrainsMono-Regular.ttf` | The JetBrains Mono Project Authors | https://github.com/JetBrains/JetBrainsMono | OFL-1.1 (`assets/fonts/OFL-JetBrainsMono.txt`) |
 | `docs/images/filmcraft-hero.png` | FilmCraft contributors | Original work: FilmCraft screenshot; frames from public-domain films (Night of the Living Dead 1968, Carnival of Souls 1962), CC0 Chopin (Musopen) | MIT OR Apache-2.0; film frames public domain |
 | `docs/images/filmcraft-color.png` | FilmCraft contributors | Original work: FilmCraft screenshot; frames from Charade (1963, public domain) | MIT OR Apache-2.0; film frames public domain |
@@ -23,6 +26,26 @@ iconography, images or other Adobe assets; open licences only; every asset attri
 | `docs/images/filmcraft-effects.png` | FilmCraft contributors | Original work: FilmCraft screenshot crop; NASA Earth Views (US Government work, public domain) | MIT OR Apache-2.0; footage public domain |
 | `docs/images/filmcraft-timeline.png` | FilmCraft contributors | Original work: FilmCraft UI crop; thumbnails from Night of the Living Dead (1968) and Carnival of Souls (1962), CC0 Chopin waveform | MIT OR Apache-2.0; film frames public domain |
 
+## Golden test images
+
+Reference frames for the renderer golden tests (`crates/golden`), rendered by FilmCraft itself from
+procedural demo footage (`crates/media/src/generators.rs`); no external media. Regenerate with
+`FILMCRAFT_BLESS=1 cargo test -p filmcraft-golden`.
+
+| Asset | Author | Source | Licence |
+|---|---|---|---|
+| `crates/golden/goldens/blend_modes.png` | FilmCraft contributors | Original work: golden reference rendered by FilmCraft (crates/golden/tests/golden.rs, scene `blend_modes`) from procedurally generated media | MIT OR Apache-2.0 |
+| `crates/golden/goldens/crop.png` | FilmCraft contributors | Original work: golden reference rendered by FilmCraft (crates/golden/tests/golden.rs, scene `crop`) from procedurally generated media | MIT OR Apache-2.0 |
+| `crates/golden/goldens/gaussian_blur.png` | FilmCraft contributors | Original work: golden reference rendered by FilmCraft (crates/golden/tests/golden.rs, scene `gaussian_blur`) from procedurally generated media | MIT OR Apache-2.0 |
+| `crates/golden/goldens/graphic_shapes.png` | FilmCraft contributors | Original work: golden reference rendered by FilmCraft (crates/golden/tests/golden.rs, scene `graphic_shapes`) from procedurally generated media and bundled OFL fonts | MIT OR Apache-2.0 |
+| `crates/golden/goldens/graphic_title.png` | FilmCraft contributors | Original work: golden reference rendered by FilmCraft (crates/golden/tests/golden.rs, scene `graphic_title`) from procedurally generated media and bundled OFL fonts | MIT OR Apache-2.0 |
+| `crates/golden/goldens/lumetri_basic.png` | FilmCraft contributors | Original work: golden reference rendered by FilmCraft (crates/golden/tests/golden.rs, scene `lumetri_basic`) from procedurally generated media | MIT OR Apache-2.0 |
+| `crates/golden/goldens/text_burnin.png` | FilmCraft contributors | Original work: golden reference rendered by FilmCraft (crates/golden/tests/golden.rs, scene `text_burnin`) from procedurally generated media | MIT OR Apache-2.0 |
+| `crates/golden/goldens/transform_opacity.png` | FilmCraft contributors | Original work: golden reference rendered by FilmCraft (crates/golden/tests/golden.rs, scene `transform_opacity`) from procedurally generated media | MIT OR Apache-2.0 |
+| `crates/golden/goldens/transition_cross_dissolve.png` | FilmCraft contributors | Original work: golden reference rendered by FilmCraft (crates/golden/tests/golden.rs, scene `transition_cross_dissolve`) from procedurally generated media | MIT OR Apache-2.0 |
+| `crates/golden/goldens/transition_dip_to_black.png` | FilmCraft contributors | Original work: golden reference rendered by FilmCraft (crates/golden/tests/golden.rs, scene `transition_dip_to_black`) from procedurally generated media | MIT OR Apache-2.0 |
+| `crates/golden/goldens/transition_wipe.png` | FilmCraft contributors | Original work: golden reference rendered by FilmCraft (crates/golden/tests/golden.rs, scene `transition_wipe`) from procedurally generated media | MIT OR Apache-2.0 |
+
 ## Third-party media shown in screenshots
 
 The README screenshots show frames from these works. The media files themselves are not in the
@@ -44,6 +67,7 @@ is traced or derived from Adobe artwork.
 | Asset | Where |
 |---|---|
 | UI icons (tools, transport, panels, header) | `crates/ui-egui/src/icons.rs`: vector paths on a 16×16 grid |
+| Align / distribute / paragraph-alignment glyphs in the graphics panel | `crates/ui-egui/src/panels/graphics.rs` (`align_glyph`): bars and lines drawn with the egui painter |
 | Demo footage (ocean sunset, aurora, city night, dunes, forest, plasma), bars and tone, counting leader, colour matte | `crates/media/src/generators.rs` |
 | Lumetri "Look" presets (Teal & Orange, Warm Film, …) | `crates/render/src/effects.rs` (`apply_look`): procedural colour transforms, not LUT files |
 | Colour palette and layout metrics | `crates/ui-egui/src/theme.rs`: colour values and sizes only; no artwork |
diff --git a/Cargo.lock b/Cargo.lock
index aca993685..4097c7b84 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1103,6 +1103,24 @@ dependencies = [
  "winit",
 ]
 
+[[package]]
+name = "egui_kittest"
+version = "0.36.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5eb3f3effb2726fee23449293e67acbf6cc6ce35525b1722bd5743bb348114d5"
+dependencies = [
+ "eframe",
+ "egui",
+ "egui-wgpu",
+ "image",
+ "kittest",
+ "log",
+ "pollster 1.0.1",
+ "serde",
+ "toml 1.1.6+spec-1.1.0",
+ "wgpu",
+]
+
 [[package]]
 name = "either"
 version = "1.18.0"
@@ -1306,6 +1324,7 @@ name = "filmcraft-aac"
 version = "0.1.0"
 dependencies = [
  "filmcraft-bitstream",
+ "filmcraft-testkit",
  "rayon",
  "thiserror 2.0.21",
 ]
@@ -1313,6 +1332,9 @@ dependencies = [
 [[package]]
 name = "filmcraft-audio-dsp"
 version = "0.1.0"
+dependencies = [
+ "filmcraft-testkit",
+]
 
 [[package]]
 name = "filmcraft-automation"
@@ -1343,9 +1365,9 @@ version = "0.1.0"
 dependencies = [
  "filmcraft-color",
  "filmcraft-project",
+ "filmcraft-text",
  "filmcraft-time",
  "proptest",
- "skrifa",
  "thiserror 2.0.21",
 ]
 
@@ -1378,6 +1400,7 @@ dependencies = [
  "filmcraft-opus",
  "filmcraft-prores",
  "filmcraft-time",
+ "filmcraft-vp9",
  "image",
  "log",
  "symphonia",
@@ -1419,6 +1442,7 @@ dependencies = [
  "filmcraft-media",
  "filmcraft-project",
  "filmcraft-render",
+ "filmcraft-text",
  "filmcraft-time",
  "log",
  "serde",
@@ -1439,6 +1463,7 @@ dependencies = [
  "filmcraft-project",
  "filmcraft-prores",
  "filmcraft-render",
+ "filmcraft-testkit",
  "filmcraft-time",
  "image",
  "rayon",
@@ -1477,6 +1502,21 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "filmcraft-golden"
+version = "0.1.0"
+dependencies = [
+ "filmcraft-geom",
+ "filmcraft-gpu",
+ "filmcraft-media",
+ "filmcraft-project",
+ "filmcraft-render",
+ "filmcraft-testkit",
+ "filmcraft-time",
+ "pollster 0.4.0",
+ "wgpu",
+]
+
 [[package]]
 name = "filmcraft-gpu"
 version = "0.1.0"
@@ -1498,6 +1538,7 @@ name = "filmcraft-h264"
 version = "0.1.0"
 dependencies = [
  "filmcraft-bitstream",
+ "filmcraft-testkit",
  "rayon",
  "thiserror 2.0.21",
 ]
@@ -1507,6 +1548,7 @@ name = "filmcraft-h264enc"
 version = "0.1.0"
 dependencies = [
  "filmcraft-bitstream",
+ "filmcraft-testkit",
  "rayon",
  "thiserror 2.0.21",
 ]
@@ -1516,6 +1558,7 @@ name = "filmcraft-hevc"
 version = "0.1.0"
 dependencies = [
  "filmcraft-bitstream",
+ "filmcraft-testkit",
  "rayon",
  "thiserror 2.0.21",
 ]
@@ -1541,6 +1584,7 @@ name = "filmcraft-isobmff"
 version = "0.1.0"
 dependencies = [
  "filmcraft-bitstream",
+ "filmcraft-testkit",
  "proptest",
  "serde_json",
  "thiserror 2.0.21",
@@ -1550,6 +1594,7 @@ dependencies = [
 name = "filmcraft-matroska"
 version = "0.1.0"
 dependencies = [
+ "filmcraft-testkit",
  "serde_json",
 ]
 
@@ -1569,6 +1614,9 @@ dependencies = [
 [[package]]
 name = "filmcraft-opus"
 version = "0.1.0"
+dependencies = [
+ "filmcraft-testkit",
+]
 
 [[package]]
 name = "filmcraft-project"
@@ -1589,6 +1637,7 @@ name = "filmcraft-prores"
 version = "0.1.0"
 dependencies = [
  "filmcraft-bitstream",
+ "filmcraft-testkit",
  "rayon",
  "thiserror 2.0.21",
 ]
@@ -1604,6 +1653,7 @@ dependencies = [
  "filmcraft-geom",
  "filmcraft-media",
  "filmcraft-project",
+ "filmcraft-text",
  "filmcraft-time",
  "image",
  "rayon",
@@ -1611,6 +1661,24 @@ dependencies = [
  "serde_json",
 ]
 
+[[package]]
+name = "filmcraft-testkit"
+version = "0.1.0"
+dependencies = [
+ "png",
+]
+
+[[package]]
+name = "filmcraft-text"
+version = "0.1.0"
+dependencies = [
+ "filmcraft-color",
+ "harfrust",
+ "skrifa",
+ "unicode-bidi",
+ "unicode-linebreak",
+]
+
 [[package]]
 name = "filmcraft-time"
 version = "0.1.0"
@@ -1625,6 +1693,7 @@ version = "0.1.0"
 dependencies = [
  "eframe",
  "egui",
+ "egui_kittest",
  "filmcraft-audio-dsp",
  "filmcraft-codecs",
  "filmcraft-color",
@@ -1636,7 +1705,9 @@ dependencies = [
  "filmcraft-media",
  "filmcraft-project",
  "filmcraft-render",
+ "filmcraft-text",
  "filmcraft-time",
+ "image",
  "log",
  "pollster 0.4.0",
  "rayon",
@@ -1645,6 +1716,15 @@ dependencies = [
  "serde_json",
 ]
 
+[[package]]
+name = "filmcraft-vp9"
+version = "0.1.0"
+dependencies = [
+ "filmcraft-bitstream",
+ "rayon",
+ "thiserror 2.0.21",
+]
+
 [[package]]
 name = "find-msvc-tools"
 version = "0.1.14"
@@ -2458,6 +2538,16 @@ version = "3.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e2db585e1d738fc771bf08a151420d3ed193d9d895a36df7f6f8a9456b911ddc"
 
+[[package]]
+name = "kittest"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "90ceaa75eb0036a32b6b9833962eb18137449e9817e2e586006471925b727fd5"
+dependencies = [
+ "accesskit",
+ "accesskit_consumer 0.35.0",
+]
+
 [[package]]
 name = "kurbo"
 version = "0.13.1"
@@ -3955,6 +4045,15 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "serde_spanned"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6662b5879511e06e8999a8a235d848113e942c9124f211511b16466ee2995f26"
+dependencies = [
+ "serde_core",
+]
+
 [[package]]
 name = "shlex"
 version = "2.0.1"
@@ -4332,7 +4431,7 @@ dependencies = [
  "cfg-expr",
  "heck 0.5.0",
  "pkg-config",
- "toml",
+ "toml 0.8.2",
  "version-compare",
 ]
 
@@ -4465,11 +4564,24 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "185d8ab0dfbb35cf1399a6344d8484209c088f75f8f68230da55d48d95d43e3d"
 dependencies = [
  "serde",
- "serde_spanned",
+ "serde_spanned 0.6.9",
  "toml_datetime 0.6.3",
  "toml_edit 0.20.2",
 ]
 
+[[package]]
+name = "toml"
+version = "1.1.6+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "920602543f0911ab71da12c50d59701da54c196d1a2bf5cb4b75667f137a406a"
+dependencies = [
+ "serde_core",
+ "serde_spanned 1.1.1",
+ "toml_datetime 1.1.1+spec-1.1.0",
+ "toml_parser",
+ "winnow 1.0.4",
+]
+
 [[package]]
 name = "toml_datetime"
 version = "0.6.3"
@@ -4507,7 +4619,7 @@ checksum = "396e4d48bbb2b7554c944bde63101b5ae446cff6ec4a24227428f15eb72ef338"
 dependencies = [
  "indexmap",
  "serde",
- "serde_spanned",
+ "serde_spanned 0.6.9",
  "toml_datetime 0.6.3",
  "winnow 0.5.40",
 ]
@@ -4591,6 +4703,12 @@ version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "eaea85b334db583fe3274d12b4cd1880032beab409c0d774be044d4480ab9a94"
 
+[[package]]
+name = "unicode-bidi"
+version = "0.3.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c1cb5db39152898a79168971543b1cb5020dff7fe43c8dc468b0885f5e29df5"
+
 [[package]]
 name = "unicode-general-category"
 version = "1.1.0"
@@ -4603,6 +4721,12 @@ version = "1.0.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954"
 
+[[package]]
+name = "unicode-linebreak"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b09c83c3c29d37506a3e260c08c03743a6bb66a9cd432c6934ab501a190571f"
+
 [[package]]
 name = "unicode-segmentation"
 version = "1.13.3"
@@ -5643,6 +5767,7 @@ checksum = "e450f9b2ed1dff33c94c12589a87338689467b9c4f5d8a5710bd09a847d2c8a7"
 name = "xtask"
 version = "0.1.0"
 dependencies = [
+ "filmcraft-testkit",
  "serde_json",
 ]
 
diff --git a/Cargo.toml b/Cargo.toml
index 71bb13049..00ddb8419 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -7,7 +7,7 @@ default-members = ["crates/*", "apps/*", "xtask"]
 version = "0.1.0"
 edition = "2024"
 license = "MIT OR Apache-2.0"
-rust-version = "1.90"
+rust-version = "1.95"
 repository = "https://github.com/storytold/filmcraft"
 
 [workspace.dependencies]
@@ -20,6 +20,7 @@ filmcraft-isobmff = { path = "crates/isobmff" }
 filmcraft-matroska = { path = "crates/matroska" }
 filmcraft-h264 = { path = "crates/h264" }
 filmcraft-hevc = { path = "crates/hevc" }
+filmcraft-vp9 = { path = "crates/vp9" }
 filmcraft-prores = { path = "crates/prores" }
 filmcraft-aac = { path = "crates/aac" }
 filmcraft-opus = { path = "crates/opus" }
@@ -31,6 +32,7 @@ filmcraft-codecs = { path = "crates/codecs" }
 filmcraft-project = { path = "crates/project" }
 filmcraft-edit = { path = "crates/edit" }
 filmcraft-interchange = { path = "crates/interchange" }
+filmcraft-text = { path = "crates/text" }
 filmcraft-captions = { path = "crates/captions" }
 filmcraft-render = { path = "crates/render" }
 filmcraft-gpu = { path = "crates/gpu" }
@@ -39,6 +41,7 @@ filmcraft-format = { path = "crates/format" }
 filmcraft-engine = { path = "crates/engine" }
 filmcraft-ui-egui = { path = "crates/ui-egui" }
 filmcraft-automation = { path = "crates/automation" }
+filmcraft-testkit = { path = "crates/testkit" }
 
 # foundation
 thiserror = "2"
@@ -90,6 +93,9 @@ opt-level = 3
 [profile.dev.package.filmcraft-opus]
 opt-level = 3
 
+[profile.dev.package.filmcraft-vp9]
+opt-level = 3
+
 [profile.release]
 lto = "thin"
 codegen-units = 1
diff --git a/ROADMAP.md b/ROADMAP.md
index f86088ad3..07f802140 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -2,7 +2,7 @@
 
 Progress toward feature parity with Adobe Premiere Pro, with estimates. Updated as milestones land.
 
-**Last updated:** 2026-09-30 (midday) · **Overall parity:** ~32% · **Code:** ~71k lines of Rust, 400+ tests
+**Last updated:** 2026-10-01 · **Overall parity:** ~45% · **Code:** ~125k lines of Rust in 31 crates, 800+ tests
 
 ## Estimate to parity
 
@@ -31,24 +31,28 @@ Status: ✅ done · 🟡 in progress · ⬜ not started. Estimates are remaining
 | M0 | Skeleton + visual shell | ✅ | Workspace, 20 crates, dock/workspaces, Premiere 26 look, native menus, control channel, MCP, xtask gates (layers, wasm) | — | — |
 | M1 | Media I/O | ✅ | MP4/MOV demux+mux, WAV, stills, MJPEG, symphonia audio (MP3/FLAC/ALAC/Vorbis), GOP seek + frame cache, import | Media Browser polish | 2 |
 | M2 | H.264 decoder | ✅ | Own decoder, bit-exact on 37+ streams, 500–600 fps 1080p | — | — |
-| M3 | Editing core | 🟡 | Edit algebra (insert/overwrite/razor/lift/extract/ripple/roll/slip/slide/rate-stretch/nest/paste), tools, markers | Trim mode + dynamic trimming, multicam, subclips, keyboard shortcut editor | 10–15 |
+| M3 | Editing core | 🟡 | Edit algebra (insert/overwrite/razor/lift/extract/ripple/roll/slip/slide/rate-stretch/nest/paste), tools, markers, trim mode + Trim Monitor + dynamic J/K/L trimming, Keyboard Shortcuts editor with FilmCraft/Premiere/FCP/Avid presets | Multicam, subclip polish, ~220 Premiere default shortcuts whose commands don't exist yet | 6–10 |
 | M4 | Playback | 🟡 | Audio-clock master, prefetch, J/K/L, dropped-frame stats, playback resolution | Render previews, render bar, 4K/8K tuning | 8–12 |
 | M5 | Effects, keyframes, GPU | 🟡 | ~60 CPU effects, 30 transitions, keyframes + value/velocity graphs, wgpu compositor | Full ~150-effect catalogue, WGSL parity for all, masks + tracking, adjustment layers, presets, Warp Stabilizer, Morph Cut | 30–45 |
 | M6 | Export | ✅ | Own H.264 encoder (High/Main/Baseline, B-frames, VBR/CBR/2-pass) → MP4 + own AAC; ProRes, MJPEG, PNG, GIF, WAV; background jobs | Preset library, queue UI, smart render | 6–8 |
-| M7 | Audio | 🟡 | Mixer basics, peak meters, BS.1770 loudness meters (M/S/I LUFS, true peak; matches ffmpeg), DSP crate, 12 clip audio effects running on it (EQ, filters, dynamics, limiter, delay, reverb, DeNoise, DeHum, pitch) with keyframes | Effects UI polish (EQ curve), remaining effects (multiband, convolution reverb), track effects/mixers with automation, Essential Sound, audio transitions, 5.1 | 6–10 |
+| M7 | Audio | 🟡 | Mixer graph (tracks → submixes → Mix, pre/post-fader inserts and sends, latency-compensated, sample-accurate, ~6× realtime for 24 tracks × 3 effects on one core), Audio Track Mixer + Audio Clip Mixer panels, track automation (Off/Read/Latch/Touch/Write, recorded live while playing, thinned to keyframes, timeline lanes with pen editing), solo/solo-safe, channel mapping basics, peak + BS.1770 loudness meters (match ffmpeg), DSP crate with 12 clip/track effects, Audio Gain (set/adjust/normalize), Constant Power / Constant Gain / Exponential Fade | Essential Sound, 5.1 panner and multichannel buses, voice-over record, effect editor windows (EQ curve), remaining effects (multiband, convolution reverb), clip-mixer automation recording | 6–9 |
 | M8 | Colour | 🟡 | Lumetri: basic, creative + looks, RGB & hue curves, wheels, HSL secondary, vignette; basic scopes | LUT import UI, colour match, colour management + HDR (PQ/HLG, log, tone mapping) | 8–12 |
-| M9 | More codecs | 🟡 | ProRes decode+encode, AAC decode+encode, HEVC Main/Main 10 decoder (bit-exact on 41 fixtures, ~225 fps 1080p), Matroska/WebM import (H.264/HEVC/ProRes/MJPEG + AAC/Opus/FLAC/MP3/Vorbis/PCM), Opus decoder (SILK/CELT/hybrid, 5.1/7.1 multistream; all RFC 8251 vectors range-exact; WebM/MKV/MP4) | VP9 (in progress), Ogg Opus files, AV1 (rav1d), DNxHR, MXF, hardware decode | 12–20 |
-| M10 | Graphics & captions | 🟡 | Caption tracks (Subtitle/CEA-608/708/Teletext formats, track style), SRT/WebVTT/SCC import+export (frame-exact, property-tested), caption editing (add/split/merge/trim/move, sync-locked insert/extract), Text panel Captions tab, burn-in in Program monitor and export | Text engine with shaping, Type tool, Essential Graphics, rolls/crawls, MCC/STL/TTML, 608/708 embedding, speech-to-text | 18–27 |
+| M9 | More codecs | 🟡 | ProRes decode+encode, AAC decode+encode, HEVC Main/Main 10 decoder (bit-exact on 41 fixtures, ~225 fps 1080p), VP9 decoder (profiles 0–3, 8/10/12-bit, bit-exact on 50+ fixtures; WebM/MKV `V_VP9` and MP4 `vp09` import with key-frame-checked seeking), Matroska/WebM import (H.264/HEVC/VP9/ProRes/MJPEG + AAC/Opus/FLAC/MP3/Vorbis/PCM), Opus decoder (SILK/CELT/hybrid, 5.1/7.1 multistream; all RFC 8251 vectors range-exact; WebM/MKV/MP4) | VP9 frame threading, Ogg Opus files, AV1 (rav1d), DNxHR, MXF, hardware decode | 12–20 |
+| M10 | Graphics & captions | 🟡 | Caption tracks (Subtitle/CEA-608/708/Teletext formats, track style), SRT/WebVTT/SCC import+export (frame-exact, property-tested), caption editing (add/split/merge/trim/move, sync-locked insert/extract), Text panel Captions tab, burn-in in Program monitor and export; text engine (`crates/text`: bundled + system fonts, harfrust shaping, bidi, line breaking, paragraph layout, glyph cache; 3-line 1080p title ≈ 0.15 ms warm); graphic clips with text + shape layers (fill, 2 strokes, background, shadow, keyframable transform), Type tool with on-monitor editing, shape/pen tools, Properties/Essential Graphics editor, align/distribute | Responsive design pins, rolls/crawls, per-character styles, motion graphics templates, MCC/STL/TTML, 608/708 embedding, speech-to-text | 12–18 |
 | M11 | Interchange & project management | 🟡 | `.fcproj` schema versions + migrations, atomic saves, Save a Copy/Revert, auto-save ring + crash-recovery journal (Preferences ▸ Auto Save, recovery prompt), FCP7 XML, FCPXML, EDL, OTIO | Relink/offline, project manager, proxies | 8 |
 | M12–M16 | Web (WASM), platform, long tail | 🟡 | L0–L4 crates compile to wasm32 | Web app shell (file access, WebCodecs, audio), ~850 remaining commands and dialogs, performance hardening | 40–65 |
 
 ## Running now
 
-- VP9 decoder (`crates/vp9`), from the public VP9 bitstream spec
-- Interchange (`crates/interchange`): CMX 3600 EDL, FCP7 XML, FCPXML, OTIO import and export
+- Playback: fix a UI hang after preview renders, then a load-robust playback benchmark and profiling (target: 3 × 1080p streams with 0 dropped frames)
 
 ## Log
 
+- **2026-10-01 (later):** text engine (shaping, bidi, line breaking) + Type/Shape/Pen tools + graphic clips + graphics panel; Trim Monitor + dynamic trimming; Keyboard Shortcuts editor; audio mixer with automation. Fixed: MP4 muxer wrote unreadable all-empty sample tables; system font scan race.
+
+- **2026-10-01:** Audio mixing (M7.2/M7.5/M7.6 basics): mixer graph with submixes, sends, inserts and latency compensation; Audio Track / Clip Mixer panels; Latch/Touch/Write automation recorded live; timeline track keyframes; Audio Gain dialog.
+- **2026-10-01:** recovered from a machine crash with no lost work. Merged: VP9 decoder (profiles 0–3, bit-exact, WebM/MKV/MP4), Opus decoder (RFC 8251 range-exact; WebM/MKV/MP4), captions (SRT/VTT/SCC, burn-in), render bar + render previews, project schema versioning + atomic saves + auto-save + crash-recovery journal, test infrastructure (golden images, loudness oracle vs ffmpeg, headless scripted UI tests; fixed a GPU stale-texture bug), public contributor docs and licence files.
+
 - **2026-09-30 (evening):** Opus decoder (RFC 6716/8251, range-exact on every conformance vector, ~80–110× realtime 48 kHz stereo) wired into WebM/MKV and MP4 import.
 - **2026-09-30 (afternoon):** Matroska/WebM import; LUFS meters; clip audio effects on the DSP crate.
 - **2026-09-30 (midday):** HEVC decoder, Matroska/WebM demuxer and audio DSP merged; HEVC import wired; asset rules (AGENTS.md, ATTRIBUTION.md, `cargo xtask assets`); README with hero screenshot and the Craft family.
diff --git a/apps/filmcraft/src/main.rs b/apps/filmcraft/src/main.rs
index c5f691d66..f39a8a423 100644
--- a/apps/filmcraft/src/main.rs
+++ b/apps/filmcraft/src/main.rs
@@ -111,12 +111,16 @@ fn main() -> eframe::Result {
             app.hooks.pick_save_as = Some(Box::new(|filter: &str, exts: &[&str], name: &str| {
                 rfd::FileDialog::new().add_filter(filter, exts).set_file_name(name).save_file().map(|p| p.to_string_lossy().to_string())
             }));
+            app.hooks.pick_open_file = Some(Box::new(|filter: &str, exts: &[&str]| {
+                rfd::FileDialog::new().add_filter(filter, exts).pick_file().map(|p| p.to_string_lossy().to_string())
+            }));
             app.hooks.pick_open_project =
                 Some(Box::new(|| rfd::FileDialog::new().add_filter("FilmCraft Project", &["fcproj"]).pick_file().map(|p| p.to_string_lossy().to_string())));
             #[cfg(target_os = "macos")]
             {
-                let rx = native_menu::install(&app, cc.egui_ctx.clone());
+                let (rx, update) = native_menu::install(&app, cc.egui_ctx.clone());
                 app.command_inbox = Some(rx);
+                app.hooks.shortcuts_changed = Some(update);
                 app.ui.show_menu_bar = false;
             }
             if let Some(port) = control_port {
diff --git a/apps/filmcraft/src/native_menu.rs b/apps/filmcraft/src/native_menu.rs
index 3f9a6543e..fd1422948 100644
--- a/apps/filmcraft/src/native_menu.rs
+++ b/apps/filmcraft/src/native_menu.rs
@@ -19,8 +19,12 @@ fn accel(s: &str) -> Option<Accelerator> {
     mapped.parse().ok()
 }
 
-pub fn install(app: &FilmcraftApp, ctx: egui::Context) -> Receiver<String> {
+/// Updates native key equivalents when the active keyboard shortcuts change.
+pub type ShortcutUpdater = Box<dyn FnMut(&[Item])>;
+
+pub fn install(app: &FilmcraftApp, ctx: egui::Context) -> (Receiver<String>, ShortcutUpdater) {
     let items = menu_items(app);
+    let mut native: Vec<(String, MenuItem)> = Vec::new();
     let bar = Menu::new();
     let app_menu = Submenu::new("FilmCraft", true);
     let _ = app_menu.append_items(&[
@@ -40,6 +44,7 @@ pub fn install(app: &FilmcraftApp, ctx: egui::Context) -> Receiver<String> {
         let mut subs: Vec<(String, Submenu)> = Vec::new();
         for it in mine {
             let mi = MenuItem::with_id(it.id.clone(), &it.label, true, it.shortcut.as_deref().and_then(accel));
+            native.push((it.id.clone(), mi.clone()));
             if let Some(name) = it.path.get(1) {
                 if let Some((_, s)) = subs.iter().find(|(n, _)| n == name) {
                     let _ = s.append(&mi);
@@ -69,5 +74,12 @@ pub fn install(app: &FilmcraftApp, ctx: egui::Context) -> Receiver<String> {
             ctx.request_repaint();
         }
     });
-    rx
+    let update: ShortcutUpdater = Box::new(move |items: &[Item]| {
+        for (id, mi) in &native {
+            if let Some(it) = items.iter().find(|i| &i.id == id) {
+                let _ = mi.set_accelerator(it.shortcut.as_deref().and_then(accel));
+            }
+        }
+    });
+    (rx, update)
 }
diff --git a/assets/fonts/Inter-Bold.ttf b/assets/fonts/Inter-Bold.ttf
new file mode 100644
index 000000000..9fb9b751e
Binary files /dev/null and b/assets/fonts/Inter-Bold.ttf differ
diff --git a/assets/fonts/Inter-Bold.ttf.attribution b/assets/fonts/Inter-Bold.ttf.attribution
new file mode 100644
index 000000000..6f2ca0b1d
--- /dev/null
+++ b/assets/fonts/Inter-Bold.ttf.attribution
@@ -0,0 +1,8 @@
+asset:        Inter-Bold.ttf
+title:        Inter Bold (text engine / graphics)
+author:       The Inter Project Authors (Rasmus Andersson et al.)
+source:       https://github.com/rsms/inter (release v4.1, extras/ttf)
+license:      OFL-1.1
+license-file: assets/fonts/OFL-Inter.txt
+added:        2026-10-01 by Claude (agent) for Brandon Thomas
+notes:        Unmodified font file, bundled via include_bytes! in the text engine (crates/text/src/fonts.rs) for graphics text, titles and burn-ins.
diff --git a/assets/fonts/Inter-Italic.ttf b/assets/fonts/Inter-Italic.ttf
new file mode 100644
index 000000000..e7ed211d2
Binary files /dev/null and b/assets/fonts/Inter-Italic.ttf differ
diff --git a/assets/fonts/Inter-Italic.ttf.attribution b/assets/fonts/Inter-Italic.ttf.attribution
new file mode 100644
index 000000000..e346bc98d
--- /dev/null
+++ b/assets/fonts/Inter-Italic.ttf.attribution
@@ -0,0 +1,8 @@
+asset:        Inter-Italic.ttf
+title:        Inter Italic (text engine / graphics)
+author:       The Inter Project Authors (Rasmus Andersson et al.)
+source:       https://github.com/rsms/inter (release v4.1, extras/ttf)
+license:      OFL-1.1
+license-file: assets/fonts/OFL-Inter.txt
+added:        2026-10-01 by Claude (agent) for Brandon Thomas
+notes:        Unmodified font file, bundled via include_bytes! in the text engine (crates/text/src/fonts.rs) for graphics text, titles and burn-ins.
diff --git a/assets/fonts/Inter-Medium.ttf.attribution b/assets/fonts/Inter-Medium.ttf.attribution
index 20dc0cf41..707fc56c8 100644
--- a/assets/fonts/Inter-Medium.ttf.attribution
+++ b/assets/fonts/Inter-Medium.ttf.attribution
@@ -5,4 +5,4 @@ source:       https://github.com/rsms/inter
 license:      OFL-1.1
 license-file: assets/fonts/OFL-Inter.txt
 added:        2026-09-30 by Claude (agent) for Brandon Thomas
-notes:        Unmodified font file, embedded in the UI via include_bytes! (crates/ui-egui/src/theme.rs).
+notes:        Unmodified font file, embedded via include_bytes! in the text engine (crates/text/src/fonts.rs), which also supplies it to the UI (crates/ui-egui/src/theme.rs).
diff --git a/assets/fonts/Inter-Regular.ttf.attribution b/assets/fonts/Inter-Regular.ttf.attribution
index c4f496fbc..052b01130 100644
--- a/assets/fonts/Inter-Regular.ttf.attribution
+++ b/assets/fonts/Inter-Regular.ttf.attribution
@@ -5,4 +5,4 @@ source:       https://github.com/rsms/inter
 license:      OFL-1.1
 license-file: assets/fonts/OFL-Inter.txt
 added:        2026-09-30 by Claude (agent) for Brandon Thomas
-notes:        Unmodified font file, embedded in the UI via include_bytes! (crates/ui-egui/src/theme.rs).
+notes:        Unmodified font file, embedded via include_bytes! in the text engine (crates/text/src/fonts.rs), which also supplies it to the UI (crates/ui-egui/src/theme.rs).
diff --git a/assets/fonts/Inter-SemiBold.ttf.attribution b/assets/fonts/Inter-SemiBold.ttf.attribution
index 771822f07..e010cad7e 100644
--- a/assets/fonts/Inter-SemiBold.ttf.attribution
+++ b/assets/fonts/Inter-SemiBold.ttf.attribution
@@ -5,4 +5,4 @@ source:       https://github.com/rsms/inter
 license:      OFL-1.1
 license-file: assets/fonts/OFL-Inter.txt
 added:        2026-09-30 by Claude (agent) for Brandon Thomas
-notes:        Unmodified font file, embedded via include_bytes! in the UI (crates/ui-egui/src/theme.rs) and as the caption burn-in font (crates/captions/src/font.rs).
+notes:        Unmodified font file, embedded via include_bytes! in the text engine (crates/text/src/fonts.rs; caption burn-in, graphics), which also supplies it to the UI (crates/ui-egui/src/theme.rs).
diff --git a/assets/fonts/JetBrainsMono-Regular.ttf.attribution b/assets/fonts/JetBrainsMono-Regular.ttf.attribution
index ab720f6cf..f185af97b 100644
--- a/assets/fonts/JetBrainsMono-Regular.ttf.attribution
+++ b/assets/fonts/JetBrainsMono-Regular.ttf.attribution
@@ -5,4 +5,4 @@ source:       https://github.com/JetBrains/JetBrainsMono
 license:      OFL-1.1
 license-file: assets/fonts/OFL-JetBrainsMono.txt
 added:        2026-09-30 by Claude (agent) for Brandon Thomas
-notes:        Unmodified font file, embedded in the UI via include_bytes! (crates/ui-egui/src/theme.rs).
+notes:        Unmodified font file, embedded via include_bytes! in the text engine (crates/text/src/fonts.rs), which also supplies it to the UI (crates/ui-egui/src/theme.rs).
diff --git a/assets/fonts/NotoSerif-Regular.ttf b/assets/fonts/NotoSerif-Regular.ttf
new file mode 100644
index 000000000..9fe4b2986
Binary files /dev/null and b/assets/fonts/NotoSerif-Regular.ttf differ
diff --git a/assets/fonts/NotoSerif-Regular.ttf.attribution b/assets/fonts/NotoSerif-Regular.ttf.attribution
new file mode 100644
index 000000000..8d09443bb
--- /dev/null
+++ b/assets/fonts/NotoSerif-Regular.ttf.attribution
@@ -0,0 +1,8 @@
+asset:        NotoSerif-Regular.ttf
+title:        Noto Serif Regular (serif face of the text engine / graphics)
+author:       The Noto Project Authors
+source:       https://github.com/notofonts/notofonts.github.io (fonts/NotoSerif/unhinted/ttf)
+license:      OFL-1.1
+license-file: assets/fonts/OFL-NotoSerif.txt
+added:        2026-10-01 by Claude (agent) for Brandon Thomas
+notes:        Unmodified font file, bundled via include_bytes! in the text engine (crates/text/src/fonts.rs) for graphics text, titles and burn-ins.
diff --git a/assets/fonts/OFL-NotoSerif.txt b/assets/fonts/OFL-NotoSerif.txt
new file mode 100644
index 000000000..6843f3187
--- /dev/null
+++ b/assets/fonts/OFL-NotoSerif.txt
@@ -0,0 +1,93 @@
+Copyright 2022 The Noto Project Authors (https://github.com/notofonts/latin-greek-cyrillic)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+https://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
diff --git a/crates/aac/Cargo.toml b/crates/aac/Cargo.toml
index 1f1203da8..1bc264263 100644
--- a/crates/aac/Cargo.toml
+++ b/crates/aac/Cargo.toml
@@ -17,3 +17,6 @@ rayon = ["dep:rayon"]
 filmcraft-bitstream = { workspace = true }
 thiserror = { workspace = true }
 rayon = { workspace = true, optional = true }
+
+[dev-dependencies]
+filmcraft-testkit = { workspace = true }
diff --git a/crates/aac/tests/common/mod.rs b/crates/aac/tests/common/mod.rs
index 7ffc04c20..eb0551728 100644
--- a/crates/aac/tests/common/mod.rs
+++ b/crates/aac/tests/common/mod.rs
@@ -5,19 +5,13 @@ use std::process::Command;
 
 use filmcraft_aac::{Decoder, Encoder, EncoderConfig, EncoderStats, split_adts};
 
+/// ffmpeg (see `filmcraft_testkit::oracle`); `None` after printing `SKIPPED`.
 pub fn ffmpeg() -> Option<PathBuf> {
-    for p in ["/opt/homebrew/bin/ffmpeg", "/usr/local/bin/ffmpeg", "/usr/bin/ffmpeg"] {
-        if Path::new(p).exists() {
-            return Some(PathBuf::from(p));
-        }
-    }
-    None
+    filmcraft_testkit::ffmpeg_or_skip("aac oracle")
 }
 
 pub fn fixtures() -> PathBuf {
-    let d = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../target/fixtures/aac");
-    std::fs::create_dir_all(&d).unwrap();
-    d
+    filmcraft_testkit::fixtures_dir("aac")
 }
 
 pub struct Rng(pub u64);
diff --git a/crates/audio-dsp/Cargo.toml b/crates/audio-dsp/Cargo.toml
index bc1a0483b..aef31dba1 100644
--- a/crates/audio-dsp/Cargo.toml
+++ b/crates/audio-dsp/Cargo.toml
@@ -11,3 +11,6 @@ workspace = true
 
 # Intentionally dependency-free (layer L1): planar `&mut [f32]` slices in, planar slices out.
 [dependencies]
+
+[dev-dependencies]
+filmcraft-testkit = { workspace = true }
diff --git a/crates/audio-dsp/README.md b/crates/audio-dsp/README.md
index 99c85a0fd..e1ae13a6c 100644
--- a/crates/audio-dsp/README.md
+++ b/crates/audio-dsp/README.md
@@ -24,6 +24,9 @@ Householder FDN, phase vocoder).
 - Gated integrated loudness (−70 LUFS / −10 LU) and LRA (−70 / −20 LU, 10th–95th percentile) use a
   0.01 LU histogram with exact energy sums: fixed memory for programmes of any length.
 - True peak: 4× (2× at 88.2/96 kHz) polyphase Kaiser-sinc interpolation.
+- Oracle-tested against ffmpeg's `ebur128` filter (`tests/loudness_oracle.rs`, skipped without ffmpeg):
+  M/S within 0.0005 LU, I within 0.007 LU, LRA within 0.04 LU and true peak within 0.045 dB (0.053 dB of the analytic value on an fs/4 tone) on
+  sine, pink-noise, speech-like and gated stereo signals at 44.1/48/96 kHz.
 - `normalize_gain_db(measured, target)` and `normalize_gain_db_peak_limited(...)` for Normalize /
   Essential Sound loudness auto-match.
 
diff --git a/crates/audio-dsp/tests/loudness_oracle.rs b/crates/audio-dsp/tests/loudness_oracle.rs
new file mode 100644
index 000000000..1a3b82765
--- /dev/null
+++ b/crates/audio-dsp/tests/loudness_oracle.rs
@@ -0,0 +1,285 @@
+//! Oracle test: BS.1770-4 / EBU R128 loudness against ffmpeg's `ebur128` filter.
+//!
+//! Each signal is generated here, written as a 32-bit float WAV and measured twice: by
+//! `LoudnessMeter` and by `ffmpeg -af ebur128=peak=true:metadata=1,ametadata=print` (three decimals
+//! per 100 ms frame). ffmpeg is an external oracle only (never linked).
+//!
+//! Tolerances (EBU Tech 3341 allows ±0.1 LU for M/S/I and +0.2/−0.4 dB for true peak; Tech 3342
+//! allows ±1 LU for LRA):
+//! - momentary (every 100 ms once 400 ms have been seen) and short-term (once 3 s have been seen):
+//!   ±0.1 LU wherever ffmpeg reads above −70 LUFS;
+//! - integrated: ±0.1 LU;
+//! - loudness range: ±0.5 LU;
+//! - true peak: ±0.2 dB (both are 4× oversampling estimates with different interpolators).
+
+use filmcraft_audio_dsp::loudness::LoudnessMeter;
+use std::f64::consts::PI;
+use std::path::Path;
+use std::process::Command;
+
+const TOL_MS: f64 = 0.1;
+const TOL_I: f64 = 0.1;
+const TOL_LRA: f64 = 0.5;
+const TOL_TP_DB: f64 = 0.2;
+
+/// ffmpeg's per-100 ms frame values.
+#[derive(Clone, Copy, Debug, Default)]
+struct Frame {
+    m: f64,
+    s: f64,
+    i: f64,
+    lra: f64,
+    true_peak: f64,
+}
+
+fn ffmpeg_ebur128(ff: &Path, wav: &Path) -> Vec<Frame> {
+    let out = Command::new(ff)
+        .args(["-hide_banner", "-nostats", "-v", "error", "-i"])
+        .arg(wav)
+        .args(["-af", "ebur128=peak=true:metadata=1,ametadata=mode=print:file=-", "-f", "null", "-"])
+        .output()
+        .expect("run ffmpeg");
+    assert!(out.status.success(), "ffmpeg ebur128 failed: {}", String::from_utf8_lossy(&out.stderr));
+    let mut frames = Vec::new();
+    let mut cur: Option<Frame> = None;
+    for line in String::from_utf8_lossy(&out.stdout).lines() {
+        if line.starts_with("frame:") {
+            frames.extend(cur.take());
+            cur = Some(Frame::default());
+            continue;
+        }
+        let (Some(f), Some((k, v))) = (cur.as_mut(), line.strip_prefix("lavfi.r128.").and_then(|l| l.split_once('='))) else { continue };
+        let v: f64 = v.trim().parse().unwrap_or(f64::NAN);
+        match k {
+            "M" => f.m = v,
+            "S" => f.s = v,
+            "I" => f.i = v,
+            "LRA" => f.lra = v,
+            "true_peak" => f.true_peak = v,
+            _ => {}
+        }
+    }
+    frames.extend(cur);
+    frames
+}
+
+/// Our measurements after each 100 ms block: (M, S) per block, plus the final meter.
+fn ours(chans: &[Vec<f32>], sr: u32) -> (Vec<(f64, f64)>, LoudnessMeter) {
+    let mut m = LoudnessMeter::new(sr as f64, chans.len());
+    let block = sr as usize / 10;
+    let n = chans[0].len();
+    let mut per = Vec::new();
+    let mut pos = 0;
+    while pos < n {
+        let end = (pos + block).min(n);
+        let slices: Vec<&[f32]> = chans.iter().map(|c| &c[pos..end]).collect();
+        m.process(&slices);
+        per.push((m.momentary(), m.short_term()));
+        pos = end;
+    }
+    (per, m)
+}
+
+struct Report {
+    max_dm: f64,
+    max_ds: f64,
+    i: (f64, f64),
+    lra: (f64, f64),
+    tp: (f64, f64),
+    /// True-peak reference used (analytic value when known, else ffmpeg).
+    tp_ref: f64,
+}
+
+/// Measure `chans` with both meters and check the tolerances. `tp_truth`: the analytic true peak
+/// (dBTP) when known; it then replaces ffmpeg as the true-peak reference.
+fn compare(ff: &Path, name: &'static str, chans: &[Vec<f32>], sr: u32, tp_truth: Option<f64>) -> Report {
+    let dir = filmcraft_testkit::fixtures_dir("audio-dsp/loudness");
+    let wav = dir.join(format!("{name}_{sr}.wav"));
+    let tmp = filmcraft_testkit::temp_path(&wav);
+    let refs: Vec<&[f32]> = chans.iter().map(|c| c.as_slice()).collect();
+    filmcraft_testkit::wav::write_f32(&tmp, &refs, sr).unwrap();
+    let frames = ffmpeg_ebur128(ff, &tmp);
+    let _ = std::fs::remove_file(&tmp);
+    let (per, meter) = ours(chans, sr);
+    assert!(frames.len() + 1 >= per.len() && !frames.is_empty(), "{name}: ffmpeg gave {} frames, we have {} blocks", frames.len(), per.len());
+    let (mut max_dm, mut max_ds, mut n_m, mut n_s) = (0f64, 0f64, 0, 0);
+    for (k, (f, (m, s))) in frames.iter().zip(&per).enumerate() {
+        let full_blocks = k + 1;
+        if full_blocks >= 4 && f.m > -70.0 {
+            let d = (f.m - m).abs();
+            assert!(d <= TOL_MS, "{name}: momentary at {:.1} s: ffmpeg {:.3}, ours {m:.3}", full_blocks as f64 / 10.0, f.m);
+            max_dm = max_dm.max(d);
+            n_m += 1;
+        }
+        if full_blocks >= 30 && f.s > -70.0 {
+            let d = (f.s - s).abs();
+            assert!(d <= TOL_MS, "{name}: short-term at {:.1} s: ffmpeg {:.3}, ours {s:.3}", full_blocks as f64 / 10.0, f.s);
+            max_ds = max_ds.max(d);
+            n_s += 1;
+        }
+    }
+    let last = frames.last().unwrap();
+    let ff_tp_db = 20.0 * last.true_peak.log10();
+    let r = Report {
+        tp_ref: tp_truth.unwrap_or(ff_tp_db),
+        max_dm,
+        max_ds,
+        i: (meter.integrated(), last.i),
+        lra: (meter.loudness_range(), last.lra),
+        tp: (meter.true_peak_dbtp(), ff_tp_db),
+    };
+    eprintln!(
+        "{name} @ {sr} Hz: I ours {:.3} / ffmpeg {:.3} LUFS; LRA {:.2} / {:.2} LU; TP {:.3} / {:.3} dBTP; max |ΔM| {:.4} over {n_m}, max |ΔS| {:.4} over {n_s}",
+        r.i.0, r.i.1, r.lra.0, r.lra.1, r.tp.0, r.tp.1, r.max_dm, r.max_ds
+    );
+    assert!(n_m > 0, "{name}: no momentary values compared");
+    assert!((r.i.0 - r.i.1).abs() <= TOL_I, "{name}: integrated ours {:.3} vs ffmpeg {:.3}", r.i.0, r.i.1);
+    assert!((r.lra.0 - r.lra.1).abs() <= TOL_LRA, "{name}: LRA ours {:.3} vs ffmpeg {:.3}", r.lra.0, r.lra.1);
+    match tp_truth {
+        Some(t) => {
+            eprintln!("{name}: analytic true peak {t:.3} dBTP: ours off by {:+.3} dB, ffmpeg off by {:+.3} dB", r.tp.0 - t, r.tp.1 - t);
+            assert!((r.tp.0 - t).abs() <= TOL_TP_DB, "{name}: true peak ours {:.3} vs analytic {t:.3} dBTP", r.tp.0);
+        }
+        None => assert!((r.tp.0 - r.tp.1).abs() <= TOL_TP_DB, "{name}: true peak ours {:.3} vs ffmpeg {:.3} dBTP", r.tp.0, r.tp.1),
+    }
+    r
+}
+
+// ---- signals ----
+
+struct Rng(u64);
+impl Rng {
+    fn next(&mut self) -> f64 {
+        self.0 ^= self.0 << 13;
+        self.0 ^= self.0 >> 7;
+        self.0 ^= self.0 << 17;
+        (self.0 >> 11) as f64 / (1u64 << 53) as f64 * 2.0 - 1.0
+    }
+}
+
+fn db(x: f64) -> f64 {
+    10f64.powf(x / 20.0)
+}
+
+fn sine(freq: f64, amp: f64, sr: u32, secs: f64, phase: f64) -> Vec<f32> {
+    (0..(secs * sr as f64) as usize).map(|i| (amp * (2.0 * PI * freq * i as f64 / sr as f64 + phase).sin()) as f32).collect()
+}
+
+/// Pink noise (Paul Kellet's refined filter on white noise), scaled to `amp` RMS-ish.
+fn pink(sr: u32, secs: f64, amp: f64, seed: u64) -> Vec<f32> {
+    let mut r = Rng(seed);
+    let (mut b0, mut b1, mut b2, mut b3, mut b4, mut b5, mut b6) = (0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
+    (0..(secs * sr as f64) as usize)
+        .map(|_| {
+            let w = r.next();
+            b0 = 0.99886 * b0 + w * 0.0555179;
+            b1 = 0.99332 * b1 + w * 0.0750759;
+            b2 = 0.96900 * b2 + w * 0.1538520;
+            b3 = 0.86650 * b3 + w * 0.3104856;
+            b4 = 0.55000 * b4 + w * 0.5329522;
+            b5 = -0.7616 * b5 - w * 0.0168980;
+            let y = b0 + b1 + b2 + b3 + b4 + b5 + b6 + w * 0.5362;
+            b6 = w * 0.115926;
+            (y * 0.11 * amp) as f32
+        })
+        .collect()
+}
+
+/// Speech-like: syllable bursts (80–300 ms) of a pitched, formant-ish signal with pauses
+/// (50–600 ms) and phrase-level level changes, so gating and the M/S windows are exercised.
+fn speech(sr: u32, secs: f64, seed: u64) -> Vec<f32> {
+    let mut r = Rng(seed);
+    let n = (secs * sr as f64) as usize;
+    let mut out = vec![0f32; n];
+    let mut pos = 0usize;
+    let mut phrase_gain = 1.0;
+    while pos < n {
+        if r.next() > 0.7 {
+            phrase_gain = db(-12.0 * (r.next() + 1.0) / 2.0);
+        }
+        let syl = ((0.08 + 0.22 * (r.next() + 1.0) / 2.0) * sr as f64) as usize;
+        let f0 = 110.0 + 60.0 * (r.next() + 1.0) / 2.0;
+        let (f1, f2) = (500.0 + 400.0 * r.next(), 1500.0 + 700.0 * r.next());
+        for i in 0..syl.min(n - pos) {
+            let t = i as f64 / sr as f64;
+            let env = (PI * i as f64 / syl as f64).sin().powi(2);
+            let mut v = 0.0;
+            for h in 1..=20 {
+                let f = f0 * h as f64;
+                if f > sr as f64 / 2.2 {
+                    break;
+                }
+                let formant = (-((f - f1) / 200.0).powi(2)).exp() + 0.5 * (-((f - f2) / 300.0).powi(2)).exp() + 0.05;
+                v += formant * (2.0 * PI * f * t).sin() / h as f64;
+            }
+            out[pos + i] = (0.3 * phrase_gain * env * v + 0.003 * r.next()) as f32;
+        }
+        pos += syl;
+        let gap = ((0.05 + 0.55 * (r.next() + 1.0) / 2.0) * sr as f64) as usize;
+        pos += gap;
+    }
+    out
+}
+
+fn concat(parts: &[Vec<f32>]) -> Vec<f32> {
+    parts.concat()
+}
+
+#[test]
+fn loudness_matches_ffmpeg_ebur128() {
+    let ff = filmcraft_testkit::require_ffmpeg!();
+    let sr = 48_000;
+    let mut reports = Vec::new();
+
+    // 1. Steady 997 Hz sine, −20 dBFS, both channels (dual mono adds +3 dB).
+    let s = sine(997.0, db(-20.0), sr, 10.0, 0.0);
+    reports.push(compare(&ff, "sine_997", &[s.clone(), s], sr, Some(-20.0)));
+
+    // 2. Independent pink noise per channel.
+    reports.push(compare(&ff, "pink_noise", &[pink(sr, 15.0, 0.5, 1), pink(sr, 15.0, 0.5, 2)], sr, None));
+
+    // 3. Speech-like bursts and pauses (exercises the relative gate and LRA).
+    let sp = speech(sr, 25.0, 7);
+    let sp2: Vec<f32> = sp.iter().map(|v| v * 0.7).collect();
+    reports.push(compare(&ff, "speech_like", &[sp, sp2], sr, None));
+
+    // 4. Stereo with silence and quiet passages: loud tone, digital silence, a −30 dBFS tone on L
+    //    only, a −50 dBFS passage (below the relative gate) and a −80 dBFS passage (below the
+    //    absolute gate).
+    let l = concat(&[
+        sine(440.0, db(-18.0), sr, 5.0, 0.0),
+        vec![0.0; 3 * sr as usize],
+        sine(1000.0, db(-30.0), sr, 5.0, 0.0),
+        pink(sr, 4.0, db(-50.0), 3),
+        pink(sr, 4.0, db(-80.0), 4),
+    ]);
+    let r = concat(&[
+        sine(440.0, db(-18.0), sr, 5.0, 0.3),
+        vec![0.0; 3 * sr as usize],
+        vec![0.0; 5 * sr as usize],
+        pink(sr, 4.0, db(-50.0), 5),
+        pink(sr, 4.0, db(-80.0), 6),
+    ]);
+    reports.push(compare(&ff, "gated_stereo", &[l, r], sr, None));
+
+    // 5. Inter-sample peaks: fs/4 at 45° phase, 0 dBFS true peak but −3 dBFS sample peak.
+    let x = sine(sr as f64 / 4.0, 0.9, sr, 5.0, PI / 4.0);
+    reports.push(compare(&ff, "intersample_peak", &[x.clone(), x], sr, Some(20.0 * 0.9f64.log10())));
+
+    // 6. Mono speech-like at 44.1 kHz (K-weighting derived for another rate; true peak at 4×).
+    let sr2 = 44_100;
+    reports.push(compare(&ff, "speech_mono_44k", &[speech(sr2, 20.0, 11)], sr2, None));
+
+    // 7. Pink noise at 96 kHz (2× true-peak oversampling).
+    reports.push(compare(&ff, "pink_noise_96k", &[pink(96_000, 8.0, 0.4, 21), pink(96_000, 8.0, 0.4, 22)], 96_000, None));
+
+    let worst = |f: fn(&Report) -> f64| reports.iter().map(f).fold(0f64, f64::max);
+    eprintln!(
+        "worst: |ΔM| {:.3}, |ΔS| {:.3}, |ΔI| {:.3}, |ΔLRA| {:.3}, |ΔTP| {:.3} dB",
+        worst(|r| r.max_dm),
+        worst(|r| r.max_ds),
+        worst(|r| (r.i.0 - r.i.1).abs()),
+        worst(|r| (r.lra.0 - r.lra.1).abs()),
+        worst(|r| (r.tp.0 - r.tp_ref).abs()),
+    );
+}
diff --git a/crates/captions/Cargo.toml b/crates/captions/Cargo.toml
index 55ce943c3..dad44780c 100644
--- a/crates/captions/Cargo.toml
+++ b/crates/captions/Cargo.toml
@@ -13,9 +13,8 @@ workspace = true
 filmcraft-time = { workspace = true }
 filmcraft-color = { workspace = true }
 filmcraft-project = { workspace = true }
+filmcraft-text = { workspace = true }
 thiserror = { workspace = true }
-# Font tables, glyph outlines and metrics (MIT OR Apache-2.0). Rasterisation is our own.
-skrifa = { version = "0.44", default-features = false, features = ["std"] }
 
 [dev-dependencies]
 proptest = { workspace = true }
diff --git a/crates/captions/README.md b/crates/captions/README.md
index 919e057c9..b988d65fb 100644
--- a/crates/captions/README.md
+++ b/crates/captions/README.md
@@ -1,7 +1,7 @@
 # filmcraft-captions
 
 Caption files and caption burn-in for FilmCraft (layer L2: depends on `filmcraft-time`,
-`filmcraft-color`, `filmcraft-project` and `skrifa`).
+`filmcraft-color`, `filmcraft-project` and `filmcraft-text`).
 
 The caption *model* (caption tracks in a sequence, captions, track style) lives in
 `filmcraft-project` (`caption.rs`) because it is part of the `.fcproj` document. This crate reads
@@ -40,16 +40,13 @@ rasterises it to a small premultiplied linear-light RGBA overlay. `filmcraft-ren
 overlays of visible caption tracks over the finished frame (Program monitor and export burn-in).
 
 Text is set in **Inter SemiBold** (`assets/fonts/Inter-SemiBold.ttf`, SIL OFL 1.1, attributed in
-`ATTRIBUTION.md`). `skrifa` (MIT OR Apache-2.0) provides glyph outlines and metrics; the
-rasteriser (`raster.rs`, non-zero winding, 5 sub-scanlines with exact horizontal coverage) is our
-own. Glyph masks are cached per character, size and quarter-pixel offset. There is no shaping or
-kerning yet; that arrives with the M10.1 text engine.
+`ATTRIBUTION.md`) by the `filmcraft-text` engine: shaped with kerning and ligatures, bidi-ordered,
+and drawn from its sub-pixel positioned glyph cache.
 
 ## Tests
 
 - Unit tests per module (timestamps, decoding, sloppy SRT, WebVTT blocks and voices, CEA-608
-  tables, PAC round trips, known SCC pop-on and roll-up streams, rasteriser coverage, glyphs,
-  layout).
+  tables, PAC round trips, known SCC pop-on and roll-up streams, layout).
 - `tests/roundtrip.rs`: property tests — SRT (also with BOM + CRLF), WebVTT (ids, speakers,
   settings, STYLE blocks) and SCC (drop-frame and non-drop, gaps and back-to-back captions)
   round-trip exactly; readers never panic on random bytes; SRT → VTT → SCC keeps text and frames.
diff --git a/crates/captions/src/burn.rs b/crates/captions/src/burn.rs
index 8fb7d75ca..5c43e5251 100644
--- a/crates/captions/src/burn.rs
+++ b/crates/captions/src/burn.rs
@@ -10,7 +10,7 @@ use filmcraft_color::srgb_to_linear;
 use filmcraft_project::{Caption, CaptionAlign, CaptionAnchor, CaptionStyle, CaptionTrack, Sequence};
 use filmcraft_time::Tick;
 
-use crate::font;
+use filmcraft_text::{ParagraphStyle, TextStyle, layout, render};
 
 /// A rendered caption: premultiplied linear-light RGBA f32 pixels at `(x, y)` in the frame.
 #[derive(Clone, Debug, PartialEq)]
@@ -49,6 +49,15 @@ impl Overlay {
     }
 }
 
+/// The caption face: Inter SemiBold at `px`.
+fn caption_style(px: f32) -> TextStyle {
+    TextStyle { style: "SemiBold".into(), size: px, ..Default::default() }
+}
+
+fn measure(text: &str, px: f32) -> f32 {
+    filmcraft_text::measure(text, &caption_style(px))
+}
+
 fn lin(c: [u8; 4]) -> [f32; 4] {
     let a = c[3] as f32 / 255.0;
     [srgb_to_linear(c[0] as f32 / 255.0) * a, srgb_to_linear(c[1] as f32 / 255.0) * a, srgb_to_linear(c[2] as f32 / 255.0) * a, a]
@@ -60,7 +69,7 @@ fn wrap(line: &str, px: f32, max_w: f32) -> Vec<String> {
     let mut cur = String::new();
     for word in line.split(' ') {
         let cand = if cur.is_empty() { word.to_string() } else { format!("{cur} {word}") };
-        if !cur.is_empty() && font::measure(&cand, px) > max_w {
+        if !cur.is_empty() && measure(&cand, px) > max_w {
             out.push(std::mem::take(&mut cur));
             cur = word.to_string();
         } else {
@@ -115,7 +124,8 @@ pub fn render_caption(c: &Caption, style: &CaptionStyle, w: usize, h: usize) ->
     if lines.is_empty() {
         return None;
     }
-    let (asc, desc) = font::metrics(px);
+    let vm = filmcraft_text::fonts::face(filmcraft_text::resolve("Inter", "SemiBold").face).metrics(px);
+    let (asc, desc) = (vm.ascent, vm.descent);
     let lh = px * style.line_spacing.max(0.8);
     let pad_x = (px * 0.3).round();
     let block_h = lh * lines.len() as f32;
@@ -131,7 +141,7 @@ pub fn render_caption(c: &Caption, style: &CaptionStyle, w: usize, h: usize) ->
     .max(0.0)
     .round();
     let side = w as f32 * 0.05;
-    let widths: Vec<f32> = lines.iter().map(|l| font::measure(l, px)).collect();
+    let widths: Vec<f32> = lines.iter().map(|l| measure(l, px)).collect();
     let xs: Vec<f32> = widths
         .iter()
         .map(|&lw| match align {
@@ -166,28 +176,10 @@ pub fn render_caption(c: &Caption, style: &CaptionStyle, w: usize, h: usize) ->
             }
         }
         let baseline = lt + (lh - (asc + desc)) / 2.0 + asc;
-        let mut pen = xs[i];
-        for ch in line.chars() {
-            if let Some(g) = font::glyph(ch, px, pen.fract()) {
-                let gx = pen.floor() as i32 + g.left - ox;
-                let gy = baseline.round() as i32 + g.top - oy;
-                for y in 0..g.mask.h {
-                    let ty = gy + y as i32;
-                    if ty < 0 || ty >= oh as i32 {
-                        continue;
-                    }
-                    for x in 0..g.mask.w {
-                        let tx = gx + x as i32;
-                        if tx < 0 || tx >= ow as i32 {
-                            continue;
-                        }
-                        let j = ty as usize * ow + tx as usize;
-                        cover[j] = (cover[j] + g.mask.get(x, y)).min(1.0);
-                    }
-                }
-            }
-            pen += font::advance(ch, px);
-        }
+        let l = layout(line, &caption_style(px), &ParagraphStyle::default());
+        let mut m = filmcraft_text::Mask { w: ow, h: oh, a: std::mem::take(&mut cover) };
+        render::draw(&l, &render::at(xs[i], baseline.round()), &mut m, (ox, oy));
+        cover = m.a;
     }
     let stroke = if outline > 0.0 { dilate(&cover, ow, oh, outline) } else { Vec::new() };
     let (tc, bc, oc) = (lin(style.color), lin(style.background_color), lin(style.outline_color));
diff --git a/crates/captions/src/font.rs b/crates/captions/src/font.rs
deleted file mode 100644
index 2aa1cf843..000000000
--- a/crates/captions/src/font.rs
+++ /dev/null
@@ -1,137 +0,0 @@
-//! The caption font: Inter SemiBold (SIL OFL 1.1, `assets/fonts/Inter-SemiBold.ttf`, attributed in
-//! ATTRIBUTION.md), read with `skrifa` and rasterised by [`crate::raster`]. Glyph masks are
-//! cached by (char, size, sub-pixel offset).
-
-use std::collections::HashMap;
-use std::sync::{Arc, Mutex, OnceLock};
-
-use skrifa::instance::{LocationRef, Size};
-use skrifa::outline::{DrawSettings, OutlinePen};
-use skrifa::{FontRef, MetadataProvider};
-
-use crate::raster::{Mask, Path, fill};
-
-static INTER_SEMIBOLD: &[u8] = include_bytes!("../../../assets/fonts/Inter-SemiBold.ttf");
-
-fn font() -> Option<FontRef<'static>> {
-    FontRef::new(INTER_SEMIBOLD).ok()
-}
-
-/// Vertical metrics at a pixel size: (ascent, descent), both positive.
-pub fn metrics(px: f32) -> (f32, f32) {
-    match font() {
-        Some(f) => {
-            let m = f.metrics(Size::new(px), LocationRef::default());
-            (m.ascent, -m.descent)
-        }
-        None => (px * 0.8, px * 0.2),
-    }
-}
-
-/// Horizontal advance of a character at a pixel size.
-pub fn advance(c: char, px: f32) -> f32 {
-    let Some(f) = font() else { return px * 0.5 };
-    let gid = f.charmap().map(c).or_else(|| f.charmap().map('?'));
-    gid.and_then(|g| f.glyph_metrics(Size::new(px), LocationRef::default()).advance_width(g)).unwrap_or(px * 0.5)
-}
-
-/// Width of a single line of text.
-pub fn measure(text: &str, px: f32) -> f32 {
-    text.chars().map(|c| advance(c, px)).sum()
-}
-
-struct Pen {
-    p: Path,
-}
-
-impl OutlinePen for Pen {
-    fn move_to(&mut self, x: f32, y: f32) {
-        self.p.move_to(x, -y);
-    }
-    fn line_to(&mut self, x: f32, y: f32) {
-        self.p.line_to(x, -y);
-    }
-    fn quad_to(&mut self, cx0: f32, cy0: f32, x: f32, y: f32) {
-        self.p.quad_to(cx0, -cy0, x, -y);
-    }
-    fn curve_to(&mut self, cx0: f32, cy0: f32, cx1: f32, cy1: f32, x: f32, y: f32) {
-        self.p.cubic_to(cx0, -cy0, cx1, -cy1, x, -y);
-    }
-    fn close(&mut self) {
-        self.p.close();
-    }
-}
-
-/// A rasterised glyph: coverage mask placed with its top-left at `(left, top)` relative to the
-/// pen position on the baseline.
-#[derive(Debug)]
-pub struct Glyph {
-    pub mask: Mask,
-    pub left: i32,
-    pub top: i32,
-}
-
-type Key = (char, u32, u8);
-
-fn cache() -> &'static Mutex<HashMap<Key, Option<Arc<Glyph>>>> {
-    static C: OnceLock<Mutex<HashMap<Key, Option<Arc<Glyph>>>>> = OnceLock::new();
-    C.get_or_init(Default::default)
-}
-
-/// Rasterise `c` at `px` with the pen at fractional x offset `frac` (0..1, quantised to ¼ px).
-pub fn glyph(c: char, px: f32, frac: f32) -> Option<Arc<Glyph>> {
-    let size_q = (px * 4.0).round().max(1.0) as u32;
-    let frac_q = ((frac.rem_euclid(1.0) * 4.0).round() as u8) % 4;
-    let key = (c, size_q, frac_q);
-    if let Some(g) = cache().lock().unwrap_or_else(|e| e.into_inner()).get(&key) {
-        return g.clone();
-    }
-    let g = render_glyph(c, size_q as f32 / 4.0, frac_q as f32 / 4.0).map(Arc::new);
-    let mut m = cache().lock().unwrap_or_else(|e| e.into_inner());
-    if m.len() > 8192 {
-        m.clear();
-    }
-    m.insert(key, g.clone());
-    g
-}
-
-fn render_glyph(c: char, px: f32, frac: f32) -> Option<Glyph> {
-    if c.is_whitespace() {
-        return None;
-    }
-    let f = font()?;
-    let gid = f.charmap().map(c).or_else(|| f.charmap().map('?'))?;
-    let outline = f.outline_glyphs().get(gid)?;
-    let mut pen = Pen { p: Path::default() };
-    outline.draw(DrawSettings::unhinted(Size::new(px), LocationRef::default()), &mut pen).ok()?;
-    pen.p.close();
-    let (x0, y0, x1, y1) = pen.p.bounds()?;
-    let left = (x0 + frac).floor() as i32;
-    let top = y0.floor() as i32;
-    let w = ((x1 + frac).ceil() as i32 - left).max(1) as usize;
-    let h = (y1.ceil() as i32 - top).max(1) as usize;
-    let mask = fill(&pen.p, w, h, frac - left as f32, -top as f32);
-    Some(Glyph { mask, left, top })
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn inter_loads_and_draws() {
-        let (a, d) = metrics(100.0);
-        assert!(a > 80.0 && a < 110.0, "ascent {a}");
-        assert!(d > 10.0 && d < 40.0, "descent {d}");
-        assert!(advance('W', 100.0) > advance('i', 100.0));
-        let g = glyph('H', 40.0, 0.0).unwrap();
-        // the H has two stems: the middle row has ink on both sides and a gap between them
-        let y = g.mask.h / 4;
-        let row: Vec<f32> = (0..g.mask.w).map(|x| g.mask.get(x, y)).collect();
-        assert!(row[1] > 0.9 && row[g.mask.w - 2] > 0.9, "{row:?}");
-        assert!(row[g.mask.w / 2] < 0.1, "{row:?}");
-        assert!(g.top < 0, "glyph rises above the baseline");
-        assert!(glyph(' ', 40.0, 0.0).is_none());
-        assert!(measure("Hello", 30.0) > 50.0);
-    }
-}
diff --git a/crates/captions/src/lib.rs b/crates/captions/src/lib.rs
index 4c8b24b74..d10c98d12 100644
--- a/crates/captions/src/lib.rs
+++ b/crates/captions/src/lib.rs
@@ -10,13 +10,11 @@
 //!   (drop-frame or not) convert exactly; [`Document::snap_to_frames`] snaps to a sequence's frames.
 //! - **Model:** [`track_from_document`] / [`document_from_track`] convert to and from the project's
 //!   [`CaptionTrack`].
-//! - **Burn-in:** [`burn`] lays a caption out with the track style and rasterises it with the
-//!   bundled Inter font (outlines via `skrifa`, coverage rasteriser in [`raster`]).
+//! - **Burn-in:** [`burn`] lays a caption out with the track style and draws it with the
+//!   `filmcraft-text` engine (Inter SemiBold, shaped and kerned).
 
 pub mod burn;
 pub mod cea608;
-pub mod font;
-pub mod raster;
 pub mod scc;
 pub mod srt;
 pub mod vtt;
diff --git a/crates/captions/src/raster.rs b/crates/captions/src/raster.rs
deleted file mode 100644
index ff8dcc383..000000000
--- a/crates/captions/src/raster.rs
+++ /dev/null
@@ -1,228 +0,0 @@
-//! A small anti-aliased path rasteriser for glyph outlines.
-//!
-//! Curves are flattened to line segments; each pixel row is sampled at [`SUB`] sub-scanlines, and
-//! on each sub-scanline the non-zero winding spans between edge crossings are accumulated with
-//! exact horizontal coverage at the span ends. Original implementation for FilmCraft.
-
-/// Vertical sub-samples per pixel row.
-pub const SUB: usize = 5;
-
-/// A flattened path: line segments `(x0, y0, x1, y1)` in pixel space, y down.
-#[derive(Clone, Debug, Default)]
-pub struct Path {
-    pub segs: Vec<[f32; 4]>,
-    start: (f32, f32),
-    cur: (f32, f32),
-    open: bool,
-}
-
-impl Path {
-    pub fn move_to(&mut self, x: f32, y: f32) {
-        self.close();
-        self.start = (x, y);
-        self.cur = (x, y);
-        self.open = true;
-    }
-    pub fn line_to(&mut self, x: f32, y: f32) {
-        if (x, y) != self.cur {
-            self.segs.push([self.cur.0, self.cur.1, x, y]);
-        }
-        self.cur = (x, y);
-    }
-    pub fn quad_to(&mut self, cx: f32, cy: f32, x: f32, y: f32) {
-        let (x0, y0) = self.cur;
-        let dd = ((x0 - 2.0 * cx + x).abs() + (y0 - 2.0 * cy + y).abs()).max(0.01);
-        let n = ((dd * 2.0).sqrt().ceil() as usize).clamp(1, 32);
-        for i in 1..=n {
-            let t = i as f32 / n as f32;
-            let u = 1.0 - t;
-            self.line_to(u * u * x0 + 2.0 * u * t * cx + t * t * x, u * u * y0 + 2.0 * u * t * cy + t * t * y);
-        }
-    }
-    pub fn cubic_to(&mut self, c1x: f32, c1y: f32, c2x: f32, c2y: f32, x: f32, y: f32) {
-        let (x0, y0) = self.cur;
-        let dd = (x0 - 2.0 * c1x + c2x).abs() + (y0 - 2.0 * c1y + c2y).abs() + (c1x - 2.0 * c2x + x).abs() + (c1y - 2.0 * c2y + y).abs();
-        let n = (((dd.max(0.01)) * 3.0).sqrt().ceil() as usize).clamp(1, 48);
-        for i in 1..=n {
-            let t = i as f32 / n as f32;
-            let u = 1.0 - t;
-            let (a, b, c, d) = (u * u * u, 3.0 * u * u * t, 3.0 * u * t * t, t * t * t);
-            self.line_to(a * x0 + b * c1x + c * c2x + d * x, a * y0 + b * c1y + c * c2y + d * y);
-        }
-    }
-    pub fn close(&mut self) {
-        if self.open && self.cur != self.start {
-            self.segs.push([self.cur.0, self.cur.1, self.start.0, self.start.1]);
-        }
-        self.cur = self.start;
-        self.open = false;
-    }
-    /// Bounding box `(x0, y0, x1, y1)` of all segments.
-    pub fn bounds(&self) -> Option<(f32, f32, f32, f32)> {
-        let mut it = self.segs.iter();
-        let f = it.next()?;
-        let mut b = (f[0].min(f[2]), f[1].min(f[3]), f[0].max(f[2]), f[1].max(f[3]));
-        for s in it {
-            b = (b.0.min(s[0]).min(s[2]), b.1.min(s[1]).min(s[3]), b.2.max(s[0]).max(s[2]), b.3.max(s[1]).max(s[3]));
-        }
-        Some(b)
-    }
-}
-
-/// Coverage mask (0..1), row-major.
-#[derive(Clone, Debug, PartialEq)]
-pub struct Mask {
-    pub w: usize,
-    pub h: usize,
-    pub a: Vec<f32>,
-}
-
-impl Mask {
-    pub fn new(w: usize, h: usize) -> Self {
-        Self { w, h, a: vec![0.0; w * h] }
-    }
-    pub fn get(&self, x: usize, y: usize) -> f32 {
-        self.a[y * self.w + x]
-    }
-}
-
-/// Fill `path` (non-zero winding) into a `w`×`h` mask, offsetting the path by `(dx, dy)`.
-pub fn fill(path: &Path, w: usize, h: usize, dx: f32, dy: f32) -> Mask {
-    let mut m = Mask::new(w, h);
-    if w == 0 || h == 0 {
-        return m;
-    }
-    // edges: (ytop, ybot, x at ytop, dx/dy, winding)
-    let mut edges: Vec<(f32, f32, f32, f32, i32)> = path
-        .segs
-        .iter()
-        .filter(|s| s[1] != s[3])
-        .map(|s| {
-            let (x0, y0, x1, y1) = (s[0] + dx, s[1] + dy, s[2] + dx, s[3] + dy);
-            let (dir, xa, ya, xb, yb) = if y0 < y1 { (1, x0, y0, x1, y1) } else { (-1, x1, y1, x0, y0) };
-            (ya, yb, xa, (xb - xa) / (yb - ya), dir)
-        })
-        .collect();
-    edges.sort_by(|a, b| a.0.total_cmp(&b.0));
-    let mut xs: Vec<(f32, i32)> = Vec::new();
-    let mut row = vec![0.0f32; w + 1];
-    let weight = 1.0 / SUB as f32;
-    for y in 0..h {
-        row.iter_mut().for_each(|v| *v = 0.0);
-        let mut any = false;
-        for k in 0..SUB {
-            let sy = y as f32 + (k as f32 + 0.5) / SUB as f32;
-            xs.clear();
-            for e in &edges {
-                if e.0 > sy {
-                    break; // sorted by top
-                }
-                if sy < e.1 {
-                    xs.push((e.2 + (sy - e.0) * e.3, e.4));
-                }
-            }
-            if xs.len() < 2 {
-                continue;
-            }
-            xs.sort_by(|a, b| a.0.total_cmp(&b.0));
-            let mut wind = 0;
-            let mut span_start = 0.0f32;
-            for &(x, d) in &xs {
-                let before = wind;
-                wind += d;
-                if before == 0 && wind != 0 {
-                    span_start = x;
-                } else if before != 0 && wind == 0 {
-                    add_span(&mut row, span_start, x, weight, w);
-                    any = true;
-                }
-            }
-        }
-        if any {
-            let out = &mut m.a[y * w..(y + 1) * w];
-            for (o, v) in out.iter_mut().zip(&row) {
-                *o = v.min(1.0);
-            }
-        }
-    }
-    m
-}
-
-/// Add coverage `weight` over `[x0, x1)` with fractional ends.
-fn add_span(row: &mut [f32], x0: f32, x1: f32, weight: f32, w: usize) {
-    let x0 = x0.clamp(0.0, w as f32);
-    let x1 = x1.clamp(0.0, w as f32);
-    if x1 <= x0 {
-        return;
-    }
-    let i0 = x0.floor() as usize;
-    let i1 = x1.floor() as usize;
-    if i0 == i1 {
-        row[i0] += (x1 - x0) * weight;
-        return;
-    }
-    row[i0] += (i0 as f32 + 1.0 - x0) * weight;
-    for v in &mut row[i0 + 1..i1] {
-        *v += weight;
-    }
-    if i1 < w {
-        row[i1] += (x1 - i1 as f32) * weight;
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn rect(x0: f32, y0: f32, x1: f32, y1: f32) -> Path {
-        let mut p = Path::default();
-        p.move_to(x0, y0);
-        p.line_to(x1, y0);
-        p.line_to(x1, y1);
-        p.line_to(x0, y1);
-        p.close();
-        p
-    }
-
-    #[test]
-    fn rectangle_coverage() {
-        let m = fill(&rect(1.5, 2.0, 4.0, 5.0), 6, 6, 0.0, 0.0);
-        assert!((m.get(1, 3) - 0.5).abs() < 1e-5);
-        assert!((m.get(2, 3) - 1.0).abs() < 1e-5);
-        assert_eq!(m.get(4, 3), 0.0);
-        assert_eq!(m.get(2, 1), 0.0);
-        assert_eq!(m.get(2, 5), 0.0);
-        let total: f32 = m.a.iter().sum();
-        assert!((total - 2.5 * 3.0).abs() < 1e-3, "{total}");
-    }
-
-    #[test]
-    fn hole_with_opposite_winding() {
-        let mut p = rect(0.0, 0.0, 10.0, 10.0);
-        // inner square wound the other way
-        p.move_to(3.0, 3.0);
-        p.line_to(3.0, 7.0);
-        p.line_to(7.0, 7.0);
-        p.line_to(7.0, 3.0);
-        p.close();
-        let m = fill(&p, 10, 10, 0.0, 0.0);
-        assert_eq!(m.get(5, 5), 0.0);
-        assert!((m.get(1, 5) - 1.0).abs() < 1e-5);
-    }
-
-    #[test]
-    fn circle_area() {
-        let mut p = Path::default();
-        let (cx, cy, r) = (10.0f32, 10.0f32, 6.0f32);
-        p.move_to(cx + r, cy);
-        for i in 1..=64 {
-            let a = i as f32 / 64.0 * std::f32::consts::TAU;
-            p.line_to(cx + r * a.cos(), cy + r * a.sin());
-        }
-        p.close();
-        let m = fill(&p, 20, 20, 0.0, 0.0);
-        let total: f32 = m.a.iter().sum();
-        let want = std::f32::consts::PI * r * r;
-        assert!((total - want).abs() / want < 0.02, "{total} vs {want}");
-    }
-}
diff --git a/crates/codecs/Cargo.toml b/crates/codecs/Cargo.toml
index ee250a8c5..843bd4f1a 100644
--- a/crates/codecs/Cargo.toml
+++ b/crates/codecs/Cargo.toml
@@ -19,6 +19,7 @@ filmcraft-matroska = { workspace = true }
 filmcraft-bitstream = { workspace = true }
 filmcraft-h264 = { workspace = true }
 filmcraft-hevc = { workspace = true }
+filmcraft-vp9 = { workspace = true }
 filmcraft-prores = { workspace = true }
 filmcraft-aac = { workspace = true }
 filmcraft-opus = { workspace = true }
diff --git a/crates/codecs/src/gop.rs b/crates/codecs/src/gop.rs
index 16c6ef59f..34a603882 100644
--- a/crates/codecs/src/gop.rs
+++ b/crates/codecs/src/gop.rs
@@ -180,7 +180,7 @@ impl GopCache {
         if st.intra {
             return self.intra_frame(st, s, i, want_pts);
         }
-        let key = s.sync_before(i);
+        let mut key = s.sync_before(i);
         // Continue the running decoder when it has passed the wanted sample's sync sample and
         // either has not reached the sample yet or has been fed it without outputting it yet
         // (a frame-threaded decoder holds many pictures in flight). Otherwise the frame was
@@ -192,6 +192,15 @@ impl GopCache {
         let continuing = running && (st.next > key || near) && (i >= st.next || (st.start <= i && want_pts > st.out_max));
         if !continuing {
             SEEKS.fetch_add(1, Ordering::Relaxed);
+            // The container's sync flags may be wrong for the codec (an MP4 without `stss` marks
+            // every sample): step back to a sample the decoder can start from.
+            while key > 0 {
+                let data = s.read(key)?;
+                if st.decoder.as_ref().expect("decoder").is_random_access(&data) != Some(false) {
+                    break;
+                }
+                key = s.sync_before(key - 1);
+            }
             if let Some(d) = st.decoder.as_mut() {
                 d.reset();
             }
diff --git a/crates/codecs/src/lib.rs b/crates/codecs/src/lib.rs
index 9dd95d64c..7a1baad0d 100644
--- a/crates/codecs/src/lib.rs
+++ b/crates/codecs/src/lib.rs
@@ -1,6 +1,6 @@
 //! The container + codec hub.
 //!
-//! - [`VideoDecoder`]: the trait every video codec implements (our own H.264/ProRes/…, MJPEG, and
+//! - [`VideoDecoder`]: the trait every video codec implements (our own H.264/HEVC/VP9/ProRes/…, MJPEG, and
 //!   OS hardware decoders registered by the platform layer). Factories are tried in registration
 //!   order, so a hardware decoder can take precedence over the pure-Rust one.
 //! - [`Mp4Source`]: a [`MediaSource`](filmcraft_media::MediaSource) over MP4/MOV using
@@ -51,7 +51,7 @@ impl From<CodecError> for filmcraft_media::MediaError {
 
 fn factories() -> &'static RwLock<Vec<VideoDecoderFactory>> {
     static F: std::sync::OnceLock<RwLock<Vec<VideoDecoderFactory>>> = std::sync::OnceLock::new();
-    F.get_or_init(|| RwLock::new(vec![video::h264_factory, video::hevc_factory, video::prores_factory, video::mjpeg_factory]))
+    F.get_or_init(|| RwLock::new(vec![video::h264_factory, video::hevc_factory, video::vp9_factory, video::prores_factory, video::mjpeg_factory]))
 }
 
 /// Register a video decoder factory (tried before previously registered ones).
diff --git a/crates/codecs/src/mkv.rs b/crates/codecs/src/mkv.rs
index e5134fd95..b6c56a395 100644
--- a/crates/codecs/src/mkv.rs
+++ b/crates/codecs/src/mkv.rs
@@ -1,7 +1,7 @@
 //! Matroska/WebM media source (`filmcraft-matroska` demux, GOP-aware video via [`crate::gop`]).
 //!
 //! Video codecs are mapped onto ISO-BMFF sample entries so the same decoder factories serve both
-//! containers (H.264, HEVC, ProRes, MJPEG; VP9/AV1 once their decoders land). Audio: AAC and Opus
+//! containers (H.264, HEVC, VP9, ProRes, MJPEG; AV1 once its decoder lands). Audio: AAC and Opus
 //! via our decoders, PCM directly, MP3/FLAC/Vorbis via the bootstrap decoders.
 //!
 //! Opus (`A_OPUS`): `CodecPrivate` is the `OpusHead`; output is always 48 kHz. The demuxer
@@ -14,7 +14,7 @@ use std::sync::{Arc, Mutex};
 
 use filmcraft_color::{ColorInfo, Matrix, Primaries, Range, Transfer};
 use filmcraft_frame::{AudioBuffer, VideoFrame};
-use filmcraft_isobmff::{AvcConfig, FourCc, HevcConfig, PcmConfig, SampleEntry};
+use filmcraft_isobmff::{AvcConfig, CodecConfig, FourCc, HevcConfig, PcmConfig, SampleEntry, VpcConfig};
 use filmcraft_matroska::{Codec, MkvFile, TrackKind};
 use filmcraft_media::{AudioStreamInfo, FrameRequest, MediaError, MediaInfo, MediaKind, MediaSource, SharedSource, VideoStreamInfo};
 use filmcraft_time::{FrameRate, Tick};
@@ -105,8 +105,42 @@ fn from_tick(t: &filmcraft_matroska::Track, time: Tick) -> i64 {
     time.to_rational_floor(n, d)
 }
 
-fn sample_entry(c: &Codec, w: u16, h: u16) -> Option<SampleEntry> {
+/// VP9 configuration from the Matroska `CodecPrivate` feature list (ID / length / value triples:
+/// 1 profile, 2 level, 3 bit depth, 4 chroma subsampling) and the track's `Colour`.
+fn vp9_config(private: &[u8], v: Option<&filmcraft_matroska::VideoInfo>) -> VpcConfig {
+    let mut c = VpcConfig { bit_depth: 8, colour_primaries: 2, transfer_characteristics: 2, matrix_coefficients: 2, ..Default::default() };
+    let mut p = 0;
+    while p + 2 <= private.len() {
+        let (id, len) = (private[p], private[p + 1] as usize);
+        let Some(val) = private.get(p + 2..p + 2 + len) else { break };
+        let x = val.first().copied().unwrap_or(0);
+        match id {
+            1 => c.profile = x,
+            2 => c.level = x,
+            3 => c.bit_depth = x,
+            4 => c.chroma_subsampling = x,
+            _ => {}
+        }
+        p += 2 + len;
+    }
+    if let Some(col) = v.and_then(|v| v.colour.as_ref()) {
+        if let Some(t) = col.transfer_characteristics {
+            c.transfer_characteristics = t as u8;
+        }
+        if let Some(pr) = col.primaries {
+            c.colour_primaries = pr as u8;
+        }
+        if let Some(m) = col.matrix_coefficients {
+            c.matrix_coefficients = m as u8;
+        }
+        c.full_range = col.full_range();
+    }
+    c
+}
+
+fn sample_entry(c: &Codec, v: Option<&filmcraft_matroska::VideoInfo>, w: u16, h: u16) -> Option<SampleEntry> {
     Some(match c {
+        Codec::Vp9 { private } => SampleEntry::video(FourCc(*b"vp09"), CodecConfig::Vp9(vp9_config(private, v)), w, h),
         Codec::Avc { avcc } => SampleEntry::avc(AvcConfig::parse(avcc).ok()?, w, h),
         Codec::Hevc { hvcc } => SampleEntry::hevc(HevcConfig::parse(hvcc).ok()?, w, h),
         Codec::ProRes { fourcc } => SampleEntry::prores(FourCc(fourcc.unwrap_or(*b"apcn")), w, h),
@@ -190,7 +224,7 @@ impl MkvSource {
             if explicit {
                 explicit_color = Some(color);
             }
-            ventry = sample_entry(&t.codec, w as u16, h as u16);
+            ventry = sample_entry(&t.codec, t.video.as_ref(), w as u16, h as u16);
             let secs = file.duration_ns().unwrap_or(0) as f64 / 1e9;
             let bitrate = (secs > 0.0).then(|| (t.samples.iter().map(|s| s.size as u64).sum::<u64>() as f64 * 8.0 / secs) as u64);
             VideoStreamInfo {
diff --git a/crates/codecs/src/mp4.rs b/crates/codecs/src/mp4.rs
index 3cc08b874..8d8f46097 100644
--- a/crates/codecs/src/mp4.rs
+++ b/crates/codecs/src/mp4.rs
@@ -48,9 +48,17 @@ pub fn sniff(b: &[u8]) -> bool {
 
 fn color_from(entry: &filmcraft_isobmff::SampleEntry, w: u32, h: u32) -> ColorInfo {
     let mut c = ColorInfo { matrix: filmcraft_frame::default_matrix(w, h), transfer: Transfer::Bt709, primaries: Primaries::Bt709, range: Range::Limited };
-    if let Some(v) = &entry.video
-        && let Some(col) = &v.color
-    {
+    // VP9 carries its colour description in vpcC (used when there is no colr box).
+    let vpc = match &entry.codec {
+        CodecConfig::Vp9(v) => Some(filmcraft_isobmff::ColorInfo::Nclx {
+            primaries: v.colour_primaries as u16,
+            transfer: v.transfer_characteristics as u16,
+            matrix: v.matrix_coefficients as u16,
+            full_range: v.full_range,
+        }),
+        _ => None,
+    };
+    if let Some(col) = entry.video.as_ref().and_then(|v| v.color.as_ref()).or(vpc.as_ref()) {
         let (p, t, m, full) = match col {
             filmcraft_isobmff::ColorInfo::Nclx { primaries, transfer, matrix, full_range } => (*primaries, *transfer, *matrix, *full_range),
             filmcraft_isobmff::ColorInfo::Nclc { primaries, transfer, matrix } => (*primaries, *transfer, *matrix, false),
@@ -369,6 +377,7 @@ fn codec_label(c: &CodecConfig) -> String {
             }
         ),
         CodecConfig::Hevc(_) => "HEVC".into(),
+        CodecConfig::Vp9(c) => format!("VP9 (Profile {})", c.profile),
         CodecConfig::ProRes { fourcc } => match &fourcc.0 {
             b"apco" => "Apple ProRes 422 Proxy".into(),
             b"apcs" => "Apple ProRes 422 LT".into(),
@@ -399,6 +408,14 @@ fn pixfmt_label(c: &CodecConfig) -> String {
             244 => "YUV 4:4:4".into(),
             _ => "YUV 4:2:0 8-bit".into(),
         },
+        CodecConfig::Vp9(c) => {
+            let sub = match c.chroma_subsampling {
+                2 => "4:2:2",
+                3 => "4:4:4",
+                _ => "4:2:0",
+            };
+            format!("YUV {sub} {}-bit", c.bit_depth.max(8))
+        }
         CodecConfig::ProRes { fourcc } if fourcc.0[2] == b'4' => "YUVA 4:4:4 12-bit".into(),
         CodecConfig::ProRes { .. } => "YUV 4:2:2 10-bit".into(),
         CodecConfig::Jpeg { .. } => "YUV 4:2:x 8-bit".into(),
diff --git a/crates/codecs/src/tests.rs b/crates/codecs/src/tests.rs
index 601f2048b..fc35862aa 100644
--- a/crates/codecs/src/tests.rs
+++ b/crates/codecs/src/tests.rs
@@ -179,6 +179,169 @@ fn matroska_prores_pcm() {
     check_mkv("blue_prores_pcm.mkv", &["-c:v", "prores_ks", "-profile:v", "2"], &["-c:a", "pcm_s16le"]);
 }
 
+/// Path of a fixture under `target/fixtures/codecs/`, generated with ffmpeg when missing
+/// (`None` when ffmpeg or the encoder is unavailable).
+fn fixture_path(name: &str, args: &[&str]) -> Option<PathBuf> {
+    fixture(name, args)?;
+    Some(PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../target/fixtures/codecs").join(name))
+}
+
+/// ffmpeg's decode of `src` as raw planar video (the oracle).
+fn reference_yuv(src: &std::path::Path, pix_fmt: &str) -> Option<Vec<u8>> {
+    let name = format!("{}.{pix_fmt}.yuv", src.file_name()?.to_str()?);
+    let path = src.to_str()?;
+    let b = fixture(&name, &["-i", path, "-fps_mode", "passthrough", "-f", "rawvideo", "-pix_fmt", pix_fmt])?;
+    Some(b.to_vec())
+}
+
+/// Planes of a decoded YUV frame as little-endian bytes (ffmpeg rawvideo layout).
+fn yuv_bytes(f: &filmcraft_frame::VideoFrame) -> Vec<u8> {
+    match &f.data {
+        filmcraft_frame::PixelData::Yuv8 { planes, .. } => planes.iter().flat_map(|p| p.iter().copied()).collect(),
+        filmcraft_frame::PixelData::Yuv16 { planes, .. } => planes.iter().flat_map(|p| p.iter().flat_map(|s| s.to_le_bytes())).collect(),
+        _ => panic!("not a YUV frame: {}", f.format_label()),
+    }
+}
+
+/// Random access into a VP9 file: frames requested out of order (seeks back and forth across key
+/// frames, then sequential playback) are sample-exact against ffmpeg's decode.
+fn check_vp9_seeks(name: &str, container: &str, pix_fmt: &str, extra: &[&str], frames: usize) {
+    let dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../target/fixtures/codecs");
+    let log = dir.join(format!("{name}.passlog")).to_string_lossy().into_owned();
+    let mut args = vec!["-f", "lavfi", "-i", "testsrc2=s=352x288:r=25,noise=alls=8:allf=t", "-frames:v"];
+    let n = frames.to_string();
+    args.push(&n);
+    args.extend_from_slice(&["-c:v", "libvpx-vp9", "-pix_fmt", pix_fmt, "-g", "25", "-b:v", "600k"]);
+    args.extend_from_slice(extra);
+    if extra.contains(&"-auto-alt-ref") {
+        // libvpx only uses alternate reference frames in two-pass mode: run the first pass.
+        let Some(ff) = ffmpeg() else { return };
+        if !dir.join(name).exists() {
+            let _ = std::fs::create_dir_all(&dir);
+            let ok = Command::new(ff).args(["-y", "-v", "error"]).args(&args).args(["-pass", "1", "-passlogfile"]).arg(&log).args(["-f", "null", "-"]).status();
+            if !ok.is_ok_and(|s| s.success()) {
+                eprintln!("first pass for {name} failed; skipping");
+                return;
+            }
+        }
+        args.extend_from_slice(&["-pass", "2", "-passlogfile"]);
+        args.push(&log);
+    }
+    let Some(path) = fixture_path(name, &args) else { return };
+    let Some(reference) = reference_yuv(&path, pix_fmt) else { return };
+    let bytes: Arc<[u8]> = std::fs::read(&path).unwrap().into();
+    let src = crate::open_bytes(name, bytes).unwrap();
+    let info = src.info().clone();
+    assert_eq!(info.container, container);
+    let v = info.video.as_ref().unwrap();
+    assert!(v.codec.contains("VP9"), "{}", v.codec);
+    assert_eq!((v.width, v.height), (352, 288));
+    let frame_len = reference.len() / frames;
+    let rate = info.frame_rate();
+    let order: Vec<usize> = [frames - 3, 3, 40, 26, 24, frames - 1, 0, 12].into_iter().chain(30..45).filter(|&k| k < frames).collect();
+    for k in order {
+        let f = src.video_frame(FrameRequest::full(rate.tick_of(k as i64))).unwrap();
+        assert_eq!((f.width, f.height), (352, 288));
+        let got = yuv_bytes(&f);
+        assert!(got == reference[k * frame_len..(k + 1) * frame_len], "{name}: frame {k} differs from ffmpeg");
+    }
+}
+
+#[test]
+fn webm_vp9_seeks_bit_exact() {
+    check_vp9_seeks("noise_vp9.webm", "WebM", "yuv420p", &["-deadline", "realtime", "-speed", "8"], 60);
+}
+
+#[test]
+fn webm_vp9_altref_superframes_seek_bit_exact() {
+    // Good-quality encode with alternate reference frames: hidden frames packed into superframes.
+    check_vp9_seeks("noise_vp9_altref.webm", "WebM", "yuv420p", &["-speed", "4", "-auto-alt-ref", "1", "-lag-in-frames", "16"], 60);
+}
+
+#[test]
+fn mp4_vp9_10bit_seeks_bit_exact() {
+    check_vp9_seeks("noise_vp9_10bit.mp4", "MPEG-4", "yuv420p10le", &["-profile:v", "2", "-deadline", "realtime", "-speed", "8"], 50);
+}
+
+#[test]
+fn mkv_vp9_444_12bit_seeks_bit_exact() {
+    check_vp9_seeks("noise_vp9_444_12bit.mkv", "Matroska", "yuv444p12le", &["-profile:v", "3", "-deadline", "realtime", "-speed", "8"], 30);
+}
+
+#[test]
+fn mkv_vp9_422_seeks_bit_exact() {
+    check_vp9_seeks("noise_vp9_422.mkv", "Matroska", "yuv422p", &["-profile:v", "1", "-deadline", "realtime", "-speed", "8"], 30);
+}
+
+/// Every sample flagged as sync (as in an MP4 without `stss`): the GOP cache must still start
+/// decoding at a real VP9 key frame.
+#[test]
+fn vp9_random_access_ignores_bogus_sync_flags() {
+    use crate::gop::{GopCache, VideoSamples};
+    let Some(path) = fixture_path(
+        "noise_vp9_g20.ivf",
+        &["-f", "lavfi", "-i", "testsrc2=s=176x144:r=25", "-frames:v", "50", "-c:v", "libvpx-vp9", "-g", "20", "-deadline", "realtime", "-speed", "8"],
+    ) else {
+        return;
+    };
+    let Some(reference) = reference_yuv(&path, "yuv420p") else { return };
+    let data = std::fs::read(&path).unwrap();
+    let mut chunks = Vec::new();
+    let mut p = 32;
+    while p + 12 <= data.len() {
+        let sz = u32::from_le_bytes(data[p..p + 4].try_into().unwrap()) as usize;
+        chunks.push(data[p + 12..p + 12 + sz].to_vec());
+        p += 12 + sz;
+    }
+    struct AllSync(Vec<Vec<u8>>);
+    impl VideoSamples for AllSync {
+        fn count(&self) -> usize {
+            self.0.len()
+        }
+        fn pts(&self, i: usize) -> i64 {
+            i as i64
+        }
+        fn sync_before(&self, i: usize) -> usize {
+            i
+        }
+        fn sample_at(&self, t: i64) -> Option<usize> {
+            (t >= 0 && (t as usize) < self.0.len()).then_some(t as usize)
+        }
+        fn read(&self, i: usize) -> crate::Result<Vec<u8>> {
+            Ok(self.0[i].clone())
+        }
+        fn make_decoder(&self) -> crate::Result<Box<dyn crate::VideoDecoder>> {
+            Ok(Box::new(crate::video::Vp9Decoder::new(None)))
+        }
+    }
+    let s = AllSync(chunks);
+    let cache = GopCache::new(None);
+    let frame_len = 176 * 144 * 3 / 2;
+    for k in [37usize, 5, 49, 21, 20, 19] {
+        let f = cache.frame(&s, k as i64).unwrap();
+        assert!(yuv_bytes(&f) == reference[k * frame_len..(k + 1) * frame_len], "frame {k} differs from ffmpeg");
+    }
+}
+
+/// VP9 RGB (profile 1, colour space sRGB; planes G, B, R) decodes to RGBA in the right order.
+#[test]
+fn mkv_vp9_rgb() {
+    let Some(b) = fixture(
+        "orange_vp9_gbrp.mkv",
+        &["-f", "lavfi", "-i", "color=c=0xe08020:s=128x96:r=25:d=0.4", "-c:v", "libvpx-vp9", "-pix_fmt", "gbrp", "-deadline", "realtime", "-lossless", "1"],
+    ) else {
+        return;
+    };
+    let src = crate::open_bytes("orange_vp9_gbrp.mkv", b).unwrap();
+    let f = src.video_frame(FrameRequest::full(Tick(TICKS_PER_SECOND / 5))).unwrap();
+    let px = f.to_rgba8();
+    let c = &px[(48 * 128 + 64) * 4..][..3];
+    // (the lavfi colour source is converted to RGB by ffmpeg, which rounds by a level)
+    for (got, want) in c.iter().zip([0xe0u8, 0x80, 0x20]) {
+        assert!((*got as i32 - want as i32).abs() <= 2, "{c:?}");
+    }
+}
+
 /// ffmpeg + libopus decode of a container fixture (pre-skip / codec delay / edit list applied) as
 /// interleaved f32 at 48 kHz: the reference for our Opus path.
 fn opus_reference(name: &str) -> Option<Vec<f32>> {
diff --git a/crates/codecs/src/video.rs b/crates/codecs/src/video.rs
index 16d1ad38f..9542951d1 100644
--- a/crates/codecs/src/video.rs
+++ b/crates/codecs/src/video.rs
@@ -25,6 +25,12 @@ pub trait VideoDecoder: Send {
     fn intra_only(&self) -> bool {
         false
     }
+    /// Whether decoding can start at `sample` (`None`: unknown, trust the container's sync flags).
+    /// Containers may flag samples as sync that the codec cannot start from (an MP4 without
+    /// `stss` marks every sample), so codecs that can tell say so.
+    fn is_random_access(&self, _sample: &[u8]) -> Option<bool> {
+        None
+    }
 }
 
 /// A factory returns `None` when it does not handle the entry.
@@ -220,6 +226,141 @@ pub fn hevc_factory(e: &SampleEntry) -> Option<Result<Box<dyn VideoDecoder>>> {
     }
 }
 
+/// Our pure-Rust VP9 decoder (profiles 0-3, 8/10/12-bit; tile columns and loop filter decode in
+/// parallel).
+pub struct Vp9Decoder {
+    dec: filmcraft_vp9::Decoder,
+    /// Container colour (vpcC / Matroska `Colour`): transfer and primaries are not in the VP9
+    /// bitstream.
+    transfer: Option<filmcraft_color::Transfer>,
+    primaries: Option<filmcraft_color::Primaries>,
+}
+
+/// Colour primaries from an ISO/IEC 23091-2 code.
+pub(crate) fn primaries_from_code(c: u8) -> Option<filmcraft_color::Primaries> {
+    use filmcraft_color::Primaries;
+    match c {
+        1 => Some(Primaries::Bt709),
+        5 => Some(Primaries::Bt601_625),
+        6 => Some(Primaries::Bt601_525),
+        9 => Some(Primaries::Bt2020),
+        12 => Some(Primaries::P3D65),
+        _ => None,
+    }
+}
+
+impl Vp9Decoder {
+    pub fn new(cfg: Option<&filmcraft_isobmff::VpcConfig>) -> Self {
+        Self {
+            dec: filmcraft_vp9::Decoder::new(),
+            transfer: cfg.and_then(|c| filmcraft_color::Transfer::from_code(c.transfer_characteristics)),
+            primaries: cfg.and_then(|c| primaries_from_code(c.colour_primaries)),
+        }
+    }
+
+    fn convert(&self, p: filmcraft_vp9::Picture) -> DecodedFrame {
+        use filmcraft_color::{Matrix, Primaries, Range};
+        use filmcraft_frame::{Chroma, PixelData};
+        use filmcraft_vp9::Plane;
+        use std::sync::Arc;
+        let (w, h) = (p.width as usize, p.height as usize);
+        let (cw, ch) = (p.chroma_width as usize, p.chroma_height as usize);
+        let mut color = filmcraft_color::ColorInfo { matrix: filmcraft_frame::default_matrix(p.width, p.height), ..filmcraft_color::ColorInfo::REC709 };
+        // color_space (7.2.2): 1 BT.601, 2 BT.709, 3 SMPTE-170, 4 SMPTE-240, 5 BT.2020, 7 sRGB.
+        match p.color.color_space {
+            1 | 3 => color.matrix = Matrix::Bt601,
+            2 | 4 => color.matrix = Matrix::Bt709,
+            5 => {
+                color.matrix = Matrix::Bt2020Ncl;
+                color.primaries = Primaries::Bt2020;
+            }
+            _ => {}
+        }
+        if let Some(t) = self.transfer {
+            color.transfer = t;
+        }
+        if let Some(pr) = self.primaries {
+            color.primaries = pr;
+        }
+        if p.color.full_range {
+            color.range = Range::Full;
+        }
+        let pts = p.pts;
+        if p.color.color_space == 7 {
+            // RGB (profiles 1 / 3, 4:4:4): the planes carry G, B, R.
+            let shift = p.bit_depth - 8;
+            let mut rgba = Vec::with_capacity(w * h * 4);
+            for i in 0..w * h {
+                rgba.extend_from_slice(&[(p.v.get(i) >> shift) as u8, (p.y.get(i) >> shift) as u8, (p.u.get(i) >> shift) as u8, 255]);
+            }
+            let mut frame = VideoFrame::rgba8(p.width, p.height, rgba);
+            frame.color = filmcraft_color::ColorInfo { range: Range::Full, transfer: filmcraft_color::Transfer::Srgb, ..color };
+            return DecodedFrame { pts, frame };
+        }
+        // 4:4:0 has no frame format of its own: chroma rows are repeated to 4:4:4.
+        let (chroma, rows_440) = match (p.subsampling_x, p.subsampling_y) {
+            (true, true) => (Chroma::C420, false),
+            (true, false) => (Chroma::C422, false),
+            (false, false) => (Chroma::C444, false),
+            (false, true) => (Chroma::C444, true),
+        };
+        fn expand<T: Copy>(v: &[T], cw: usize, ch: usize, h: usize, rows_440: bool) -> Vec<T> {
+            if !rows_440 {
+                return v[..cw * ch].to_vec();
+            }
+            let mut out = Vec::with_capacity(cw * h);
+            for y in 0..h {
+                out.extend_from_slice(&v[(y >> 1) * cw..(y >> 1) * cw + cw]);
+            }
+            out
+        }
+        let data = match (&p.y, &p.u, &p.v) {
+            (Plane::U8(y), Plane::U8(u), Plane::U8(v)) => PixelData::Yuv8 {
+                planes: [Arc::new(y[..w * h].to_vec()), Arc::new(expand(u, cw, ch, h, rows_440)), Arc::new(expand(v, cw, ch, h, rows_440))],
+                chroma,
+                alpha: None,
+            },
+            (Plane::U16(y), Plane::U16(u), Plane::U16(v)) => PixelData::Yuv16 {
+                planes: [Arc::new(y[..w * h].to_vec()), Arc::new(expand(u, cw, ch, h, rows_440)), Arc::new(expand(v, cw, ch, h, rows_440))],
+                chroma,
+                bits: p.bit_depth,
+                alpha: None,
+            },
+            _ => unreachable!("VP9 planes share one sample type"),
+        };
+        // render_size (the intended display size) is not applied: the container's display
+        // dimensions / pixel aspect describe the presentation.
+        let par = (1, 1);
+        DecodedFrame { pts, frame: VideoFrame { width: p.width, height: p.height, data, color, par, pts: filmcraft_time::Tick::ZERO } }
+    }
+}
+
+impl VideoDecoder for Vp9Decoder {
+    fn decode(&mut self, sample: &[u8], pts: i64) -> Result<Vec<DecodedFrame>> {
+        let pics = self.dec.decode(sample, pts).map_err(|e| CodecError::Decode(e.to_string()))?;
+        Ok(pics.into_iter().map(|p| self.convert(p)).collect())
+    }
+    fn flush(&mut self) -> Vec<DecodedFrame> {
+        self.dec.flush().into_iter().map(|p| self.convert(p)).collect()
+    }
+    fn reset(&mut self) {
+        self.dec.reset();
+    }
+    fn name(&self) -> &str {
+        "FilmCraft VP9"
+    }
+    fn is_random_access(&self, sample: &[u8]) -> Option<bool> {
+        Some(filmcraft_vp9::is_keyframe(sample))
+    }
+}
+
+pub fn vp9_factory(e: &SampleEntry) -> Option<Result<Box<dyn VideoDecoder>>> {
+    match &e.codec {
+        CodecConfig::Vp9(c) => Some(Ok(Box::new(Vp9Decoder::new(Some(c))) as Box<dyn VideoDecoder>)),
+        _ => None,
+    }
+}
+
 /// Our ProRes decoder (every frame is intra; slices decode in parallel).
 pub struct ProResDecoder;
 
diff --git a/crates/engine/Cargo.toml b/crates/engine/Cargo.toml
index b8fb90c7d..287c1a325 100644
--- a/crates/engine/Cargo.toml
+++ b/crates/engine/Cargo.toml
@@ -19,6 +19,7 @@ filmcraft-codecs = { workspace = true }
 filmcraft-project = { workspace = true }
 filmcraft-edit = { workspace = true }
 filmcraft-render = { workspace = true }
+filmcraft-text = { workspace = true }
 filmcraft-export = { workspace = true }
 filmcraft-format = { workspace = true }
 filmcraft-interchange = { workspace = true }
diff --git a/crates/engine/src/autosave.rs b/crates/engine/src/autosave.rs
index 436841ab7..e66b7c2d6 100644
--- a/crates/engine/src/autosave.rs
+++ b/crates/engine/src/autosave.rs
@@ -63,15 +63,98 @@ impl AutoSavePrefs {
     }
 }
 
+/// Preferences ▸ Playback (the parts trim-mode loop playback uses).
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase", default)]
+pub struct PlaybackPrefs {
+    /// "Preroll: N seconds" (Play Around, trim-mode loop playback).
+    pub preroll_seconds: f64,
+    /// "Postroll: N seconds".
+    pub postroll_seconds: f64,
+}
+
+impl Default for PlaybackPrefs {
+    fn default() -> Self {
+        Self { preroll_seconds: 3.0, postroll_seconds: 2.0 }
+    }
+}
+
+/// Preferences ▸ Trim.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase", default)]
+pub struct TrimPrefs {
+    /// "Large Trim Offset: N frames" (Trim Forward/Backward Many, the Trim Monitor's ±N buttons).
+    pub large_trim_offset: u32,
+    /// "Playhead position determines trim monitor loop playback" (else the edit point does).
+    pub playhead_determines_loop: bool,
+}
+
+impl Default for TrimPrefs {
+    fn default() -> Self {
+        Self { large_trim_offset: 5, playhead_determines_loop: false }
+    }
+}
+
 /// User preferences (persisted as JSON in the per-user data directory). Keys are dotted camelCase
-/// paths: `autoSave.enabled`, `autoSave.intervalMinutes`, …
+/// paths: `autoSave.enabled`, `autoSave.intervalMinutes`, `playback.prerollSeconds`, …
 #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase", default)]
 pub struct Preferences {
     pub auto_save: AutoSavePrefs,
+    pub audio: AudioPrefs,
+    pub playback: PlaybackPrefs,
+    pub trim: TrimPrefs,
+}
+
+/// Preferences ▸ Audio (the mixer-automation part) and the Track Mixer panel-menu toggle.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase", default)]
+pub struct AudioPrefs {
+    /// "Automatch Time" (s): how long Touch takes to return to the existing automation.
+    pub automatch_time: f64,
+    /// "Large Volume Adjustment" (dB) for the Increase/Decrease Clip Volume Many commands.
+    pub large_volume_adjustment: f64,
+    /// Automation Keyframe Optimization: "Linear keyframe thinning".
+    pub linear_keyframe_thinning: bool,
+    /// "Minimum time interval thinning".
+    pub minimum_time_interval_thinning: bool,
+    /// "Minimum time" (ms).
+    pub minimum_time_ms: u32,
+    /// Track Mixer ▸ "Switch to Touch after Write".
+    pub switch_to_touch_after_write: bool,
+}
+
+impl Default for AudioPrefs {
+    fn default() -> Self {
+        Self {
+            automatch_time: 1.0,
+            large_volume_adjustment: 6.0,
+            linear_keyframe_thinning: true,
+            minimum_time_interval_thinning: false,
+            minimum_time_ms: 20,
+            switch_to_touch_after_write: true,
+        }
+    }
+}
+
+impl AudioPrefs {
+    fn clamp(&mut self) {
+        self.automatch_time = if self.automatch_time.is_finite() { self.automatch_time.clamp(0.0, 30.0) } else { 1.0 };
+        self.large_volume_adjustment = if self.large_volume_adjustment.is_finite() { self.large_volume_adjustment.clamp(0.0, 96.0) } else { 6.0 };
+        self.minimum_time_ms = self.minimum_time_ms.clamp(1, 10_000);
+    }
 }
 
 impl Preferences {
+    fn clamp(&mut self) {
+        self.auto_save.clamp();
+        self.audio.clamp();
+        let secs = |v: f64| if v.is_finite() { v.clamp(0.0, 60.0) } else { 0.0 };
+        self.playback.preroll_seconds = secs(self.playback.preroll_seconds);
+        self.playback.postroll_seconds = secs(self.playback.postroll_seconds);
+        self.trim.large_trim_offset = self.trim.large_trim_offset.clamp(1, 1000);
+    }
+
     pub fn to_value(&self) -> Value {
         serde_json::to_value(self).unwrap_or_default()
     }
@@ -117,14 +200,14 @@ impl Preferences {
         };
         *slot = value;
         let mut p: Preferences = serde_json::from_value(v).map_err(|e| format!("`{key}`: {e}"))?;
-        p.auto_save.clamp();
+        p.clamp();
         *self = p;
         Ok(())
     }
 
     pub fn load(path: &Path) -> Self {
         let mut p: Preferences = fs::read(path).ok().and_then(|b| serde_json::from_slice(&b).ok()).unwrap_or_default();
-        p.auto_save.clamp();
+        p.clamp();
         p
     }
 
diff --git a/crates/engine/src/commands.rs b/crates/engine/src/commands.rs
index 687721f3b..7f3ae7e09 100644
--- a/crates/engine/src/commands.rs
+++ b/crates/engine/src/commands.rs
@@ -876,20 +876,16 @@ fn build() -> Vec<CommandSpec> {
             })?;
             Ok(Value::Null)
         }),
-        cmd!("clip.audioGain", "Audio Gain…", ["Clip"], Some("G"), r#"{"db":f64,"relative":bool}"#, has_selection, |s, p| {
-            let db = f64_p(p, "db").unwrap_or(0.0);
-            let rel = bool_p(p, "relative").unwrap_or(true);
-            let sel = with_links(s, &s.state.selection.clone());
-            s.edit_sequence("Audio Gain", |q, _, _| {
-                for t in q.audio_tracks.iter_mut() {
-                    for i in t.items.iter_mut().filter(|i| sel.contains(&i.id)) {
-                        i.gain_db = if rel { i.gain_db + db } else { db };
-                    }
-                }
-                Ok(())
-            })?;
-            Ok(Value::Null)
-        }),
+        cmd!(
+            "clip.audioGain",
+            "Audio Gain…",
+            ["Clip"],
+            Some("G"),
+            r#"{"mode":"set|adjust|normalizeMax|normalizeAll"?,"db":f64,"relative":bool?}"#,
+            has_selection,
+            |s, p| crate::mixer::audio_gain(s, p)
+        ),
+        query!("clip.audioPeak", "Audio Clip Peak Amplitude", r#"{"clips":[id]?}"#, |s, p| crate::mixer::audio_peak(s, p)),
         cmd!("clip.frameHold", "Add Frame Hold", ["Clip", "Video Options"], None, "{}", has_selection, |s, _| {
             let t = s.playhead();
             let sel = s.state.selection.clone();
@@ -916,7 +912,7 @@ fn build() -> Vec<CommandSpec> {
             s.events.push(crate::Event::OpenSequence(id));
             Ok(Value::Null)
         }),
-        cmd!("sequence.close", "Close Sequence", [], None, r#"{"item":id}"#, has_seq, |s, p| {
+        cmd!("sequence.close", "Close Sequence", [], None, r#"{"item":id?}"#, has_seq, |s, p| {
             let id = item_p(p, "item").or(s.state.active_sequence).ok_or(EngineError::NoSequence)?;
             s.state.open_sequences.retain(|x| *x != id);
             if s.state.active_sequence == Some(id) {
@@ -1252,8 +1248,10 @@ fn build() -> Vec<CommandSpec> {
             Ok(Value::Null)
         }),
         // ================= Source monitor =================
-        cmd!("source.open", "Open in Source Monitor", [], None, r#"{"item":id}"#, always, |s, p| {
-            let id = item_p(p, "item").ok_or_else(|| bad("source.open", "need `item`"))?;
+        cmd!("source.open", "Open in Source Monitor", [], None, r#"{"item":id?}"#, always, |s, p| {
+            let id = item_p(p, "item")
+                .or(s.state.project_selection.first().copied())
+                .ok_or_else(|| bad("source.open", "need `item` (or a Project panel selection)"))?;
             s.project.item(id).ok_or_else(|| bad("source.open", "no such item"))?;
             s.state.source_item = Some(id);
             s.state.source_playhead = Tick::ZERO;
@@ -1313,6 +1311,9 @@ fn build() -> Vec<CommandSpec> {
             let clips: Vec<ClipId> =
                 p.get("clips").and_then(Value::as_array).map(|a| a.iter().filter_map(|v| v.as_u64().map(ClipId)).collect()).unwrap_or_default();
             let clips = with_links(s, &clips);
+            // selecting clips leaves trim mode (Premiere: clip and edit point selections are exclusive)
+            s.state.edit_points.clear();
+            s.state.trim_shift = Default::default();
             if bool_p(p, "toggle").unwrap_or(false) {
                 for c in clips {
                     if let Some(i) = s.state.selection.iter().position(|x| *x == c) {
@@ -1404,16 +1405,43 @@ fn build() -> Vec<CommandSpec> {
         }),
         cmd!("trim.clear", "Clear Edit Point Selection", [], None, "{}", has_edit_points, |s, _| {
             s.state.edit_points.clear();
+            s.state.trim_shift = Default::default();
+            s.trim_play.around = None;
             Ok(Value::Null)
         }),
         cmd!("trim.toggleType", "Toggle Trim Type", [], Some("Ctrl+T"), "{}", has_edit_points, |s, _| crate::trim::toggle_type(s)),
         cmd!("trim.backward", "Trim Backward", [], Some("Alt+Left"), "{}", has_edit_points, |s, _| crate::trim::nudge(s, &json!({"frames": -1}))),
         cmd!("trim.forward", "Trim Forward", [], Some("Alt+Right"), "{}", has_edit_points, |s, _| crate::trim::nudge(s, &json!({"frames": 1}))),
-        cmd!("trim.backwardMany", "Trim Backward Many", [], Some("Alt+Shift+Left"), "{}", has_edit_points, |s, _| crate::trim::nudge(
-            s,
-            &json!({"frames": -5})
-        )),
-        cmd!("trim.forwardMany", "Trim Forward Many", [], Some("Alt+Shift+Right"), "{}", has_edit_points, |s, _| crate::trim::nudge(s, &json!({"frames": 5}))),
+        cmd!("trim.backwardMany", "Trim Backward Many", [], Some("Alt+Shift+Left"), "{}", has_edit_points, |s, _| {
+            let n = -(s.prefs.trim.large_trim_offset as i64);
+            crate::trim::nudge(s, &json!({"frames": n}))
+        }),
+        cmd!("trim.forwardMany", "Trim Forward Many", [], Some("Alt+Shift+Right"), "{}", has_edit_points, |s, _| {
+            let n = s.prefs.trim.large_trim_offset as i64;
+            crate::trim::nudge(s, &json!({"frames": n}))
+        }),
+        cmd!("trim.applyDefaultTransition", "Apply Default Transitions to Selection", ["Sequence"], None, "{}", has_edit_points, |s, _| {
+            crate::trim::apply_default_transitions(s)
+        }),
+        cmd!("trim.shuttle", "Dynamic Trim (Shuttle)", [], None, r#"{"direction":"forward|reverse","slow":bool?,"clock":seconds}"#, has_edit_points, |s, p| {
+            crate::trim::shuttle(s, p)
+        }),
+        cmd!("trim.shuttleStop", "Dynamic Trim Stop", [], None, r#"{"clock":seconds?}"#, has_seq, |s, p| crate::trim::stop(s, p)),
+        cmd!("trim.cancelDynamic", "Cancel Dynamic Trim", [], None, "{}", has_seq, |s, _| crate::trim::cancel(s)),
+        cmd!("trim.playAround", "Play Around Edit", [], None, r#"{"clock":seconds,"loop":bool=true,"toggle":bool?}"#, has_seq, |s, p| {
+            crate::trim::play_around(s, p)
+        }),
+        CommandSpec {
+            id: "trim.tick",
+            label: "Advance Trim Playback",
+            menu: &[],
+            shortcut: None,
+            params: r#"{"clock":seconds}"#,
+            enabled: has_seq,
+            run: |s, p| crate::trim::tick(s, p.get("clock").and_then(Value::as_f64).unwrap_or(0.0)),
+            journal: false,
+        },
+        query!("trim.monitor", "Trim Monitor State", "{}", |s, _| Ok(crate::trim::monitor_info(s))),
         cmd!("trim.nudge", "Trim by Frames", [], None, r#"{"frames":i64}"#, has_edit_points, |s, p| crate::trim::nudge(s, p)),
         cmd!("trim.extendToPlayhead", "Extend Selected Edit to Playhead", [], Some("E"), "{}", has_edit_points, |s, _| { crate::trim::extend_to_playhead(s) }),
         cmd!("trim.ripplePrevious", "Ripple Trim Previous Edit to Playhead", [], Some("Q"), "{}", has_seq, |s, _| crate::trim::to_playhead(
@@ -1575,6 +1603,9 @@ fn build() -> Vec<CommandSpec> {
         cmd!("effects.apply", "Apply Effect", [], None, r#"{"clips":[id]?,"effect":"gaussian_blur|Gaussian Blur|…"}"#, has_seq, |s, p| {
             let name = str_p(p, "effect").ok_or_else(|| bad("effects.apply", "need `effect`"))?;
             let def = filmcraft_project::effect::find_effect_by_name(name).ok_or_else(|| bad("effects.apply", format!("unknown effect `{name}`")))?;
+            if filmcraft_project::graphic::is_layer_id(def.id) {
+                return Err(bad("effects.apply", "graphic layers are added with graphics.newText / graphics.newShape"));
+            }
             if matches!(def.kind, filmcraft_project::EffectKind::VideoTransition | filmcraft_project::EffectKind::AudioTransition) {
                 let mut q = p.clone();
                 q["effect"] = json!(def.id);
@@ -1795,7 +1826,10 @@ fn build() -> Vec<CommandSpec> {
             Ok(Value::Array(
                 command_specs()
                     .iter()
-                    .map(|c| json!({"id": c.id, "label": c.label, "menu": c.menu, "shortcut": c.shortcut, "params": c.params, "enabled": (c.enabled)(s).is_ok()}))
+                    .map(|c| {
+                        let all: Vec<&str> = s.shortcuts.for_command(c.id).iter().map(|b| b.keys.as_str()).collect();
+                        json!({"id": c.id, "label": c.label, "menu": c.menu, "shortcut": s.shortcuts.primary(c.id), "shortcuts": all, "defaultShortcut": c.shortcut, "params": c.params, "enabled": (c.enabled)(s).is_ok()})
+                    })
                     .collect(),
             ))
         }),
@@ -1814,6 +1848,9 @@ fn build() -> Vec<CommandSpec> {
         )),
     ];
     v.extend(crate::captions::commands());
+    v.extend(crate::mixer::commands());
+    v.extend(crate::graphics::commands());
+    v.extend(crate::shortcuts::commands());
     // Labels as individual commands (Edit ▸ Label ▸ <name>)
     for l in Label::ALL {
         let _ = l;
@@ -1982,7 +2019,7 @@ fn mark(s: &mut Session, p: &Value, is_in: bool) -> Result<Value> {
     Ok(Value::Null)
 }
 
-fn json_to_param(template: &ParamValue, v: &Value) -> Option<ParamValue> {
+pub(crate) fn json_to_param(template: &ParamValue, v: &Value) -> Option<ParamValue> {
     Some(match template {
         ParamValue::Float(_) => ParamValue::Float(v.as_f64()?),
         ParamValue::Vec2(_) => {
diff --git a/crates/engine/src/graphics.rs b/crates/engine/src/graphics.rs
new file mode 100644
index 000000000..f71fb8da1
--- /dev/null
+++ b/crates/engine/src/graphics.rs
@@ -0,0 +1,551 @@
+//! Graphics commands (`graphics.*`, `fonts.list`): graphic clips with text and shape layers.
+//!
+//! A graphic clip's layers are the `graphic_text` / `graphic_shape` effect instances on the clip
+//! (see `filmcraft_project::graphic`). Commands address a clip by `clip` (default: the first
+//! selected graphic clip, else the topmost graphic clip under the playhead) and a layer by
+//! `layer` = index among the clip's graphic layers, 0 = back (default: the selected layer, else
+//! the frontmost). Property values are keyframe-aware: on an animated property they set the value
+//! at the playhead.
+
+use filmcraft_geom::Vec2;
+use filmcraft_project::graphic::{self, LayerContent, SHAPE_OPTS, eval_layer, layer_display_name, layer_indices, new_shape_layer, new_text_layer};
+use filmcraft_project::{ClipId, ItemId, ItemKind, Label, ParamValue, Sequence, TrackKind};
+use filmcraft_render::graphic_clip::{layer_local_bounds, layer_quad};
+use filmcraft_time::{Tick, TimeRange};
+use serde_json::{Value, json};
+
+use crate::commands::{CommandSpec, always, bad, f64_p, has_seq, str_p, time_p, u64_p};
+use crate::{EngineError, Result, Session};
+
+type Run = fn(&mut Session, &Value) -> Result<Value>;
+type Enabled = fn(&Session) -> std::result::Result<(), String>;
+
+fn spec(
+    id: &'static str,
+    label: &'static str,
+    menu: &'static [&'static str],
+    shortcut: Option<&'static str>,
+    params: &'static str,
+    enabled: Enabled,
+    run: Run,
+) -> CommandSpec {
+    CommandSpec { id, label, menu, shortcut, params, enabled, run, journal: true }
+}
+fn query(id: &'static str, label: &'static str, params: &'static str, run: Run) -> CommandSpec {
+    CommandSpec { id, label, menu: &[], shortcut: None, params, enabled: always, run, journal: false }
+}
+
+/// Whether a track item is a graphic clip.
+pub fn is_graphic(s: &Session, seq: &Sequence, c: ClipId) -> bool {
+    seq.find_item(c).and_then(|(_, it)| s.project.item(it.item)).is_some_and(|p| matches!(p.kind, ItemKind::Graphic { .. }))
+}
+
+/// The graphic clip a command acts on: `clip`, else the first selected graphic clip, else the
+/// topmost graphic clip under the playhead.
+pub fn target_clip(s: &Session, p: &Value) -> Option<ClipId> {
+    let seq = s.active_sequence()?;
+    if let Some(c) = u64_p(p, "clip").map(ClipId) {
+        return is_graphic(s, seq, c).then_some(c);
+    }
+    if let Some(c) = s.state.selection.iter().copied().find(|c| is_graphic(s, seq, *c)) {
+        return Some(c);
+    }
+    let t = s.playhead();
+    seq.video_tracks.iter().rev().filter_map(|tr| tr.item_at(t)).map(|it| it.id).find(|c| is_graphic(s, seq, *c))
+}
+
+fn has_graphic(s: &Session) -> std::result::Result<(), String> {
+    has_seq(s)?;
+    target_clip(s, &Value::Null).map(|_| ()).ok_or_else(|| "select a graphic clip".into())
+}
+
+/// Effect index of graphic layer `layer` (or the selected / frontmost layer) of `clip`.
+fn layer_effect_index(s: &Session, clip: ClipId, p: &Value) -> Result<(usize, usize)> {
+    let seq = s.active_sequence().ok_or(EngineError::NoSequence)?;
+    let (_, it) = seq.find_item(clip).ok_or_else(|| bad("graphics", "no such clip"))?;
+    let idx = layer_indices(&it.effects);
+    if idx.is_empty() {
+        return Err(bad("graphics", "the graphic has no layers"));
+    }
+    let l = match p.get("layer") {
+        Some(Value::Number(n)) => n.as_u64().unwrap_or(0) as usize,
+        Some(Value::String(name)) => (0..idx.len())
+            .find(|&i| layer_display_name(&it.effects[idx[i]], i).eq_ignore_ascii_case(name))
+            .ok_or_else(|| bad("graphics", format!("no layer named `{name}`")))?,
+        _ => s.state.graphic_layers.first().copied().filter(|l| *l < idx.len()).unwrap_or(idx.len() - 1),
+    };
+    let e = *idx.get(l).ok_or_else(|| bad("graphics", format!("no layer {l}")))?;
+    Ok((l, e))
+}
+
+fn vec2_p(p: &Value, k: &str) -> Option<Vec2> {
+    let a = p.get(k)?.as_array()?;
+    Some(Vec2::new(a.first()?.as_f64()?, a.get(1)?.as_f64()?))
+}
+
+/// Find or create the graphic source item for the active sequence's frame size.
+fn graphic_source(p: &mut filmcraft_project::Project, w: u32, h: u32, rate: filmcraft_time::FrameRate) -> ItemId {
+    if let Some((id, _)) =
+        p.items.iter().find(|(_, i)| matches!(i.kind, ItemKind::Graphic { width, height, rate: r } if width == w && height == h && r == rate))
+    {
+        return *id;
+    }
+    p.add_item("Graphic", Label::Rose, ItemKind::Graphic { width: w, height: h, rate }, None)
+}
+
+/// Place a new graphic clip holding `layer` at the playhead: on the first video track above the
+/// topmost clip at the playhead that is free for the duration (a track is added if needed).
+fn new_graphic_clip(s: &mut Session, layer: filmcraft_project::EffectInstance, name: &str, p: &Value) -> Result<ClipId> {
+    let seq_id = s.state.active_sequence.ok_or(EngineError::NoSequence)?;
+    let t = time_p(s, p, "").unwrap_or_else(|| s.playhead());
+    let seconds = f64_p(p, "seconds").unwrap_or(5.0).max(0.01);
+    let want_track = u64_p(p, "track").map(|v| v as usize);
+    let name = name.to_string();
+    s.edit("New Graphic", |pr, st| {
+        let (w, h, rate) = {
+            let q = pr.sequence(seq_id).ok_or(EngineError::NoSequence)?;
+            (q.settings.width, q.settings.height, q.settings.frame_rate)
+        };
+        let src = graphic_source(pr, w, h, rate);
+        let t = rate.snap(t);
+        let dur = rate.snap_nearest(Tick::from_seconds_f64(seconds)).max(rate.frame_duration());
+        let mut ti = pr.make_track_item(src, TrackKind::Video, t, TimeRange::new(Tick::ZERO, dur), rate).ok_or_else(|| bad("graphics.newText", "bad item"))?;
+        ti.name = name;
+        ti.effects.push(layer);
+        for e in &mut ti.effects {
+            filmcraft_project::resolve_auto_points(e, (w, h), (w, h));
+        }
+        let id = ti.id;
+        let track_id = filmcraft_project::TrackId(pr.alloc_id());
+        let q = pr.sequence_mut(seq_id).ok_or(EngineError::NoSequence)?;
+        let range = TimeRange::new(t, dur);
+        let free = |tr: &filmcraft_project::Track| !tr.items.iter().any(|i| i.range().overlaps(&range));
+        let idx = match want_track {
+            Some(i) if i < q.video_tracks.len() && free(&q.video_tracks[i]) => i,
+            Some(i) if i < q.video_tracks.len() => return Err(bad("graphics.newText", format!("V{} is not free here", i + 1))),
+            _ => {
+                let top = q.video_tracks.iter().rposition(|tr| tr.item_at(t).is_some()).map_or(0, |k| k + 1);
+                match (top..q.video_tracks.len()).find(|&i| free(&q.video_tracks[i]) && !q.video_tracks[i].locked) {
+                    Some(i) => i,
+                    None => {
+                        let n = q.video_tracks.len() + 1;
+                        q.video_tracks.push(filmcraft_project::Track::new(track_id, TrackKind::Video, format!("Video {n}")));
+                        q.video_tracks.len() - 1
+                    }
+                }
+            }
+        };
+        q.video_tracks[idx].items.push(ti);
+        q.video_tracks[idx].sort();
+        q.check().map_err(EngineError::Other)?;
+        st.selection = vec![id];
+        st.graphic_layers = vec![0];
+        Ok(id)
+    })
+}
+
+/// Add a layer to an existing graphic clip; returns the new layer index.
+fn add_layer(s: &mut Session, clip: ClipId, mut layer: filmcraft_project::EffectInstance) -> Result<usize> {
+    let frame = s.active_sequence().map(|q| (q.settings.width, q.settings.height)).unwrap_or((1920, 1080));
+    filmcraft_project::resolve_auto_points(&mut layer, frame, frame);
+    s.edit_sequence("Add Graphic Layer", |q, _, st| {
+        let (_, it) = q.find_item_mut(clip).ok_or(filmcraft_edit::EditError::NoItem(clip))?;
+        // new layers go in front: after the last graphic layer
+        let pos = layer_indices(&it.effects).last().map_or(it.effects.len(), |l| l + 1);
+        it.effects.insert(pos, layer);
+        let n = layer_indices(&it.effects).len() - 1;
+        st.selection = vec![clip];
+        st.graphic_layers = vec![n];
+        Ok(n)
+    })
+}
+
+/// Map friendly property names to parameter ids.
+fn param_id(k: &str) -> &str {
+    match k {
+        "fontSize" => "size",
+        "fontStyle" | "style" => "font_style",
+        "fillColor" | "color" => "fill_color",
+        "strokeColor" => "stroke_color",
+        "strokeWidth" => "stroke_width",
+        "backgroundColor" => "background_color",
+        "shadowColor" => "shadow_color",
+        "baselineShift" => "baseline_shift",
+        "fauxBold" => "faux_bold",
+        "fauxItalic" => "faux_italic",
+        "boxWidth" => "box_width",
+        "anchorPoint" => "anchor",
+        "cornerRadius" => "corner_radius",
+        other => other,
+    }
+}
+
+/// JSON value for a property, accepting names for choices ("center", "small caps", "ellipse"…).
+fn to_param(template: &ParamValue, id: &str, v: &Value) -> Option<ParamValue> {
+    if let (ParamValue::Choice(_), Value::String(name)) = (template, v) {
+        let opts: &[&str] = match id {
+            "align" => graphic::ALIGN_OPTS,
+            "caps" => graphic::CAPS_OPTS,
+            "stroke_type" | "stroke2_type" => graphic::STROKE_OPTS,
+            "shape" => SHAPE_OPTS,
+            _ => &[],
+        };
+        let n = name.to_ascii_lowercase().replace('_', " ");
+        let n = if n == "centre" { "center".to_string() } else { n };
+        return opts.iter().position(|o| o.to_ascii_lowercase() == n).map(|i| ParamValue::Choice(i as u32));
+    }
+    crate::commands::json_to_param(template, v)
+}
+
+/// Set properties `props` on a layer (keyframe-aware at time `tl`).
+fn set_props(s: &mut Session, clip: ClipId, eidx: usize, props: &serde_json::Map<String, Value>, tl: Tick, label: &str) -> Result<()> {
+    let props = props.clone();
+    s.edit_sequence(label, |q, _, _| {
+        let (_, it) = q.find_item_mut(clip).ok_or(filmcraft_edit::EditError::NoItem(clip))?;
+        let mt = it.source_time_at(tl.clamp(it.start, it.end() - Tick(1)));
+        let e = it.effects.get_mut(eidx).ok_or_else(|| bad("graphics.set", "no such layer"))?;
+        for (k, v) in &props {
+            if k == "enabled" {
+                e.enabled = v.as_bool().unwrap_or(true);
+                continue;
+            }
+            let id = param_id(k);
+            let prm = e.params.get_mut(id).ok_or_else(|| bad("graphics.set", format!("no property `{k}`")))?;
+            let pv = to_param(&prm.value, id, v).ok_or_else(|| bad("graphics.set", format!("`{k}`: value has the wrong type")))?;
+            prm.set_at(mt, pv);
+        }
+        Ok(())
+    })
+}
+
+/// Layers of a graphic clip with their evaluated bounds (sequence/canvas pixels).
+fn list_layers(s: &Session, clip: ClipId) -> Result<Value> {
+    let seq = s.active_sequence().ok_or(EngineError::NoSequence)?;
+    let (_, it) = seq.find_item(clip).ok_or_else(|| bad("graphics.list", "no such clip"))?;
+    let size = match s.project.item(it.item).map(|p| &p.kind) {
+        Some(ItemKind::Graphic { width, height, .. }) => (*width, *height),
+        _ => (seq.settings.width, seq.settings.height),
+    };
+    let ph = s.playhead();
+    let mt = it.source_time_at(ph.clamp(it.start, it.end() - Tick(1)));
+    let layers: Vec<Value> = layer_indices(&it.effects)
+        .iter()
+        .enumerate()
+        .filter_map(|(i, &ei)| {
+            let e = &it.effects[ei];
+            let sp = eval_layer(e, mt, size)?;
+            let q = layer_quad(&sp);
+            let (kind, text) = match &sp.content {
+                LayerContent::Text(t) => ("text", Some(t.text.clone())),
+                LayerContent::Shape(sh) => (SHAPE_OPTS.get(sh.shape as usize).copied().unwrap_or("Shape"), None),
+            };
+            Some(json!({
+                "layer": i,
+                "effectIndex": ei,
+                "name": layer_display_name(e, i),
+                "kind": kind,
+                "text": text,
+                "enabled": e.enabled,
+                "position": [sp.transform.position.x, sp.transform.position.y],
+                "localBounds": layer_local_bounds(&sp),
+                "quad": q.iter().map(|p| [p.x, p.y]).collect::<Vec<_>>(),
+            }))
+        })
+        .collect();
+    Ok(json!({"clip": clip.0, "name": it.name, "start": it.start.0, "duration": it.duration.0, "canvas": [size.0, size.1], "layers": layers}))
+}
+
+fn quad_bounds(q: &[Vec2; 4]) -> [f64; 4] {
+    let mut b = [f64::MAX, f64::MAX, f64::MIN, f64::MIN];
+    for p in q {
+        b = [b[0].min(p.x), b[1].min(p.y), b[2].max(p.x), b[3].max(p.y)];
+    }
+    b
+}
+
+/// Layer bounds of `layers` (layer indices) of `clip` at the playhead: (effect index, position, bounds).
+fn layer_boxes(s: &Session, clip: ClipId, layers: &[usize]) -> Result<(Vec<(usize, Vec2, [f64; 4])>, (u32, u32))> {
+    let seq = s.active_sequence().ok_or(EngineError::NoSequence)?;
+    let (_, it) = seq.find_item(clip).ok_or_else(|| bad("graphics.align", "no such clip"))?;
+    let size = match s.project.item(it.item).map(|p| &p.kind) {
+        Some(ItemKind::Graphic { width, height, .. }) => (*width, *height),
+        _ => (seq.settings.width, seq.settings.height),
+    };
+    let mt = it.source_time_at(s.playhead().clamp(it.start, it.end() - Tick(1)));
+    let idx = layer_indices(&it.effects);
+    let mut out = Vec::new();
+    for &l in layers {
+        let ei = *idx.get(l).ok_or_else(|| bad("graphics.align", format!("no layer {l}")))?;
+        let sp = eval_layer(&it.effects[ei], mt, size).ok_or_else(|| bad("graphics.align", "bad layer"))?;
+        out.push((ei, sp.transform.position, quad_bounds(&layer_quad(&sp))));
+    }
+    Ok((out, size))
+}
+
+fn layers_p(s: &Session, clip: ClipId, p: &Value) -> Result<Vec<usize>> {
+    if let Some(a) = p.get("layers").and_then(Value::as_array) {
+        return Ok(a.iter().filter_map(Value::as_u64).map(|v| v as usize).collect());
+    }
+    if !s.state.graphic_layers.is_empty() {
+        return Ok(s.state.graphic_layers.clone());
+    }
+    let (l, _) = layer_effect_index(s, clip, p)?;
+    Ok(vec![l])
+}
+
+fn move_layers(s: &mut Session, clip: ClipId, moves: Vec<(usize, Vec2)>, label: &str) -> Result<()> {
+    let tl = s.playhead();
+    s.edit_sequence(label, |q, _, _| {
+        let (_, it) = q.find_item_mut(clip).ok_or(filmcraft_edit::EditError::NoItem(clip))?;
+        let mt = it.source_time_at(tl.clamp(it.start, it.end() - Tick(1)));
+        for (ei, pos) in &moves {
+            if let Some(prm) = it.effects.get_mut(*ei).and_then(|e| e.params.get_mut("position")) {
+                prm.set_at(mt, ParamValue::Vec2(*pos));
+            }
+        }
+        Ok(())
+    })
+}
+
+pub fn commands() -> Vec<CommandSpec> {
+    vec![
+        spec(
+            "graphics.newText",
+            "Text",
+            &["Graphics and Titles", "New Layer"],
+            Some("Cmd+T"),
+            r#"{"text":str="New Text","position":[x,y]?,"clip":id?,"newClip":bool?,"size":px=100,"font":str?,"fontStyle":str?,"seconds":f64=5,"track":index?,"time":ticks?}"#,
+            has_seq,
+            |s, p| {
+                let text = str_p(p, "text").unwrap_or("New Text").to_string();
+                let (w, h) = s.active_sequence().map(|q| (q.settings.width, q.settings.height)).unwrap_or((1920, 1080));
+                let pos = vec2_p(p, "position").unwrap_or(Vec2::new(w as f64 / 2.0, h as f64 / 2.0));
+                let mut layer = new_text_layer(&text, pos, f64_p(p, "size").unwrap_or(100.0));
+                for (k, id) in [("font", "font"), ("fontStyle", "font_style")] {
+                    if let Some(v) = str_p(p, k) {
+                        layer.params.insert(id.into(), filmcraft_project::Param::new(ParamValue::Text(v.into())));
+                    }
+                }
+                let into = if p.get("newClip").and_then(Value::as_bool) == Some(true) { None } else { u64_p(p, "clip").map(ClipId) };
+                let into = into.filter(|c| s.active_sequence().is_some_and(|q| is_graphic(s, q, *c)));
+                let (clip, layer_i) = match into {
+                    Some(c) => (c, add_layer(s, c, layer)?),
+                    None => {
+                        let name = text.lines().next().filter(|l| !l.trim().is_empty()).unwrap_or("Graphic").to_string();
+                        (new_graphic_clip(s, layer, &name, p)?, 0)
+                    }
+                };
+                Ok(json!({"clip": clip.0, "layer": layer_i}))
+            },
+        ),
+        spec(
+            "graphics.newShape",
+            "Shape",
+            &["Graphics and Titles", "New Layer"],
+            None,
+            r#"{"shape":"rectangle|ellipse|polygon|path","position":[x,y]?,"size":[w,h]=[400,200],"points":[[x,y],…]?,"clip":id?,"seconds":f64=5}"#,
+            has_seq,
+            |s, p| {
+                let shape = str_p(p, "shape").unwrap_or("rectangle").to_ascii_lowercase();
+                let k = SHAPE_OPTS
+                    .iter()
+                    .position(|o| o.to_ascii_lowercase() == shape)
+                    .ok_or_else(|| bad("graphics.newShape", format!("unknown shape `{shape}`")))? as u32;
+                let (w, h) = s.active_sequence().map(|q| (q.settings.width, q.settings.height)).unwrap_or((1920, 1080));
+                let pos = vec2_p(p, "position").unwrap_or(Vec2::new(w as f64 / 2.0, h as f64 / 2.0));
+                let size = vec2_p(p, "size").unwrap_or(Vec2::new(400.0, 200.0));
+                let points: Vec<[f32; 2]> = p
+                    .get("points")
+                    .and_then(Value::as_array)
+                    .map(|a| a.iter().filter_map(|q| Some([q.get(0)?.as_f64()? as f32, q.get(1)?.as_f64()? as f32])).collect())
+                    .unwrap_or_default();
+                if k == 3 && points.len() < 3 {
+                    return Err(bad("graphics.newShape", "a path needs at least 3 points"));
+                }
+                let layer = new_shape_layer(k, pos, size, points);
+                let into = u64_p(p, "clip").map(ClipId).filter(|c| s.active_sequence().is_some_and(|q| is_graphic(s, q, *c)));
+                let (clip, layer_i) = match into {
+                    Some(c) => (c, add_layer(s, c, layer)?),
+                    None => (new_graphic_clip(s, layer, "Shape", p)?, 0),
+                };
+                Ok(json!({"clip": clip.0, "layer": layer_i}))
+            },
+        ),
+        spec(
+            "graphics.setText",
+            "Edit Text",
+            &[],
+            None,
+            r#"{"clip":id?,"layer":n|name?,"text":str,"merge":bool? (coalesce with the previous Edit Text undo step)}"#,
+            has_graphic,
+            |s, p| {
+                let clip = target_clip(s, p).ok_or_else(|| bad("graphics.setText", "no graphic clip"))?;
+                let (_, ei) = layer_effect_index(s, clip, p)?;
+                let text = str_p(p, "text").ok_or_else(|| bad("graphics.setText", "need `text`"))?.to_string();
+                let merge = p.get("merge").and_then(Value::as_bool).unwrap_or(false) && s.history.undo.last().is_some_and(|h| h.0 == "Edit Text");
+                let mut props = serde_json::Map::new();
+                props.insert("text".into(), Value::String(text));
+                let ph = s.playhead();
+                set_props(s, clip, ei, &props, ph, "Edit Text")?;
+                if merge && s.history.undo.len() >= 2 {
+                    // keep the snapshot from before the typing session
+                    s.history.undo.pop();
+                }
+                Ok(Value::Null)
+            },
+        ),
+        spec(
+            "graphics.set",
+            "Set Graphic Properties",
+            &[],
+            None,
+            r##"{"clip":id?,"layer":n|name?,"props":{"font":"Inter","font_style":"Bold","size":120,"align":"center","tracking":50,"leading":0,"fill_color":"#ffcc00","stroke":true,"stroke_width":6,"background":true,"shadow":true,"position":[x,y],"scale":100,"rotation":0,"opacity":100,…},"time":ticks?}"##,
+            has_graphic,
+            |s, p| {
+                let clip = target_clip(s, p).ok_or_else(|| bad("graphics.set", "no graphic clip"))?;
+                let (_, ei) = layer_effect_index(s, clip, p)?;
+                let props = p.get("props").and_then(Value::as_object).ok_or_else(|| bad("graphics.set", "need `props`"))?.clone();
+                let tl = time_p(s, p, "").unwrap_or_else(|| s.playhead());
+                set_props(s, clip, ei, &props, tl, "Change Graphic Property")?;
+                Ok(Value::Null)
+            },
+        ),
+        spec("graphics.selectLayer", "Select Graphic Layer", &[], None, r#"{"clip":id?,"layers":[n]}"#, has_graphic, |s, p| {
+            let clip = target_clip(s, p).ok_or_else(|| bad("graphics.selectLayer", "no graphic clip"))?;
+            let layers: Vec<usize> =
+                p.get("layers").and_then(Value::as_array).map(|a| a.iter().filter_map(Value::as_u64).map(|v| v as usize).collect()).unwrap_or_default();
+            s.state.selection = vec![clip];
+            s.state.graphic_layers = layers;
+            Ok(Value::Null)
+        }),
+        spec("graphics.deleteLayer", "Delete Graphic Layer", &[], None, r#"{"clip":id?,"layer":n?}"#, has_graphic, |s, p| {
+            let clip = target_clip(s, p).ok_or_else(|| bad("graphics.deleteLayer", "no graphic clip"))?;
+            let (_, ei) = layer_effect_index(s, clip, p)?;
+            s.edit_sequence("Delete Graphic Layer", |q, _, st| {
+                let (_, it) = q.find_item_mut(clip).ok_or(filmcraft_edit::EditError::NoItem(clip))?;
+                it.effects.remove(ei);
+                st.graphic_layers.clear();
+                Ok(())
+            })?;
+            Ok(Value::Null)
+        }),
+        spec(
+            "graphics.arrangeLayer",
+            "Arrange Graphic Layer",
+            &[],
+            None,
+            r#"{"clip":id?,"layer":n?,"to":"front|back|forward|backward"|index}"#,
+            has_graphic,
+            |s, p| {
+                let clip = target_clip(s, p).ok_or_else(|| bad("graphics.arrangeLayer", "no graphic clip"))?;
+                let (l, _) = layer_effect_index(s, clip, p)?;
+                let to = p.get("to").cloned().unwrap_or(json!("front"));
+                let n = s.state.graphic_layers.len();
+                let _ = n;
+                s.edit_sequence("Arrange Graphic Layer", |q, _, st| {
+                    let (_, it) = q.find_item_mut(clip).ok_or(filmcraft_edit::EditError::NoItem(clip))?;
+                    let idx = layer_indices(&it.effects);
+                    let last = idx.len() - 1;
+                    let dest = match &to {
+                        Value::Number(v) => (v.as_u64().unwrap_or(0) as usize).min(last),
+                        Value::String(w) => match w.as_str() {
+                            "front" => last,
+                            "back" => 0,
+                            "forward" => (l + 1).min(last),
+                            "backward" => l.saturating_sub(1),
+                            o => return Err(bad("graphics.arrangeLayer", format!("unknown `to` `{o}`"))),
+                        },
+                        _ => last,
+                    };
+                    let e = it.effects.remove(idx[l]);
+                    let mut idx2 = layer_indices(&it.effects);
+                    let insert_at = if dest >= idx2.len() { idx2.pop().map_or(idx[0], |x| x + 1) } else { idx2[dest] };
+                    it.effects.insert(insert_at, e);
+                    st.graphic_layers = vec![dest];
+                    Ok(())
+                })?;
+                Ok(Value::Null)
+            },
+        ),
+        spec(
+            "graphics.align",
+            "Align Layers",
+            &[],
+            None,
+            r#"{"clip":id?,"layers":[n]?,"align":"left|hcenter|right|top|vcenter|bottom","to":"frame|selection"="frame" (one layer always aligns to the frame)}"#,
+            has_graphic,
+            |s, p| {
+                let clip = target_clip(s, p).ok_or_else(|| bad("graphics.align", "no graphic clip"))?;
+                let layers = layers_p(s, clip, p)?;
+                let (boxes, size) = layer_boxes(s, clip, &layers)?;
+                let how = str_p(p, "align").ok_or_else(|| bad("graphics.align", "need `align`"))?;
+                let to_sel = str_p(p, "to") == Some("selection") && boxes.len() > 1;
+                let r = if to_sel {
+                    boxes.iter().fold([f64::MAX, f64::MAX, f64::MIN, f64::MIN], |a, b| [a[0].min(b.2[0]), a[1].min(b.2[1]), a[2].max(b.2[2]), a[3].max(b.2[3])])
+                } else {
+                    [0.0, 0.0, size.0 as f64, size.1 as f64]
+                };
+                let mut moves = Vec::new();
+                for (ei, pos, b) in boxes {
+                    let (dx, dy) = match how {
+                        "left" => (r[0] - b[0], 0.0),
+                        "right" => (r[2] - b[2], 0.0),
+                        "hcenter" | "center" => ((r[0] + r[2]) / 2.0 - (b[0] + b[2]) / 2.0, 0.0),
+                        "top" => (0.0, r[1] - b[1]),
+                        "bottom" => (0.0, r[3] - b[3]),
+                        "vcenter" | "middle" => (0.0, (r[1] + r[3]) / 2.0 - (b[1] + b[3]) / 2.0),
+                        o => return Err(bad("graphics.align", format!("unknown alignment `{o}`"))),
+                    };
+                    moves.push((ei, Vec2::new(pos.x + dx, pos.y + dy)));
+                }
+                move_layers(s, clip, moves, "Align Layers")?;
+                Ok(Value::Null)
+            },
+        ),
+        spec(
+            "graphics.distribute",
+            "Distribute Layers",
+            &[],
+            None,
+            r#"{"clip":id?,"layers":[n] (3 or more)?,"axis":"horizontal|vertical"}"#,
+            has_graphic,
+            |s, p| {
+                let clip = target_clip(s, p).ok_or_else(|| bad("graphics.distribute", "no graphic clip"))?;
+                let layers = layers_p(s, clip, p)?;
+                let (mut boxes, _) = layer_boxes(s, clip, &layers)?;
+                if boxes.len() < 3 {
+                    return Err(bad("graphics.distribute", "select three or more layers"));
+                }
+                let vertical = str_p(p, "axis") == Some("vertical");
+                let c = |b: &[f64; 4]| if vertical { (b[1] + b[3]) / 2.0 } else { (b[0] + b[2]) / 2.0 };
+                boxes.sort_by(|a, b| c(&a.2).total_cmp(&c(&b.2)));
+                let (first, last) = (c(&boxes[0].2), c(&boxes[boxes.len() - 1].2));
+                let n = boxes.len() - 1;
+                let moves = boxes
+                    .iter()
+                    .enumerate()
+                    .map(|(i, (ei, pos, b))| {
+                        let d = first + (last - first) * i as f64 / n as f64 - c(b);
+                        (*ei, if vertical { Vec2::new(pos.x, pos.y + d) } else { Vec2::new(pos.x + d, pos.y) })
+                    })
+                    .collect();
+                move_layers(s, clip, moves, "Distribute Layers")?;
+                Ok(Value::Null)
+            },
+        ),
+        query("graphics.list", "List Graphic Layers", r#"{"clip":id?}"#, |s, p| {
+            let clip = target_clip(s, p).ok_or_else(|| bad("graphics.list", "no graphic clip"))?;
+            list_layers(s, clip)
+        }),
+        query("fonts.list", "List Fonts", r#"{"system":bool=true (scan the system font folders)}"#, |_, p| {
+            if p.get("system").and_then(Value::as_bool).unwrap_or(true) {
+                filmcraft_text::fonts::scan_system();
+            }
+            Ok(json!(filmcraft_text::families().into_iter().map(|(f, st)| json!({"family": f, "styles": st})).collect::<Vec<_>>()))
+        }),
+    ]
+}
+
+#[cfg(test)]
+#[path = "graphics_tests.rs"]
+mod tests;
diff --git a/crates/engine/src/graphics_tests.rs b/crates/engine/src/graphics_tests.rs
new file mode 100644
index 000000000..64f21bab8
--- /dev/null
+++ b/crates/engine/src/graphics_tests.rs
@@ -0,0 +1,130 @@
+use serde_json::json;
+
+use crate::Session;
+use filmcraft_project::graphic::{LayerContent, eval_layer, layer_indices};
+use filmcraft_project::{ClipId, ItemKind};
+use filmcraft_time::Tick;
+
+fn demo() -> Session {
+    let mut s = Session::default();
+    s.execute("file.openDemoProject", json!({})).unwrap();
+    s
+}
+
+fn layers(s: &Session, clip: ClipId) -> Vec<filmcraft_project::graphic::LayerSpec> {
+    let q = s.active_sequence().unwrap();
+    let (_, it) = q.find_item(clip).unwrap();
+    layer_indices(&it.effects).into_iter().filter_map(|i| eval_layer(&it.effects[i], Tick::ZERO, (q.settings.width, q.settings.height))).collect()
+}
+
+fn text_of(l: &filmcraft_project::graphic::LayerSpec) -> String {
+    match &l.content {
+        LayerContent::Text(t) => t.text.clone(),
+        _ => panic!("not text"),
+    }
+}
+
+#[test]
+fn new_text_makes_a_graphic_clip_above_the_footage() {
+    let mut s = demo();
+    let t = s.playhead();
+    let r = s.execute("graphics.newText", json!({"text": "Hello", "position": [200, 300]})).unwrap();
+    let clip = ClipId(r["clip"].as_u64().unwrap());
+    let q = s.active_sequence().unwrap();
+    let (tid, it) = q.find_item(clip).unwrap();
+    let track_index = q.video_tracks.iter().position(|tr| tr.id == tid).unwrap();
+    let below_busy = q.video_tracks[..track_index].iter().any(|tr| tr.item_at(t).is_some());
+    assert!(below_busy || track_index == 0, "placed above the clip under the playhead");
+    assert_eq!(it.name, "Hello");
+    assert!(matches!(s.project.item(it.item).unwrap().kind, ItemKind::Graphic { .. }));
+    assert_eq!(it.duration, q.settings.frame_rate.snap_nearest(Tick::from_seconds_f64(5.0)));
+    assert!(!it.has_standard_effects(), "layers are not fx");
+    assert_eq!(s.state.selection, vec![clip]);
+    let ls = layers(&s, clip);
+    assert_eq!(ls.len(), 1);
+    assert_eq!(text_of(&ls[0]), "Hello");
+    assert_eq!((ls[0].transform.position.x, ls[0].transform.position.y), (200.0, 300.0));
+
+    // a second text layer in the same clip, then a shape
+    let r2 = s.execute("graphics.newText", json!({"text": "World", "clip": clip.0})).unwrap();
+    assert_eq!(r2["layer"], 1);
+    s.execute("graphics.newShape", json!({"shape": "ellipse", "clip": clip.0, "size": [100, 50]})).unwrap();
+    assert_eq!(layers(&s, clip).len(), 3);
+    let list = s.execute("graphics.list", json!({"clip": clip.0})).unwrap();
+    assert_eq!(list["layers"][2]["kind"], "Ellipse");
+    assert_eq!(list["layers"][1]["name"], "World");
+
+    // undo removes the shape layer again
+    s.execute("edit.undo", json!({})).unwrap();
+    assert_eq!(layers(&s, clip).len(), 2);
+}
+
+#[test]
+fn typing_coalesces_into_one_undo_step_and_props_set() {
+    let mut s = demo();
+    let r = s.execute("graphics.newText", json!({"text": ""})).unwrap();
+    let clip = ClipId(r["clip"].as_u64().unwrap());
+    let before = s.history.undo.len();
+    for (i, t) in ["T", "Ti", "Tit", "Titl", "Title"].iter().enumerate() {
+        s.execute("graphics.setText", json!({"clip": clip.0, "layer": 0, "text": t, "merge": i > 0})).unwrap();
+    }
+    assert_eq!(s.history.undo.len(), before + 1, "one undo step for the typing session");
+    assert_eq!(text_of(&layers(&s, clip)[0]), "Title");
+    s.execute("graphics.set", json!({"clip": clip.0, "props": {"font_style": "Bold", "fontSize": 140, "align": "center", "fill_color": "#ffcc00", "stroke": true, "caps": "small caps"}})).unwrap();
+    let l = &layers(&s, clip)[0];
+    let LayerContent::Text(t) = &l.content else { panic!() };
+    assert_eq!((t.style.as_str(), t.size, t.align, t.caps), ("Bold", 140.0, 1, 2));
+    assert_eq!(l.appearance.strokes.len(), 1);
+    assert!((l.appearance.fill.unwrap()[1] - 0.8).abs() < 0.01);
+    assert!(s.execute("graphics.set", json!({"clip": clip.0, "props": {"nope": 1}})).is_err());
+    s.execute("edit.undo", json!({})).unwrap();
+    s.execute("edit.undo", json!({})).unwrap();
+    assert_eq!(text_of(&layers(&s, clip)[0]), "");
+}
+
+#[test]
+fn align_and_distribute_layers() {
+    let mut s = demo();
+    let (w, h) = {
+        let q = s.active_sequence().unwrap();
+        (q.settings.width as f64, q.settings.height as f64)
+    };
+    let r = s.execute("graphics.newShape", json!({"shape": "rectangle", "position": [300, 200], "size": [100, 60]})).unwrap();
+    let clip = r["clip"].as_u64().unwrap();
+    s.execute("graphics.newShape", json!({"shape": "rectangle", "clip": clip, "position": [500, 400], "size": [40, 40]})).unwrap();
+    s.execute("graphics.newShape", json!({"shape": "rectangle", "clip": clip, "position": [1500, 900], "size": [40, 40]})).unwrap();
+    s.execute("graphics.align", json!({"clip": clip, "layers": [0], "align": "left"})).unwrap();
+    s.execute("graphics.align", json!({"clip": clip, "layers": [0], "align": "bottom"})).unwrap();
+    let l = layers(&s, ClipId(clip));
+    assert!((l[0].transform.position.x - 50.0).abs() < 1e-6, "left edge on the frame edge");
+    assert!((l[0].transform.position.y - (h - 30.0)).abs() < 1e-6);
+    s.execute("graphics.align", json!({"clip": clip, "layers": [1, 2], "align": "vcenter", "to": "selection"})).unwrap();
+    let l = layers(&s, ClipId(clip));
+    assert!((l[1].transform.position.y - l[2].transform.position.y).abs() < 1e-6);
+    s.execute("graphics.distribute", json!({"clip": clip, "layers": [0, 1, 2], "axis": "horizontal"})).unwrap();
+    let l = layers(&s, ClipId(clip));
+    let xs: Vec<f64> = l.iter().map(|x| x.transform.position.x).collect();
+    assert!(((xs[1] - xs[0]) - (xs[2] - xs[1])).abs() < 1e-6, "{xs:?}");
+    let _ = w;
+}
+
+#[test]
+fn graphic_renders_in_the_program_and_survives_save() {
+    let mut s = demo();
+    let r = s.execute("graphics.newText", json!({"text": "BIG", "size": 300, "position": [100, 500]})).unwrap();
+    let clip = r["clip"].as_u64().unwrap();
+    s.execute("graphics.set", json!({"clip": clip, "props": {"fill_color": "#ff0000"}})).unwrap();
+    let img = s.render_program(0.25).unwrap();
+    let red = img.px.chunks(4).filter(|p| p[0] > 0.9 && p[1] < 0.05 && p[2] < 0.05).count();
+    assert!(red > 200, "red text in the program: {red}");
+    let dir = std::env::temp_dir().join(format!("fc-gfx-{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join("g.fcproj");
+    s.execute("file.saveAs", json!({"path": path.to_string_lossy()})).unwrap();
+    let mut s2 = Session::default();
+    s2.execute("file.open", json!({"path": path.to_string_lossy()})).unwrap();
+    assert_eq!(s2.project.items, s.project.items, "graphic clips round-trip");
+    let _ = std::fs::remove_dir_all(&dir);
+    let fonts = s.execute("fonts.list", json!({"system": false})).unwrap();
+    assert!(fonts.as_array().unwrap().iter().any(|f| f["family"] == "Inter"));
+}
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index dfaba163b..e9a9f2788 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -12,9 +12,13 @@ pub mod autosave;
 pub mod captions;
 pub mod commands;
 pub mod demo;
+pub mod graphics;
 pub mod interchange;
 pub mod media_pool;
+pub mod mixer;
 pub mod previews;
+pub mod shortcut_presets;
+pub mod shortcuts;
 pub mod trim;
 
 use std::sync::Arc;
@@ -77,6 +81,9 @@ pub struct History {
     pub redo: Vec<(String, Arc<Project>)>,
     /// Labels of all applied states, oldest first (History panel).
     pub limit: usize,
+    /// Key of the last [`Session::edit_merged`] step: a continuous gesture (a fader drag) with the
+    /// same key folds into that one undo step.
+    pub merge_key: Option<String>,
 }
 
 impl History {
@@ -124,9 +131,15 @@ pub struct EditorState {
     /// Selected edit points (trim mode).
     #[serde(default)]
     pub edit_points: Vec<trim::EditPoint>,
+    /// Trim Monitor Out/In shift counters for the selected edit point.
+    #[serde(default)]
+    pub trim_shift: trim::TrimShift,
     /// Selected captions (caption tracks / Captions panel).
     #[serde(default)]
     pub caption_selection: Vec<ClipId>,
+    /// Selected layers (indices among the graphic layers, 0 = back) of the selected graphic clip.
+    #[serde(default)]
+    pub graphic_layers: Vec<usize>,
 }
 
 /// Events for frontends (drained each frame).
@@ -162,6 +175,14 @@ pub struct Session {
     pub loaded_schema: u32,
     /// Render preview files + render-bar segments (shared with the frontend's frame workers).
     pub previews: Arc<previews::PreviewStore>,
+    /// Audio Track Mixer automation pass in progress.
+    pub mixrec: mixer::Recorder,
+    /// Dynamic (J/K/L) trimming and trim-mode loop playback in progress.
+    pub trim_play: trim::TrimPlayback,
+    /// Keyboard shortcuts (active bindings, presets; `shortcuts.*` commands).
+    pub shortcuts: shortcuts::Shortcuts,
+    /// Nesting depth of [`Session::execute`] (commands that run other commands).
+    exec_depth: u32,
 }
 
 /// A background job with shared progress.
@@ -221,6 +242,10 @@ impl Session {
             persistence: None,
             loaded_schema: filmcraft_format::SCHEMA_VERSION,
             previews: Arc::new(previews::PreviewStore::temp()),
+            mixrec: Default::default(),
+            trim_play: Default::default(),
+            shortcuts: shortcuts::Shortcuts::new(),
+            exec_depth: 0,
         }
     }
 
@@ -230,6 +255,7 @@ impl Session {
     pub fn start_autosave(&mut self, cfg: autosave::AutosaveConfig) -> std::io::Result<()> {
         let prefs_path = cfg.data_dir.join("preferences.json");
         self.prefs = autosave::Preferences::load(&prefs_path);
+        self.shortcuts.set_dir(&cfg.data_dir);
         self.prefs_path = Some(prefs_path);
         self.persistence = Some(autosave::Persistence::start(&cfg, self.prefs.auto_save.clone())?);
         self.sync_persistence();
@@ -311,9 +337,16 @@ impl Session {
     /// Run a command by id.
     pub fn execute(&mut self, id: &str, params: Value) -> Result<Value> {
         let spec = commands::find(id).ok_or_else(|| EngineError::UnknownCommand(id.to_string()))?;
+        if self.exec_depth == 0 && spec.journal && self.trim_play.active() {
+            self.settle_trim_playback(id);
+        }
         (spec.enabled)(self).map_err(|why| EngineError::Disabled(id.to_string(), why))?;
+        self.exec_depth += 1;
         let r = (spec.run)(self, &params);
+        self.exec_depth -= 1;
         self.sync_persistence();
+        // playback reads the newest snapshot (mixer moves, mutes… are heard while playing)
+        self.previews.live.publish_project(self.project.clone());
         if r.is_ok() && spec.journal {
             self.journal.push((id.to_string(), params));
             if self.journal.len() > 10_000 {
@@ -323,6 +356,21 @@ impl Session {
         r
     }
 
+    /// Another command arrives while trim-mode playback runs: a dynamic trim is committed first
+    /// (so e.g. Undo undoes it as one step); loop playback stops unless it is a trim command.
+    fn settle_trim_playback(&mut self, id: &str) {
+        const LIVE: [&str; 5] = ["trim.shuttle", "trim.tick", "trim.shuttleStop", "trim.cancelDynamic", "trim.playAround"];
+        if LIVE.contains(&id) {
+            return;
+        }
+        if self.trim_play.dynamic.is_some() {
+            trim::commit(self);
+        }
+        if !id.starts_with("trim.") {
+            self.trim_play.around = None;
+        }
+    }
+
     pub fn is_enabled(&self, id: &str) -> bool {
         commands::find(id).is_some_and(|c| (c.enabled)(self).is_ok())
     }
@@ -338,6 +386,25 @@ impl Session {
             self.history.undo.remove(0);
         }
         self.history.redo.clear();
+        self.history.merge_key = None;
+        self.state = st;
+        self.bump();
+        Ok(r)
+    }
+
+    /// Like [`Session::edit`], but consecutive calls with the same `key` (and no other edit in
+    /// between) share one undo step: dragging a control is one undoable change.
+    pub fn edit_merged<R>(&mut self, label: &str, key: &str, f: impl FnOnce(&mut Project, &mut EditorState) -> Result<R>) -> Result<R> {
+        let merge = self.history.merge_key.as_deref() == Some(key) && self.history.undo.last().is_some_and(|u| u.0 == label);
+        if !merge {
+            let r = self.edit(label, f)?;
+            self.history.merge_key = Some(key.to_string());
+            return Ok(r);
+        }
+        let mut p = (*self.project).clone();
+        let mut st = self.state.clone();
+        let r = f(&mut p, &mut st)?;
+        self.project = Arc::new(p);
         self.state = st;
         self.bump();
         Ok(r)
@@ -367,6 +434,7 @@ impl Session {
 
     pub fn undo(&mut self) -> Option<String> {
         let (label, prev) = self.history.undo.pop()?;
+        self.history.merge_key = None;
         let cur = std::mem::replace(&mut self.project, prev);
         self.history.redo.push((label.clone(), cur));
         self.fix_state();
@@ -376,6 +444,7 @@ impl Session {
 
     pub fn redo(&mut self) -> Option<String> {
         let (label, next) = self.history.redo.pop()?;
+        self.history.merge_key = None;
         let cur = std::mem::replace(&mut self.project, next);
         self.history.undo.push((label.clone(), cur));
         self.fix_state();
@@ -479,7 +548,7 @@ pub fn media_duration(p: &Project, _pool: &MediaPool, id: ItemId) -> Option<Tick
         },
         filmcraft_project::ItemKind::Sequence(s) => Some(s.duration()),
         filmcraft_project::ItemKind::Subclip { range, .. } => Some(range.end()),
-        filmcraft_project::ItemKind::AdjustmentLayer { .. } => None,
+        filmcraft_project::ItemKind::AdjustmentLayer { .. } | filmcraft_project::ItemKind::Graphic { .. } => None,
     }
 }
 
@@ -488,6 +557,12 @@ mod autosave_tests;
 #[cfg(test)]
 mod file_tests;
 #[cfg(test)]
+mod mixer_tests;
+#[cfg(test)]
 mod previews_tests;
 #[cfg(test)]
+mod shortcuts_tests;
+#[cfg(test)]
 mod tests;
+#[cfg(test)]
+mod trim_tests;
diff --git a/crates/engine/src/mixer.rs b/crates/engine/src/mixer.rs
new file mode 100644
index 000000000..5f3781efb
--- /dev/null
+++ b/crates/engine/src/mixer.rs
@@ -0,0 +1,1191 @@
+//! Audio Track Mixer commands and the automation recorder.
+//!
+//! Strips are addressed by `strip` (or `track`): `"A1"` … (audio tracks), `"S1"` … (submixes),
+//! `"Mix"` (the master), a track id, or a strip name. Lanes are `volume`, `pan`, `mute`,
+//! `send.<i>.level` and `fx.<slot>.<param>` (see [`filmcraft_project::mixer`]).
+//!
+//! **Recording.** `mixer.recordStart` begins an automation pass at the playhead (the UI calls it
+//! when playback starts). While it runs, `mixer.touch` / `mixer.release` are the fader gestures:
+//! the audio follows the control immediately (through [`filmcraft_render::mixer::LiveMix`]) and the
+//! gesture is recorded as a stream of (time, value) points. `mixer.recordStop` (playback stops)
+//! thins every stream into keyframes and writes them as one undoable step, following the strip's
+//! automation mode:
+//!
+//! | mode | records | after release |
+//! |---|---|---|
+//! | Off / Read | nothing (Read plays the automation) | the control returns to the automation |
+//! | Latch | from the first touch | keeps writing the last value until playback stops |
+//! | Touch | while touched | ramps back to the existing automation over the automatch time |
+//! | Write | every control from the start of playback | keeps writing the last value until playback stops |
+//!
+//! With "Switch to Touch after Write" (on by default) a Write strip changes to Touch after the
+//! pass. Without a recording pass, `mixer.touch` holds the control live and `mixer.release` commits
+//! it once (a static value, or a keyframe at the playhead when the lane is automated).
+
+use serde_json::{Value, json};
+
+use filmcraft_project::mixer::{
+    self as pm, FADER_MAX_DB, FADER_MIN_DB, LANE_MUTE, LANE_PAN, LANE_VOLUME, MASTER_STRIP, lane_info, parse_fx_lane, parse_send_lane, thin_points, write_lane,
+};
+use filmcraft_project::{AudioChannels, AutomationMode, InputMap, ItemId, Param, ParamValue, Sequence, Track, TrackId, TrackKind, TrackSend, find_effect};
+use filmcraft_time::{TICKS_PER_SECOND, Tick};
+
+use crate::commands::{CommandSpec, always, bad, bool_p, f64_p, has_seq, str_p, time_p, u64_p};
+use crate::{EngineError, Result, Session};
+
+type Run = fn(&mut Session, &Value) -> Result<Value>;
+type Enabled = fn(&Session) -> std::result::Result<(), String>;
+
+// ------------------------------------------------------------------------------------- recorder
+
+/// A held value ends this long before the next move (one sample at 48 kHz).
+const HOLD_EPS: Tick = Tick(TICKS_PER_SECOND / 48_000);
+
+/// One recorded control gesture.
+#[derive(Clone, Debug)]
+pub struct Gesture {
+    pub strip: TrackId,
+    pub lane: String,
+    pub mode: AutomationMode,
+    /// Recorded (time, value) points.
+    pub points: Vec<(Tick, f64)>,
+    pub touching: bool,
+    /// Touch: released at.
+    pub released: Option<Tick>,
+    last: (Tick, f64),
+}
+
+impl Gesture {
+    fn new(strip: TrackId, lane: &str, mode: AutomationMode, t: Tick, v: f64) -> Self {
+        Gesture { strip, lane: lane.to_string(), mode, points: vec![(t, v)], touching: true, released: None, last: (t, v) }
+    }
+    /// A new value at `t`. Repeats of the same value extend the hold instead of adding points, so a
+    /// fader held still records a flat line, not a ramp to the next move.
+    fn push(&mut self, t: Tick, v: f64) {
+        if t < self.last.0 {
+            return;
+        }
+        if v == self.last.1 {
+            self.last.0 = t;
+            return;
+        }
+        if self.points.last().is_some_and(|p| self.last.0 > p.0) {
+            self.points.push(self.last);
+        }
+        self.points.push((t, v));
+        self.last = (t, v);
+    }
+    fn flush(&mut self) {
+        if self.points.last().is_some_and(|p| self.last.0 > p.0) {
+            self.points.push(self.last);
+        }
+    }
+    pub fn value(&self) -> f64 {
+        self.last.1
+    }
+}
+
+/// State of the current automation pass.
+#[derive(Clone, Debug, Default)]
+pub struct Recorder {
+    /// Sequence being recorded (None = no pass running).
+    pub seq: Option<ItemId>,
+    pub start: Tick,
+    pub gestures: Vec<Gesture>,
+}
+
+impl Recorder {
+    pub fn active(&self) -> bool {
+        self.seq.is_some()
+    }
+    fn find(&mut self, strip: TrackId, lane: &str) -> Option<&mut Gesture> {
+        self.gestures.iter_mut().find(|g| g.strip == strip && g.lane == lane)
+    }
+}
+
+/// Lanes a Write pass records on every strip.
+fn write_lanes(strip: TrackId) -> &'static [&'static str] {
+    if strip == MASTER_STRIP { &[LANE_VOLUME] } else { &[LANE_VOLUME, LANE_PAN, LANE_MUTE] }
+}
+
+/// The lane value as automation plays it (no live overrides).
+fn underlying(tr: &Track, lane: &str, t: Tick) -> f64 {
+    let v = tr.lane_value(lane, t);
+    if lane_info(lane).is_some_and(|i| i.hold) {
+        // hold lanes: last keyframe at or before t
+        if let Some(p) = tr.lane(lane).filter(|p| p.is_animated() && tr.mixer.mode.reads()) {
+            let i = p.keyframes.partition_point(|k| k.time <= t);
+            return p.keyframes[i.saturating_sub(1)].value.as_f64().unwrap_or(v);
+        }
+    }
+    v
+}
+
+fn clamp_lane(lane: &str, v: f64) -> f64 {
+    match lane_info(lane) {
+        Some(i) if i.hold => {
+            if v >= 0.5 {
+                1.0
+            } else {
+                0.0
+            }
+        }
+        Some(i) => v.clamp(i.min, i.max),
+        None => v,
+    }
+}
+
+fn seq_of(s: &Session, id: ItemId) -> Result<&Sequence> {
+    s.project.sequence(id).ok_or(EngineError::NoSequence)
+}
+
+/// Start an automation pass at `t` (playback start).
+pub fn record_start(s: &mut Session, t: Tick) -> Result<Value> {
+    let seq_id = s.state.active_sequence.ok_or(EngineError::NoSequence)?;
+    let seq = seq_of(s, seq_id)?;
+    let mut gestures = Vec::new();
+    for id in seq.strip_ids() {
+        let Some(tr) = seq.strip(id) else { continue };
+        if tr.mixer.mode != AutomationMode::Write {
+            continue;
+        }
+        for lane in write_lanes(id) {
+            let v = underlying(&tr, lane, t);
+            let mut g = Gesture::new(id, lane, AutomationMode::Write, t, v);
+            g.touching = false;
+            gestures.push(g);
+        }
+    }
+    s.previews.live.clear_all();
+    for g in &gestures {
+        s.previews.live.hold(g.strip, &g.lane, g.value());
+    }
+    let n = gestures.len();
+    s.mixrec = Recorder { seq: Some(seq_id), start: t, gestures };
+    Ok(json!({"recording": true, "writing": n}))
+}
+
+/// A control moved to `v` at `t`.
+pub fn touch(s: &mut Session, strip: TrackId, lane: &str, v: f64, t: Tick) -> Result<Value> {
+    let v = clamp_lane(lane, v);
+    let seq_id = s.mixrec.seq.or(s.state.active_sequence).ok_or(EngineError::NoSequence)?;
+    let mode = seq_of(s, seq_id)?.strip(strip).ok_or_else(|| bad("mixer.touch", "no such strip"))?.mixer.mode;
+    s.previews.live.hold(strip, lane, v);
+    if !s.mixrec.active() || !mode.writes() {
+        return Ok(json!({"recording": false, "value": v}));
+    }
+    match s.mixrec.find(strip, lane) {
+        Some(g) => {
+            if !g.touching {
+                if g.mode == AutomationMode::Touch {
+                    // a new touch after a release: the old ramp is overwritten from here
+                    g.released = None;
+                } else if t > g.last.0 {
+                    // Write / Latch held the last value until this touch
+                    g.last.0 = (t - HOLD_EPS).max(g.last.0);
+                }
+            }
+            g.touching = true;
+            g.push(t, v);
+        }
+        None => s.mixrec.gestures.push(Gesture::new(strip, lane, mode, t, v)),
+    }
+    Ok(json!({"recording": true, "value": v}))
+}
+
+/// A control let go at `t`.
+pub fn release(s: &mut Session, strip: TrackId, lane: &str, t: Tick) -> Result<Value> {
+    let automatch = Tick::from_seconds_f64(s.prefs.audio.automatch_time);
+    if s.mixrec.active() {
+        if let Some(g) = s.mixrec.find(strip, lane) {
+            g.touching = false;
+            g.push(t, g.value());
+            if g.mode == AutomationMode::Touch {
+                g.released = Some(t);
+                s.previews.live.release(strip, lane, t, automatch);
+            }
+            // Latch / Write keep holding the last value until playback stops.
+            return Ok(json!({"recording": true}));
+        }
+        s.previews.live.clear(strip, lane);
+        return Ok(json!({"recording": false}));
+    }
+    // no pass: commit the held value once
+    let held = s.previews.live.get(strip, lane);
+    s.previews.live.clear(strip, lane);
+    match held {
+        Some(o) => {
+            set_value(s, strip, lane, o.value, t)?;
+            Ok(json!({"recording": false, "value": o.value}))
+        }
+        None => Ok(json!({"recording": false})),
+    }
+}
+
+/// End the pass at `t`: write every gesture as keyframes (one undo step).
+pub fn record_stop(s: &mut Session, t_stop: Tick) -> Result<Value> {
+    let rec = std::mem::take(&mut s.mixrec);
+    let Some(seq_id) = rec.seq.filter(|_| !rec.gestures.is_empty()) else {
+        s.previews.live.clear_all();
+        return Ok(json!({"recording": false, "lanes": 0}));
+    };
+    let automatch = Tick::from_seconds_f64(s.prefs.audio.automatch_time);
+    let prefs = s.prefs.audio.clone();
+    let rate = seq_of(s, seq_id)?.settings.sample_rate.max(1) as i64;
+    let eps = Tick::from_units(1, rate).max(Tick(1));
+    let min_interval = if prefs.minimum_time_interval_thinning { Tick(prefs.minimum_time_ms as i64 * TICKS_PER_SECOND / 1000) } else { Tick::ZERO };
+    let mut written = Vec::new();
+    let mut keyframes = 0usize;
+    let result = s.edit("Write Automation", |p, _| {
+        let seq = p.sequence_mut(seq_id).ok_or(EngineError::NoSequence)?;
+        for mut g in rec.gestures {
+            if g.points.is_empty() {
+                continue;
+            }
+            let Some(tr) = seq.strip(g.strip).map(|c| c.into_owned()) else { continue };
+            let hold = lane_info(&g.lane).is_some_and(|i| i.hold);
+            let held = g.value();
+            let end = match g.mode {
+                AutomationMode::Touch => g.released.unwrap_or(t_stop).min(t_stop.max(g.points[0].0)),
+                _ => t_stop,
+            };
+            g.push(end.max(g.last.0), held);
+            g.flush();
+            let mut pts = g.points.clone();
+            if g.mode == AutomationMode::Touch && automatch.0 > 0 && !hold {
+                let back = end + automatch;
+                pts.push((back, underlying(&tr, &g.lane, back)));
+            }
+            let t0 = pts[0].0;
+            let t1 = pts.last().map(|p| p.0).unwrap_or(t0);
+            let tol = if hold {
+                0.0
+            } else if prefs.linear_keyframe_thinning {
+                if g.lane == LANE_PAN { 0.25 } else { 0.05 }
+            } else {
+                0.0
+            };
+            let thinned = thin_points(&pts, tol, min_interval, hold);
+            let before = (t0.0 > 0).then(|| underlying(&tr, &g.lane, t0 - eps));
+            let after = tr.lane(&g.lane).filter(|p| p.keyframes.iter().any(|k| k.time > t1)).map(|_| underlying(&tr, &g.lane, t1 + eps));
+            keyframes += thinned.len();
+            let lane = g.lane.clone();
+            seq.with_strip_mut(g.strip, |tr| {
+                if let Some(param) = tr.lane_mut(&lane) {
+                    write_lane(param, t0, t1, &thinned, before, after, eps, hold);
+                }
+            });
+            written.push(json!({"strip": g.strip.0, "lane": lane, "from": t0.0, "to": t1.0, "keyframes": thinned.len(), "points": pts.len()}));
+        }
+        if prefs.switch_to_touch_after_write {
+            for id in seq.strip_ids() {
+                seq.with_strip_mut(id, |tr| {
+                    if tr.mixer.mode == AutomationMode::Write {
+                        tr.mixer.mode = AutomationMode::Touch;
+                    }
+                });
+            }
+        }
+        Ok(())
+    });
+    s.previews.live.clear_all();
+    s.previews.live.publish_project(s.project.clone());
+    result?;
+    Ok(json!({"recording": false, "lanes": written.len(), "keyframes": keyframes, "written": written}))
+}
+
+// ------------------------------------------------------------------------------------- helpers
+
+fn active_seq(s: &Session) -> Result<&Sequence> {
+    s.active_sequence().ok_or(EngineError::NoSequence)
+}
+
+/// Parse a strip reference: id, "A1", "S1", "Mix", or a strip name.
+pub fn strip_ref(seq: &Sequence, v: &Value) -> Option<TrackId> {
+    if let Some(id) = v.as_u64() {
+        let id = TrackId(id);
+        return seq.strip(id).map(|_| id);
+    }
+    let name = v.as_str()?.trim();
+    if name.eq_ignore_ascii_case("mix") || name.eq_ignore_ascii_case("master") {
+        return Some(MASTER_STRIP);
+    }
+    let idx = |pre: &str| {
+        name.strip_prefix(pre).or_else(|| name.strip_prefix(&pre.to_lowercase())).and_then(|n| n.parse::<usize>().ok()).and_then(|n| n.checked_sub(1))
+    };
+    if let Some(i) = idx("A") {
+        return seq.audio_tracks.get(i).map(|t| t.id);
+    }
+    if let Some(i) = idx("S") {
+        return seq.submix_tracks.get(i).map(|t| t.id);
+    }
+    seq.audio_tracks.iter().chain(&seq.submix_tracks).find(|t| t.name.eq_ignore_ascii_case(name)).map(|t| t.id)
+}
+
+/// Display reference of a strip ("A1", "S2", "Mix").
+pub fn strip_label(seq: &Sequence, id: TrackId) -> String {
+    if id == MASTER_STRIP {
+        return "Mix".into();
+    }
+    if let Some(i) = seq.audio_tracks.iter().position(|t| t.id == id) {
+        return format!("A{}", i + 1);
+    }
+    if let Some(i) = seq.submix_tracks.iter().position(|t| t.id == id) {
+        return format!("S{}", i + 1);
+    }
+    id.0.to_string()
+}
+
+fn strip_p(s: &Session, p: &Value, cmd: &str) -> Result<TrackId> {
+    let seq = active_seq(s)?;
+    let v = p.get("strip").or_else(|| p.get("track")).ok_or_else(|| bad(cmd, "need `strip` (\"A1\", \"S1\", \"Mix\" or an id)"))?;
+    strip_ref(seq, v).ok_or_else(|| bad(cmd, format!("no strip {v}")))
+}
+
+fn lane_p(s: &Session, p: &Value, strip: TrackId, cmd: &str) -> Result<String> {
+    let lane = str_p(p, "lane").unwrap_or(LANE_VOLUME).to_string();
+    let seq = active_seq(s)?;
+    let tr = seq.strip(strip).ok_or_else(|| bad(cmd, "no such strip"))?;
+    let ok = match parse_fx_lane(&lane) {
+        Some((slot, param)) => tr.effects.get(slot).and_then(|e| e.param(param)).is_some_and(|p| p.value.as_f64().is_some()),
+        None => lane_info(&lane).is_some() && (parse_send_lane(&lane).is_none_or(|i| i < tr.mixer.sends.len())),
+    };
+    if !ok {
+        return Err(bad(cmd, format!("no lane `{lane}` on this strip (volume, pan, mute, send.<i>.level, fx.<slot>.<param>)")));
+    }
+    if strip == MASTER_STRIP && (lane == LANE_PAN || lane == LANE_MUTE || parse_send_lane(&lane).is_some()) {
+        return Err(bad(cmd, "the Mix track has volume and effect lanes only"));
+    }
+    Ok(lane)
+}
+
+fn value_p(p: &Value, lane: &str, cmd: &str) -> Result<f64> {
+    let v = p.get("value").ok_or_else(|| bad(cmd, "need `value`"))?;
+    let x = v.as_f64().or_else(|| v.as_bool().map(|b| if b { 1.0 } else { 0.0 })).ok_or_else(|| bad(cmd, "`value` must be a number"))?;
+    Ok(clamp_lane(lane, x))
+}
+
+/// Set a control outside a recording pass: the static value, or a keyframe at `t` when the lane
+/// is automated and the strip reads automation.
+pub fn set_value(s: &mut Session, strip: TrackId, lane: &str, v: f64, t: Tick) -> Result<()> {
+    let lane = lane.to_string();
+    let hold = lane_info(&lane).is_some_and(|i| i.hold);
+    s.edit_sequence("Track Mixer Adjust", move |q, _, _| {
+        q.with_strip_mut(strip, |tr| {
+            let animated = tr.lane(&lane).is_some_and(Param::is_animated) && tr.mixer.mode.reads();
+            if animated {
+                if let Some(p) = tr.lane_mut(&lane) {
+                    set_keyframe(p, t, v, hold);
+                }
+            } else {
+                tr.set_lane_static(&lane, v);
+            }
+        })
+        .ok_or_else(|| EngineError::Other("no such strip".into()))
+    })
+}
+
+fn set_keyframe(p: &mut Param, t: Tick, v: f64, hold: bool) {
+    p.put_keyframe(t, ParamValue::Float(v));
+    if hold {
+        for k in p.keyframes.iter_mut() {
+            k.interp = filmcraft_project::Interpolation::Hold;
+        }
+    }
+}
+
+fn mode_p(p: &Value) -> Option<AutomationMode> {
+    str_p(p, "mode").and_then(AutomationMode::from_name)
+}
+
+fn channels_name(c: AudioChannels) -> &'static str {
+    match c {
+        AudioChannels::Mono => "Mono",
+        AudioChannels::Stereo => "Stereo",
+        AudioChannels::Surround51 => "5.1",
+        AudioChannels::Adaptive => "Adaptive",
+    }
+}
+
+fn channels_from(s: &str) -> Option<AudioChannels> {
+    match s.to_ascii_lowercase().as_str() {
+        "mono" => Some(AudioChannels::Mono),
+        "stereo" => Some(AudioChannels::Stereo),
+        "5.1" | "surround51" => Some(AudioChannels::Surround51),
+        "adaptive" => Some(AudioChannels::Adaptive),
+        _ => None,
+    }
+}
+
+/// JSON view of one strip at time `t`.
+pub fn strip_json(s: &Session, seq: &Sequence, id: TrackId, t: Tick) -> Value {
+    let Some(tr) = seq.strip(id) else { return Value::Null };
+    let live = &s.previews.live;
+    let shown = |lane: &str| live.get(id, lane).map(|o| o.value).unwrap_or_else(|| underlying(&tr, lane, t));
+    let lanes: serde_json::Map<String, Value> = tr
+        .automated_lanes()
+        .into_iter()
+        .map(|k| {
+            let kf: Vec<Value> = tr.lane_keyframes(&k).iter().map(|kf| json!([kf.time.0, kf.value.as_f64()])).collect();
+            (k, Value::Array(kf))
+        })
+        .collect();
+    let kind = if id == MASTER_STRIP {
+        "mix"
+    } else if seq.submix_tracks.iter().any(|t| t.id == id) {
+        "submix"
+    } else {
+        "audio"
+    };
+    json!({
+        "id": id.0,
+        "ref": strip_label(seq, id),
+        "name": tr.name,
+        "kind": kind,
+        "channels": channels_name(tr.channels),
+        "mode": tr.mixer.mode.label(),
+        "volumeDb": tr.volume_db,
+        "pan": tr.pan,
+        "muted": tr.muted,
+        "solo": tr.solo,
+        "recordArm": tr.mixer.record_arm,
+        "soloSafe": tr.mixer.solo_safe,
+        "inputMap": tr.mixer.input_map.label(),
+        "output": tr.mixer.output.map(|o| strip_label(seq, o)).unwrap_or_else(|| if id == MASTER_STRIP { String::new() } else { "Mix".into() }),
+        "inserts": tr.effects.iter().enumerate().map(|(i, e)| json!({"slot": i, "effect": e.effect, "name": e.def().map(|d| d.name).unwrap_or(""), "enabled": e.enabled, "postFader": e.post_fader})).collect::<Vec<_>>(),
+        "sends": tr.mixer.sends.iter().enumerate().map(|(i, sd)| json!({"send": i, "target": strip_label(seq, sd.target), "levelDb": sd.level_db, "pan": sd.pan, "preFader": sd.pre_fader, "muted": sd.muted})).collect::<Vec<_>>(),
+        "at": {"time": t.0, "volumeDb": shown(LANE_VOLUME), "pan": shown(LANE_PAN), "mute": shown(LANE_MUTE) >= 0.5},
+        "lanes": lanes,
+    })
+}
+
+fn inspect(s: &mut Session, p: &Value) -> Result<Value> {
+    let t = time_p(s, p, "").unwrap_or(s.playhead());
+    let seq = active_seq(s)?;
+    let strips: Vec<Value> = seq.strip_ids().into_iter().map(|id| strip_json(s, seq, id, t)).collect();
+    Ok(json!({
+        "strips": strips,
+        "recording": s.mixrec.active(),
+        "gestures": s.mixrec.gestures.iter().map(|g| json!({"strip": strip_label(seq, g.strip), "lane": g.lane, "mode": g.mode.label(), "touching": g.touching, "points": g.points.len(), "value": g.value()})).collect::<Vec<_>>(),
+        "latencySamples": filmcraft_render::mixer::graph_latency(seq),
+        "automatchTime": s.prefs.audio.automatch_time,
+    }))
+}
+
+fn set_strip(s: &mut Session, p: &Value) -> Result<Value> {
+    let id = strip_p(s, p, "mixer.setStrip")?;
+    let seq = active_seq(s)?;
+    let output = match p.get("output") {
+        None => None,
+        Some(Value::Null) => Some(None),
+        Some(v) => {
+            let o = strip_ref(seq, v).ok_or_else(|| bad("mixer.setStrip", format!("no output {v}")))?;
+            if o == MASTER_STRIP {
+                Some(None)
+            } else if o == id || !seq.submix_tracks.iter().any(|t| t.id == o) {
+                return Err(bad("mixer.setStrip", "output must be the Mix or a submix"));
+            } else if seq
+                .submix_tracks
+                .iter()
+                .position(|t| t.id == id)
+                .is_some_and(|me| seq.submix_tracks.iter().position(|t| t.id == o).is_some_and(|it| it <= me))
+            {
+                return Err(bad("mixer.setStrip", "a submix can only feed a submix after it (no feedback)"));
+            } else {
+                Some(Some(o))
+            }
+        }
+    };
+    let p = p.clone();
+    s.edit_sequence("Track Mixer Settings", move |q, _, _| {
+        q.with_strip_mut(id, |t| {
+            if let Some(v) = str_p(&p, "name") {
+                t.name = v.to_string();
+            }
+            if let Some(v) = f64_p(&p, "volumeDb") {
+                t.volume_db = v.clamp(FADER_MIN_DB, FADER_MAX_DB);
+            }
+            if let Some(v) = f64_p(&p, "pan") {
+                t.pan = v.clamp(-100.0, 100.0);
+            }
+            if let Some(v) = bool_p(&p, "muted") {
+                t.muted = v;
+            }
+            if let Some(v) = bool_p(&p, "solo") {
+                t.solo = v;
+            }
+            if let Some(v) = bool_p(&p, "recordArm") {
+                t.mixer.record_arm = v;
+            }
+            if let Some(v) = bool_p(&p, "soloSafe") {
+                t.mixer.solo_safe = v;
+            }
+            if let Some(m) = mode_p(&p) {
+                t.mixer.mode = m;
+            }
+            if let Some(m) = str_p(&p, "inputMap").and_then(InputMap::from_name) {
+                t.mixer.input_map = m;
+            }
+            if let Some(c) = str_p(&p, "channels").and_then(channels_from) {
+                t.channels = c;
+            }
+            if let Some(o) = output {
+                t.mixer.output = o;
+            }
+        })
+        .ok_or_else(|| EngineError::Other("no such strip".into()))
+    })?;
+    let seq = active_seq(s)?;
+    Ok(strip_json(s, seq, id, s.playhead()))
+}
+
+fn add_submix(s: &mut Session, p: &Value) -> Result<Value> {
+    let name = str_p(p, "name").map(str::to_string);
+    let channels = str_p(p, "channels").and_then(channels_from).unwrap_or(AudioChannels::Stereo);
+    let seq_id = s.state.active_sequence.ok_or(EngineError::NoSequence)?;
+    let id = s.edit("Add Submix Track", |pr, _| {
+        let id = TrackId(pr.alloc_id());
+        let seq = pr.sequence_mut(seq_id).ok_or(EngineError::NoSequence)?;
+        let n = seq.submix_tracks.len() + 1;
+        let mut t = Track::new(id, TrackKind::Audio, name.unwrap_or_else(|| format!("Submix {n}")));
+        t.channels = channels;
+        seq.submix_tracks.push(t);
+        Ok(id)
+    })?;
+    let seq = active_seq(s)?;
+    Ok(json!({"id": id.0, "ref": strip_label(seq, id)}))
+}
+
+fn delete_submix(s: &mut Session, p: &Value) -> Result<Value> {
+    let id = strip_p(s, p, "mixer.deleteSubmix")?;
+    if !active_seq(s)?.submix_tracks.iter().any(|t| t.id == id) {
+        return Err(bad("mixer.deleteSubmix", "not a submix"));
+    }
+    s.edit_sequence("Delete Submix Track", move |q, _, _| {
+        q.submix_tracks.retain(|t| t.id != id);
+        // re-route everything that fed it to the Mix and drop sends to it
+        for sid in q.strip_ids() {
+            q.with_strip_mut(sid, |t| {
+                if t.mixer.output == Some(id) {
+                    t.mixer.output = None;
+                }
+                while let Some(i) = t.mixer.sends.iter().position(|sd| sd.target == id) {
+                    t.remove_send(i);
+                }
+            });
+        }
+        Ok(())
+    })?;
+    Ok(Value::Null)
+}
+
+fn slot_p(p: &Value, cmd: &str) -> Result<usize> {
+    u64_p(p, "slot").map(|v| v as usize).ok_or_else(|| bad(cmd, "need `slot` (0-based)"))
+}
+
+fn add_insert(s: &mut Session, p: &Value) -> Result<Value> {
+    let id = strip_p(s, p, "mixer.addInsert")?;
+    let eid = str_p(p, "effect").ok_or_else(|| bad("mixer.addInsert", "need `effect` (an audio effect id)"))?;
+    let def = find_effect(eid)
+        .filter(|d| d.kind == filmcraft_project::EffectKind::Audio && !d.intrinsic)
+        .ok_or_else(|| bad("mixer.addInsert", format!("`{eid}` is not an audio effect")))?;
+    let mut inst = def.instance();
+    inst.post_fader = bool_p(p, "postFader").unwrap_or(false);
+    let slot = u64_p(p, "slot").map(|v| v as usize);
+    let n = active_seq(s)?.strip(id).map(|t| t.effects.len()).unwrap_or(0);
+    if n >= pm::MAX_INSERTS {
+        return Err(bad("mixer.addInsert", format!("all {} effect slots are in use", pm::MAX_INSERTS)));
+    }
+    let at = slot.unwrap_or(n).min(n);
+    s.edit_sequence(&format!("Add Track Effect {}", def.name), move |q, _, _| {
+        q.with_strip_mut(id, |t| t.effects.insert(at, inst)).ok_or_else(|| EngineError::Other("no such strip".into()))
+    })?;
+    Ok(json!({"slot": at}))
+}
+
+fn remove_insert(s: &mut Session, p: &Value) -> Result<Value> {
+    let id = strip_p(s, p, "mixer.removeInsert")?;
+    let slot = slot_p(p, "mixer.removeInsert")?;
+    let ok = s.edit_sequence("Remove Track Effect", move |q, _, _| Ok(q.with_strip_mut(id, |t| t.remove_insert(slot)).unwrap_or(false)))?;
+    if !ok {
+        return Err(bad("mixer.removeInsert", "no effect in that slot"));
+    }
+    Ok(Value::Null)
+}
+
+fn set_insert(s: &mut Session, p: &Value) -> Result<Value> {
+    let id = strip_p(s, p, "mixer.setInsert")?;
+    let slot = slot_p(p, "mixer.setInsert")?;
+    let p = p.clone();
+    s.edit_sequence("Track Effect Settings", move |q, _, _| {
+        q.with_strip_mut(id, |t| -> Result<()> {
+            let e = t.effects.get_mut(slot).ok_or_else(|| bad("mixer.setInsert", "no effect in that slot"))?;
+            if let Some(v) = bool_p(&p, "enabled") {
+                e.enabled = v;
+            }
+            if let Some(v) = bool_p(&p, "postFader") {
+                e.post_fader = v;
+            }
+            if let Some(obj) = p.get("params").and_then(Value::as_object) {
+                for (k, v) in obj {
+                    let par = e.param_mut(k).ok_or_else(|| bad("mixer.setInsert", format!("no parameter `{k}`")))?;
+                    par.value = match (&par.value, v) {
+                        (ParamValue::Bool(_), Value::Bool(b)) => ParamValue::Bool(*b),
+                        (ParamValue::Choice(_), v) => ParamValue::Choice(v.as_u64().unwrap_or(0) as u32),
+                        (_, v) => ParamValue::Float(v.as_f64().ok_or_else(|| bad("mixer.setInsert", format!("`{k}` needs a number")))?),
+                    };
+                }
+            }
+            Ok(())
+        })
+        .ok_or_else(|| EngineError::Other("no such strip".into()))?
+    })?;
+    Ok(Value::Null)
+}
+
+fn send_target(s: &Session, p: &Value, id: TrackId, cmd: &str) -> Result<TrackId> {
+    let seq = active_seq(s)?;
+    let v = p.get("target").ok_or_else(|| bad(cmd, "need `target` (a submix)"))?;
+    let t = strip_ref(seq, v).filter(|t| seq.submix_tracks.iter().any(|x| x.id == *t)).ok_or_else(|| bad(cmd, "`target` must be a submix"))?;
+    let pos = |x: TrackId| seq.submix_tracks.iter().position(|y| y.id == x);
+    if t == id || pos(id).is_some_and(|me| pos(t).is_some_and(|it| it <= me)) {
+        return Err(bad(cmd, "a submix can only send to a submix after it (no feedback)"));
+    }
+    Ok(t)
+}
+
+fn add_send(s: &mut Session, p: &Value) -> Result<Value> {
+    let id = strip_p(s, p, "mixer.addSend")?;
+    if id == MASTER_STRIP {
+        return Err(bad("mixer.addSend", "the Mix track has no sends"));
+    }
+    let target = send_target(s, p, id, "mixer.addSend")?;
+    let mut snd = TrackSend::new(target);
+    snd.level_db = f64_p(p, "levelDb").unwrap_or(0.0).clamp(FADER_MIN_DB, FADER_MAX_DB);
+    snd.pre_fader = bool_p(p, "preFader").unwrap_or(false);
+    snd.pan = f64_p(p, "pan").unwrap_or(0.0).clamp(-100.0, 100.0);
+    if active_seq(s)?.strip(id).is_some_and(|t| t.mixer.sends.len() >= pm::MAX_SENDS) {
+        return Err(bad("mixer.addSend", format!("all {} send slots are in use", pm::MAX_SENDS)));
+    }
+    let i = s.edit_sequence("Add Send", move |q, _, _| {
+        q.with_strip_mut(id, |t| {
+            t.mixer.sends.push(snd);
+            t.mixer.sends.len() - 1
+        })
+        .ok_or_else(|| EngineError::Other("no such strip".into()))
+    })?;
+    Ok(json!({"send": i}))
+}
+
+fn set_send(s: &mut Session, p: &Value) -> Result<Value> {
+    let id = strip_p(s, p, "mixer.setSend")?;
+    let i = u64_p(p, "send").ok_or_else(|| bad("mixer.setSend", "need `send` (0-based)"))? as usize;
+    let target = if p.get("target").is_some() { Some(send_target(s, p, id, "mixer.setSend")?) } else { None };
+    let p = p.clone();
+    s.edit_sequence("Send Settings", move |q, _, _| {
+        q.with_strip_mut(id, |t| -> Result<()> {
+            let sd = t.mixer.sends.get_mut(i).ok_or_else(|| bad("mixer.setSend", "no such send"))?;
+            if let Some(v) = f64_p(&p, "levelDb") {
+                sd.level_db = v.clamp(FADER_MIN_DB, FADER_MAX_DB);
+            }
+            if let Some(v) = f64_p(&p, "pan") {
+                sd.pan = v.clamp(-100.0, 100.0);
+            }
+            if let Some(v) = bool_p(&p, "preFader") {
+                sd.pre_fader = v;
+            }
+            if let Some(v) = bool_p(&p, "muted") {
+                sd.muted = v;
+            }
+            if let Some(t) = target {
+                sd.target = t;
+            }
+            Ok(())
+        })
+        .ok_or_else(|| EngineError::Other("no such strip".into()))?
+    })?;
+    Ok(Value::Null)
+}
+
+fn remove_send(s: &mut Session, p: &Value) -> Result<Value> {
+    let id = strip_p(s, p, "mixer.removeSend")?;
+    let i = u64_p(p, "send").ok_or_else(|| bad("mixer.removeSend", "need `send` (0-based)"))? as usize;
+    let ok = s.edit_sequence("Remove Send", move |q, _, _| Ok(q.with_strip_mut(id, |t| t.remove_send(i)).unwrap_or(false)))?;
+    if !ok {
+        return Err(bad("mixer.removeSend", "no such send"));
+    }
+    Ok(Value::Null)
+}
+
+fn set_kf(s: &mut Session, p: &Value) -> Result<Value> {
+    let id = strip_p(s, p, "mixer.setKeyframe")?;
+    let lane = lane_p(s, p, id, "mixer.setKeyframe")?;
+    let t = time_p(s, p, "").unwrap_or(s.playhead());
+    let v = value_p(p, &lane, "mixer.setKeyframe")?;
+    let hold = lane_info(&lane).is_some_and(|i| i.hold);
+    s.edit_sequence("Add Track Keyframe", move |q, _, _| {
+        q.with_strip_mut(id, |tr| {
+            if let Some(par) = tr.lane_mut(&lane) {
+                if par.keyframes.is_empty() {
+                    // the first keyframe keeps the current value everywhere else
+                    let cur = par.value.as_f64().unwrap_or(v);
+                    par.value = ParamValue::Float(cur);
+                }
+                set_keyframe(par, t, v, hold);
+            }
+        })
+        .ok_or_else(|| EngineError::Other("no such strip".into()))
+    })?;
+    Ok(json!({"time": t.0, "value": v}))
+}
+
+fn delete_kf(s: &mut Session, p: &Value) -> Result<Value> {
+    let id = strip_p(s, p, "mixer.deleteKeyframe")?;
+    let lane = lane_p(s, p, id, "mixer.deleteKeyframe")?;
+    let t = time_p(s, p, "").ok_or_else(|| bad("mixer.deleteKeyframe", "need `time`"))?;
+    let ok = s.edit_sequence("Delete Track Keyframe", move |q, _, _| {
+        Ok(q.with_strip_mut(id, |tr| tr.lane_mut(&lane).is_some_and(|par| par.remove_keyframe_at(t))).unwrap_or(false))
+    })?;
+    if !ok {
+        return Err(bad("mixer.deleteKeyframe", "no keyframe at that time"));
+    }
+    Ok(Value::Null)
+}
+
+fn move_kf(s: &mut Session, p: &Value) -> Result<Value> {
+    let id = strip_p(s, p, "mixer.moveKeyframe")?;
+    let lane = lane_p(s, p, id, "mixer.moveKeyframe")?;
+    let t = time_p(s, p, "").ok_or_else(|| bad("mixer.moveKeyframe", "need `time` (the keyframe)"))?;
+    let nt = time_p(s, p, "new");
+    let nv = p.get("value").map(|_| value_p(p, &lane, "mixer.moveKeyframe")).transpose()?;
+    let ok = s.edit_sequence("Move Track Keyframe", move |q, _, _| {
+        Ok(q.with_strip_mut(id, |tr| {
+            let Some(par) = tr.lane_mut(&lane) else { return false };
+            let Ok(i) = par.keyframes.binary_search_by_key(&t, |k| k.time) else { return false };
+            let mut k = par.keyframes.remove(i);
+            if let Some(nt) = nt {
+                // keep keyframe order: clamp between the neighbours
+                let lo = i.checked_sub(1).map(|j| par.keyframes[j].time + Tick(1)).unwrap_or(Tick::ZERO);
+                let hi = par.keyframes.get(i).map(|n| n.time - Tick(1)).unwrap_or(Tick(i64::MAX));
+                k.time = nt.clamp(lo, hi);
+            }
+            if let Some(v) = nv {
+                k.value = ParamValue::Float(v);
+            }
+            let j = par.keyframes.partition_point(|x| x.time < k.time);
+            par.keyframes.insert(j, k);
+            true
+        })
+        .unwrap_or(false))
+    })?;
+    if !ok {
+        return Err(bad("mixer.moveKeyframe", "no keyframe at that time"));
+    }
+    Ok(Value::Null)
+}
+
+fn clear_lane(s: &mut Session, p: &Value) -> Result<Value> {
+    let id = strip_p(s, p, "mixer.clearLane")?;
+    let lane = lane_p(s, p, id, "mixer.clearLane")?;
+    let t = s.playhead();
+    s.edit_sequence("Clear Track Keyframes", move |q, _, _| {
+        q.with_strip_mut(id, |tr| {
+            let v = tr.lane_value(&lane, t);
+            if let Some(par) = tr.lane_mut(&lane) {
+                par.keyframes.clear();
+            }
+            tr.set_lane_static(&lane, v);
+            if parse_fx_lane(&lane).is_none() {
+                tr.mixer.lanes.remove(&lane);
+            }
+        })
+        .ok_or_else(|| EngineError::Other("no such strip".into()))
+    })?;
+    Ok(Value::Null)
+}
+
+fn write_automation(s: &mut Session, p: &Value) -> Result<Value> {
+    let id = strip_p(s, p, "mixer.writeAutomation")?;
+    let lane = lane_p(s, p, id, "mixer.writeAutomation")?;
+    let pts: Vec<(Tick, f64)> = p
+        .get("points")
+        .and_then(Value::as_array)
+        .ok_or_else(|| bad("mixer.writeAutomation", "need `points`: [[ticks, value], …]"))?
+        .iter()
+        .filter_map(|v| Some((Tick(v.get(0)?.as_i64()?), clamp_lane(&lane, v.get(1)?.as_f64()?))))
+        .collect();
+    if pts.is_empty() {
+        return Err(bad("mixer.writeAutomation", "no points"));
+    }
+    let hold = lane_info(&lane).is_some_and(|i| i.hold);
+    let tol = f64_p(p, "tolerance").unwrap_or(if hold { 0.0 } else { 0.05 });
+    let thinned = thin_points(&pts, tol, Tick::ZERO, hold);
+    let (t0, t1) = (thinned[0].0, thinned[thinned.len() - 1].0);
+    let rate = active_seq(s)?.settings.sample_rate.max(1) as i64;
+    let eps = Tick::from_units(1, rate).max(Tick(1));
+    let n = thinned.len();
+    s.edit_sequence("Write Automation", move |q, _, _| {
+        q.with_strip_mut(id, |tr| {
+            let before = (t0.0 > 0).then(|| underlying(tr, &lane, t0 - eps));
+            let after = tr.lane(&lane).filter(|p| p.keyframes.iter().any(|k| k.time > t1)).map(|_| underlying(tr, &lane, t1 + eps));
+            if let Some(par) = tr.lane_mut(&lane) {
+                write_lane(par, t0, t1, &thinned, before, after, eps, hold);
+            }
+        })
+        .ok_or_else(|| EngineError::Other("no such strip".into()))
+    })?;
+    Ok(json!({"keyframes": n, "points": pts.len()}))
+}
+
+/// Audio Clip Mixer: set the clip's Volume level / Panner balance (or any scalar clip effect
+/// parameter) at the playhead. With `keyframe` (or when already animated) it writes a keyframe at the
+/// playhead; a drag (same clip and parameter, no other edit between) is one undo step.
+fn clip_set(s: &mut Session, p: &Value) -> Result<Value> {
+    let clip = filmcraft_project::ClipId(u64_p(p, "clip").ok_or_else(|| bad("clipMixer.set", "need `clip`"))?);
+    let effect = str_p(p, "effect").unwrap_or("volume").to_string();
+    let param = str_p(p, "param").unwrap_or("level").to_string();
+    let v = f64_p(p, "value").ok_or_else(|| bad("clipMixer.set", "need `value`"))?;
+    let kf = bool_p(p, "keyframe").unwrap_or(false);
+    let t = time_p(s, p, "").unwrap_or(s.playhead());
+    let seq_id = s.state.active_sequence.ok_or(EngineError::NoSequence)?;
+    let key = format!("clipMixer:{}:{effect}:{param}", clip.0);
+    if bool_p(p, "begin").unwrap_or(false) {
+        s.history.merge_key = None;
+    }
+    s.edit_merged("Audio Clip Mixer", &key, |pr, _| {
+        let seq = pr.sequence_mut(seq_id).ok_or(EngineError::NoSequence)?;
+        let (_, it) = seq.find_item_mut(clip).ok_or_else(|| bad("clipMixer.set", "no such clip"))?;
+        let mt = it.source_time_at(t.clamp(it.start, it.end()));
+        let e = it.effect_mut(&effect).ok_or_else(|| bad("clipMixer.set", format!("the clip has no `{effect}` effect")))?;
+        let par = e.param_mut(&param).ok_or_else(|| bad("clipMixer.set", format!("no parameter `{param}`")))?;
+        let v = if param == "level" { v.clamp(FADER_MIN_DB, FADER_MAX_DB) } else { v.clamp(-100.0, 100.0) };
+        if kf || par.is_animated() {
+            par.put_keyframe(mt, ParamValue::Float(v));
+        } else {
+            par.value = ParamValue::Float(v);
+        }
+        Ok(())
+    })?;
+    Ok(Value::Null)
+}
+
+// ------------------------------------------------------------------------------------- audio gain
+
+/// Peak (dBFS, before clip gain) of each selected audio clip's source range.
+fn clip_peaks(s: &Session, clips: &[filmcraft_project::ClipId]) -> Vec<(filmcraft_project::ClipId, f64)> {
+    let Some(seq) = s.active_sequence() else { return Vec::new() };
+    let sr = seq.settings.sample_rate.max(1);
+    let provider = s.media.provider(s.project.clone(), s.services.clone());
+    let mut out = Vec::new();
+    for t in &seq.audio_tracks {
+        for it in t.items.iter().filter(|i| clips.contains(&i.id)) {
+            let Some(src) = filmcraft_render::SourceProvider::source(&provider, it.item) else { continue };
+            if !src.info().has_audio() {
+                continue;
+            }
+            let s0 = it.source_in.to_units_floor(sr as i64);
+            let len = ((it.duration.to_units_floor(sr as i64) as f64) * it.speed.abs().max(1e-6)).ceil() as i64;
+            let mut peak = 0f32;
+            let mut pos = s0;
+            while pos < s0 + len {
+                let n = (s0 + len - pos).min(sr as i64) as usize;
+                if let Ok(b) = src.audio(pos, n, sr) {
+                    peak = b.peaks().into_iter().fold(peak, f32::max);
+                }
+                pos += n as i64;
+            }
+            out.push((it.id, 20.0 * (peak.max(1e-9) as f64).log10()));
+        }
+    }
+    out
+}
+
+fn gain_targets(s: &Session, p: &Value) -> Vec<filmcraft_project::ClipId> {
+    let sel: Vec<filmcraft_project::ClipId> = match p.get("clips").and_then(Value::as_array) {
+        Some(a) => a.iter().filter_map(|v| v.as_u64().map(filmcraft_project::ClipId)).collect(),
+        None => s.state.selection.clone(),
+    };
+    crate::commands::with_links(s, &sel)
+}
+
+/// `clip.audioPeak`: the peak amplitude of the selection (with its current clip gain), as the Audio
+/// Gain dialog shows it.
+pub fn audio_peak(s: &mut Session, p: &Value) -> Result<Value> {
+    let clips = gain_targets(s, p);
+    let seq = active_seq(s)?;
+    let gain = |c: filmcraft_project::ClipId| seq.find_item(c).map(|(_, i)| i.gain_db).unwrap_or(0.0);
+    let peaks = clip_peaks(s, &clips);
+    let max = peaks.iter().map(|(c, pk)| pk + gain(*c)).fold(f64::NEG_INFINITY, f64::max);
+    Ok(json!({
+        "peakDb": if max.is_finite() { json!(max) } else { Value::Null },
+        "clips": peaks.iter().map(|(c, pk)| json!({"clip": c.0, "sourcePeakDb": pk, "gainDb": gain(*c)})).collect::<Vec<_>>(),
+    }))
+}
+
+/// `clip.audioGain`: Set Gain to / Adjust Gain by / Normalize Max Peak to / Normalize All Peaks to.
+pub fn audio_gain(s: &mut Session, p: &Value) -> Result<Value> {
+    let db = f64_p(p, "db").unwrap_or(0.0);
+    let mode = match str_p(p, "mode") {
+        Some(m) => m.to_string(),
+        None => if bool_p(p, "relative").unwrap_or(true) { "adjust" } else { "set" }.to_string(),
+    };
+    let clips = gain_targets(s, p);
+    let new_gain: Vec<(filmcraft_project::ClipId, f64)> = match mode.as_str() {
+        "set" => clips.iter().map(|c| (*c, db)).collect(),
+        "adjust" => {
+            let seq = active_seq(s)?;
+            clips.iter().filter_map(|c| seq.find_item(*c).map(|(_, i)| (*c, i.gain_db + db))).collect()
+        }
+        "normalizeMax" | "normalizeAll" => {
+            let peaks = clip_peaks(s, &clips);
+            if peaks.is_empty() {
+                return Err(bad("clip.audioGain", "no audio clips with audio in the selection"));
+            }
+            let seq = active_seq(s)?;
+            let gain = |c: filmcraft_project::ClipId| seq.find_item(c).map(|(_, i)| i.gain_db).unwrap_or(0.0);
+            if mode == "normalizeAll" {
+                peaks.iter().map(|(c, pk)| (*c, db - pk)).collect()
+            } else {
+                let loudest = peaks.iter().map(|(c, pk)| pk + gain(*c)).fold(f64::NEG_INFINITY, f64::max);
+                let delta = db - loudest;
+                peaks.iter().map(|(c, _)| (*c, gain(*c) + delta)).collect()
+            }
+        }
+        m => return Err(bad("clip.audioGain", format!("unknown mode `{m}` (set, adjust, normalizeMax, normalizeAll)"))),
+    };
+    let n = new_gain.len();
+    let applied = new_gain.clone();
+    s.edit_sequence("Audio Gain", move |q, _, _| {
+        for t in q.audio_tracks.iter_mut() {
+            for i in t.items.iter_mut() {
+                if let Some((_, g)) = new_gain.iter().find(|(c, _)| *c == i.id) {
+                    i.gain_db = g.clamp(-96.0, 96.0);
+                }
+            }
+        }
+        Ok(())
+    })?;
+    Ok(json!({"mode": mode, "clips": n, "gainDb": applied.iter().map(|(c, g)| json!({"clip": c.0, "gainDb": g})).collect::<Vec<_>>()}))
+}
+
+/// Effects panel ▸ Set Selected as Default Transition (video or audio, from the effect's kind).
+fn set_default_transition(s: &mut Session, p: &Value) -> Result<Value> {
+    let id = str_p(p, "effect").ok_or_else(|| bad("effects.setDefaultTransition", "need `effect`"))?;
+    let def = find_effect(id)
+        .or_else(|| filmcraft_project::effect_defs().iter().find(|d| d.name.eq_ignore_ascii_case(id)))
+        .ok_or_else(|| bad("effects.setDefaultTransition", format!("no effect `{id}`")))?;
+    match def.kind {
+        filmcraft_project::EffectKind::AudioTransition => s.state.default_audio_transition = def.id.to_string(),
+        filmcraft_project::EffectKind::VideoTransition => s.state.default_video_transition = def.id.to_string(),
+        _ => return Err(bad("effects.setDefaultTransition", format!("`{}` is not a transition", def.name))),
+    }
+    Ok(json!({"video": s.state.default_video_transition, "audio": s.state.default_audio_transition}))
+}
+
+fn not_recording(s: &Session) -> std::result::Result<(), String> {
+    has_seq(s)?;
+    if s.mixrec.active() { Err("an automation pass is already recording".into()) } else { Ok(()) }
+}
+
+fn spec(
+    id: &'static str,
+    label: &'static str,
+    menu: &'static [&'static str],
+    shortcut: Option<&'static str>,
+    params: &'static str,
+    enabled: Enabled,
+    run: Run,
+    journal: bool,
+) -> CommandSpec {
+    CommandSpec { id, label, menu, shortcut, params, enabled, run, journal }
+}
+
+pub fn commands() -> Vec<CommandSpec> {
+    vec![
+        spec("mixer.inspect", "Inspect Audio Track Mixer", &[], None, r#"{"time":ticks?}"#, always, inspect, false),
+        spec(
+            "mixer.setStrip",
+            "Track Mixer Settings",
+            &[],
+            None,
+            r#"{"strip":"A1"|"S1"|"Mix"|id,"name":str?,"volumeDb":f64?,"pan":f64?,"muted":bool?,"solo":bool?,"recordArm":bool?,"soloSafe":bool?,"mode":"Off|Read|Latch|Touch|Write"?,"output":"Mix"|"S1"?,"inputMap":"Stereo|Left|Right|Swap|Mono"?,"channels":"Mono|Stereo|5.1"?}"#,
+            has_seq,
+            set_strip,
+            true,
+        ),
+        spec(
+            "mixer.setValue",
+            "Set Mixer Control",
+            &[],
+            None,
+            r#"{"strip":"A1"|"S1"|"Mix"|id,"lane":"volume|pan|mute|send.<i>.level|fx.<slot>.<param>","value":f64,"time":ticks?}"#,
+            has_seq,
+            |s, p| {
+                let id = strip_p(s, p, "mixer.setValue")?;
+                let lane = lane_p(s, p, id, "mixer.setValue")?;
+                let v = value_p(p, &lane, "mixer.setValue")?;
+                let t = time_p(s, p, "").unwrap_or(s.playhead());
+                if s.mixrec.active() {
+                    touch(s, id, &lane, v, t)?;
+                    return release(s, id, &lane, t);
+                }
+                set_value(s, id, &lane, v, t)?;
+                Ok(json!({"value": v}))
+            },
+            true,
+        ),
+        spec(
+            "mixer.touch",
+            "Touch Mixer Control",
+            &[],
+            None,
+            r#"{"strip":"A1"|"S1"|"Mix"|id,"lane":"volume|pan|mute|send.<i>.level|fx.<slot>.<param>","value":f64,"time":ticks?}"#,
+            has_seq,
+            |s, p| {
+                let id = strip_p(s, p, "mixer.touch")?;
+                let lane = lane_p(s, p, id, "mixer.touch")?;
+                let v = value_p(p, &lane, "mixer.touch")?;
+                let t = time_p(s, p, "").unwrap_or(s.playhead());
+                touch(s, id, &lane, v, t)
+            },
+            false,
+        ),
+        spec(
+            "mixer.release",
+            "Release Mixer Control",
+            &[],
+            None,
+            r#"{"strip":"A1"|"S1"|"Mix"|id,"lane":str?,"time":ticks?}"#,
+            has_seq,
+            |s, p| {
+                let id = strip_p(s, p, "mixer.release")?;
+                let lane = lane_p(s, p, id, "mixer.release")?;
+                let t = time_p(s, p, "").unwrap_or(s.playhead());
+                release(s, id, &lane, t)
+            },
+            true,
+        ),
+        spec(
+            "mixer.recordStart",
+            "Start Automation Pass",
+            &[],
+            None,
+            r#"{"time":ticks?}"#,
+            not_recording,
+            |s, p| {
+                let t = time_p(s, p, "").unwrap_or(s.playhead());
+                record_start(s, t)
+            },
+            false,
+        ),
+        spec(
+            "mixer.recordStop",
+            "Write Automation",
+            &[],
+            None,
+            r#"{"time":ticks?}"#,
+            has_seq,
+            |s, p| {
+                let t = time_p(s, p, "").unwrap_or(s.playhead());
+                record_stop(s, t)
+            },
+            true,
+        ),
+        spec(
+            "clipMixer.set",
+            "Audio Clip Mixer Adjust",
+            &[],
+            None,
+            r#"{"clip":id,"effect":"volume"|"panner","param":"level"|"balance","value":f64,"keyframe":bool?,"time":ticks?,"begin":bool?}"#,
+            has_seq,
+            clip_set,
+            true,
+        ),
+        spec(
+            "effects.setDefaultTransition",
+            "Set Selected as Default Transition",
+            &[],
+            None,
+            r#"{"effect":"constant_power|constant_gain|exponential_fade|<video transition>"}"#,
+            always,
+            set_default_transition,
+            true,
+        ),
+        spec("mixer.addSubmix", "Add Audio Submix Track", &["Sequence"], None, r#"{"name":str?,"channels":"Mono|Stereo|5.1"?}"#, has_seq, add_submix, true),
+        spec("mixer.deleteSubmix", "Delete Submix Track", &[], None, r#"{"strip":"S1"|id}"#, has_seq, delete_submix, true),
+        spec(
+            "mixer.addInsert",
+            "Add Track Effect",
+            &[],
+            None,
+            r#"{"strip":"A1"|"S1"|"Mix"|id,"effect":str,"slot":n?,"postFader":bool?}"#,
+            has_seq,
+            add_insert,
+            true,
+        ),
+        spec("mixer.removeInsert", "Remove Track Effect", &[], None, r#"{"strip":"A1"|"S1"|"Mix"|id,"slot":n}"#, has_seq, remove_insert, true),
+        spec(
+            "mixer.setInsert",
+            "Track Effect Settings",
+            &[],
+            None,
+            r#"{"strip":"A1"|"S1"|"Mix"|id,"slot":n,"enabled":bool?,"postFader":bool?,"params":{id:value}?}"#,
+            has_seq,
+            set_insert,
+            true,
+        ),
+        spec(
+            "mixer.addSend",
+            "Add Send",
+            &[],
+            None,
+            r#"{"strip":"A1"|"S1"|id,"target":"S1"|id,"levelDb":f64?,"preFader":bool?,"pan":f64?}"#,
+            has_seq,
+            add_send,
+            true,
+        ),
+        spec(
+            "mixer.setSend",
+            "Send Settings",
+            &[],
+            None,
+            r#"{"strip":"A1"|"S1"|id,"send":n,"levelDb":f64?,"pan":f64?,"preFader":bool?,"muted":bool?,"target":"S1"?}"#,
+            has_seq,
+            set_send,
+            true,
+        ),
+        spec("mixer.removeSend", "Remove Send", &[], None, r#"{"strip":"A1"|"S1"|id,"send":n}"#, has_seq, remove_send, true),
+        spec(
+            "mixer.setKeyframe",
+            "Add Track Keyframe",
+            &[],
+            None,
+            r#"{"strip":"A1"|"S1"|"Mix"|id,"lane":str?,"time":ticks?,"value":f64}"#,
+            has_seq,
+            set_kf,
+            true,
+        ),
+        spec("mixer.deleteKeyframe", "Delete Track Keyframe", &[], None, r#"{"strip":"A1"|"S1"|"Mix"|id,"lane":str?,"time":ticks}"#, has_seq, delete_kf, true),
+        spec(
+            "mixer.moveKeyframe",
+            "Move Track Keyframe",
+            &[],
+            None,
+            r#"{"strip":"A1"|"S1"|"Mix"|id,"lane":str?,"time":ticks,"newTime":ticks?,"value":f64?}"#,
+            has_seq,
+            move_kf,
+            true,
+        ),
+        spec("mixer.clearLane", "Clear Track Keyframes", &[], None, r#"{"strip":"A1"|"S1"|"Mix"|id,"lane":str?}"#, has_seq, clear_lane, true),
+        spec(
+            "mixer.writeAutomation",
+            "Write Automation Points",
+            &[],
+            None,
+            r#"{"strip":"A1"|"S1"|"Mix"|id,"lane":str?,"points":[[ticks,value]],"tolerance":f64?}"#,
+            has_seq,
+            write_automation,
+            true,
+        ),
+    ]
+}
diff --git a/crates/engine/src/mixer_tests.rs b/crates/engine/src/mixer_tests.rs
new file mode 100644
index 000000000..73a89a3ef
--- /dev/null
+++ b/crates/engine/src/mixer_tests.rs
@@ -0,0 +1,326 @@
+//! Audio Track Mixer commands and automation recording.
+
+use super::*;
+use filmcraft_project::mixer::{LANE_VOLUME, MASTER_STRIP};
+use filmcraft_project::{AutomationMode, ParamValue};
+use filmcraft_time::TICKS_PER_SECOND;
+use serde_json::json;
+
+fn demo() -> Session {
+    let mut s = Session::default();
+    s.execute("file.openDemoProject", json!({})).unwrap();
+    s
+}
+
+fn sec(x: f64) -> i64 {
+    (x * TICKS_PER_SECOND as f64) as i64
+}
+
+fn a1(s: &Session) -> &filmcraft_project::Track {
+    &s.active_sequence().unwrap().audio_tracks[0]
+}
+
+fn vol_at(s: &Session, x: f64) -> f64 {
+    a1(s).lane_value(LANE_VOLUME, Tick(sec(x)))
+}
+
+fn set_mode(s: &mut Session, strip: &str, mode: &str) {
+    s.execute("mixer.setStrip", json!({"strip": strip, "mode": mode})).unwrap();
+}
+
+#[test]
+fn every_mixer_command_is_registered_with_a_label() {
+    for id in [
+        "mixer.inspect",
+        "mixer.setStrip",
+        "mixer.setValue",
+        "mixer.touch",
+        "mixer.release",
+        "mixer.recordStart",
+        "mixer.recordStop",
+        "mixer.addSubmix",
+        "mixer.deleteSubmix",
+        "mixer.addInsert",
+        "mixer.removeInsert",
+        "mixer.setInsert",
+        "mixer.addSend",
+        "mixer.setSend",
+        "mixer.removeSend",
+        "mixer.setKeyframe",
+        "mixer.deleteKeyframe",
+        "mixer.moveKeyframe",
+        "mixer.clearLane",
+        "mixer.writeAutomation",
+    ] {
+        let c = commands::find(id).unwrap_or_else(|| panic!("{id} missing"));
+        assert!(!c.label.is_empty() && !c.params.is_empty());
+    }
+    let s = Session::default();
+    assert!(s.clone_disabled("mixer.setStrip"), "needs a sequence");
+}
+
+impl Session {
+    fn clone_disabled(&self, id: &str) -> bool {
+        !self.is_enabled(id)
+    }
+}
+
+#[test]
+fn strip_settings_undo_redo_and_inspect() {
+    let mut s = demo();
+    s.execute("mixer.setStrip", json!({"strip": "A1", "volumeDb": -6.0, "pan": -30.0, "mode": "Touch", "recordArm": true, "solo": true})).unwrap();
+    let t = a1(&s);
+    assert_eq!((t.volume_db, t.pan, t.mixer.mode, t.mixer.record_arm, t.solo), (-6.0, -30.0, AutomationMode::Touch, true, true));
+    s.execute("mixer.setStrip", json!({"strip": "Mix", "volumeDb": -3.0})).unwrap();
+    assert_eq!(s.active_sequence().unwrap().master_volume_db, -3.0);
+    s.execute("edit.undo", json!({})).unwrap();
+    s.execute("edit.undo", json!({})).unwrap();
+    assert_eq!(a1(&s).volume_db, 0.0);
+    s.execute("edit.redo", json!({})).unwrap();
+    assert_eq!(a1(&s).volume_db, -6.0);
+    let v = s.execute("mixer.inspect", json!({})).unwrap();
+    let strips = v["strips"].as_array().unwrap();
+    assert_eq!(strips.last().unwrap()["ref"], "Mix");
+    assert_eq!(strips[0]["ref"], "A1");
+    assert_eq!(strips[0]["mode"], "Touch");
+    // errors
+    assert!(s.execute("mixer.setStrip", json!({"strip": "A99"})).is_err());
+    assert!(s.execute("mixer.setValue", json!({"strip": "Mix", "lane": "pan", "value": 3})).is_err(), "Mix has no pan");
+}
+
+#[test]
+fn submixes_sends_and_inserts() {
+    let mut s = demo();
+    let r = s.execute("mixer.addSubmix", json!({"name": "Reverb"})).unwrap();
+    assert_eq!(r["ref"], "S1");
+    s.execute("mixer.addSubmix", json!({})).unwrap();
+    s.execute("mixer.addSend", json!({"strip": "A1", "target": "S1", "levelDb": -6.0, "preFader": true})).unwrap();
+    s.execute("mixer.addInsert", json!({"strip": "S1", "effect": "studio_reverb"})).unwrap();
+    s.execute("mixer.addInsert", json!({"strip": "A1", "effect": "dynamics", "postFader": true})).unwrap();
+    s.execute("mixer.setInsert", json!({"strip": "A1", "slot": 0, "params": {"threshold": -30.0}})).unwrap();
+    s.execute("mixer.setStrip", json!({"strip": "S1", "output": "S2"})).unwrap();
+    assert!(s.execute("mixer.setStrip", json!({"strip": "S2", "output": "S1"})).is_err(), "no feedback");
+    assert!(s.execute("mixer.addSend", json!({"strip": "S2", "target": "S1"})).is_err(), "no feedback");
+    assert!(s.execute("mixer.addInsert", json!({"strip": "A1", "effect": "gaussian_blur"})).is_err());
+    let q = s.active_sequence().unwrap();
+    assert_eq!(q.audio_tracks[0].mixer.sends[0].level_db, -6.0);
+    assert!(q.audio_tracks[0].effects[0].post_fader);
+    assert_eq!(q.audio_tracks[0].effects[0].param("threshold").unwrap().value, ParamValue::Float(-30.0));
+    // the mix renders through the graph (the demo has audio on A1)
+    let provider = s.media.provider(s.project.clone(), s.services.clone());
+    let b = filmcraft_render::audio::mix_sequence(&s.project, q, 0, 4_800, &provider);
+    assert_eq!(b.frames(), 4_800);
+    // deleting a submix re-routes and drops sends
+    let s1 = q.submix_tracks[0].id.0;
+    s.execute("mixer.deleteSubmix", json!({"strip": s1})).unwrap();
+    let q = s.active_sequence().unwrap();
+    assert!(q.audio_tracks[0].mixer.sends.is_empty());
+    assert_eq!(q.submix_tracks.len(), 1);
+    s.execute("mixer.removeInsert", json!({"strip": "A1", "slot": 0})).unwrap();
+    assert!(a1(&s).effects.is_empty());
+}
+
+#[test]
+fn keyframes_by_command_and_pen_edits() {
+    let mut s = demo();
+    s.execute("mixer.setKeyframe", json!({"strip": "A1", "time": sec(1.0), "value": -10.0})).unwrap();
+    s.execute("mixer.setKeyframe", json!({"strip": "A1", "time": sec(2.0), "value": 0.0})).unwrap();
+    assert_eq!(vol_at(&s, 0.0), -10.0);
+    assert!((vol_at(&s, 1.5) + 5.0).abs() < 1e-9);
+    s.execute("mixer.moveKeyframe", json!({"strip": "A1", "time": sec(2.0), "newTime": sec(3.0), "value": -20.0})).unwrap();
+    assert!((vol_at(&s, 2.0) + 15.0).abs() < 1e-9);
+    s.execute("mixer.deleteKeyframe", json!({"strip": "A1", "time": sec(1.0)})).unwrap();
+    assert_eq!(vol_at(&s, 0.0), -20.0);
+    // a fader move on an automated lane (Read, stopped) adds a keyframe at the playhead
+    s.execute("playhead.set", json!({"seconds": 5.0})).unwrap();
+    s.execute("mixer.setValue", json!({"strip": "A1", "value": -3.0})).unwrap();
+    assert_eq!(vol_at(&s, 5.0), -3.0);
+    assert_eq!(a1(&s).lane_keyframes(LANE_VOLUME).len(), 2);
+    // mute keyframes hold
+    s.execute("mixer.setKeyframe", json!({"strip": "A1", "lane": "mute", "time": sec(1.0), "value": true})).unwrap();
+    s.execute("mixer.setKeyframe", json!({"strip": "A1", "lane": "mute", "time": sec(2.0), "value": false})).unwrap();
+    assert_eq!(a1(&s).lane_value("mute", Tick(sec(1.9))), 1.0);
+    s.execute("mixer.clearLane", json!({"strip": "A1", "lane": "volume"})).unwrap();
+    assert!(a1(&s).lane_keyframes(LANE_VOLUME).is_empty());
+    // effect parameter lanes
+    s.execute("mixer.addInsert", json!({"strip": "A1", "effect": "amplify"})).unwrap();
+    s.execute("mixer.setKeyframe", json!({"strip": "A1", "lane": "fx.0.gain", "time": sec(1.0), "value": 6.0})).unwrap();
+    assert!(a1(&s).automated_lanes().contains(&"fx.0.gain".to_string()));
+}
+
+/// Simulate a fader gesture: `(seconds, dB)` samples as the UI would send them each frame.
+fn gesture(s: &mut Session, strip: &str, pts: &[(f64, f64)]) {
+    for &(t, v) in pts {
+        s.execute("mixer.touch", json!({"strip": strip, "lane": "volume", "value": v, "time": sec(t)})).unwrap();
+    }
+}
+
+#[test]
+fn touch_records_while_held_and_returns_over_automatch() {
+    let mut s = demo();
+    set_mode(&mut s, "A1", "Touch");
+    s.execute("mixer.recordStart", json!({"time": 0})).unwrap();
+    assert!(s.execute("mixer.recordStart", json!({})).is_err(), "already recording");
+    // hold -10 dB from 1 s to 2 s (frames every 1/30 s)
+    let pts: Vec<(f64, f64)> = (0..=30).map(|i| (1.0 + i as f64 / 30.0, -10.0)).collect();
+    gesture(&mut s, "A1", &pts);
+    // the audio follows the fader while recording
+    assert_eq!(s.previews.live.get(a1(&s).id, LANE_VOLUME).map(|o| o.value), Some(-10.0));
+    s.execute("mixer.release", json!({"strip": "A1", "time": sec(2.0)})).unwrap();
+    let r = s.execute("mixer.recordStop", json!({"time": sec(5.0)})).unwrap();
+    assert_eq!(r["lanes"], 1);
+    assert!(!s.previews.live.is_active());
+    assert_eq!(vol_at(&s, 0.5), 0.0, "before the touch: unchanged");
+    assert_eq!(vol_at(&s, 1.5), -10.0);
+    assert!((vol_at(&s, 2.5) + 5.0).abs() < 0.01, "halfway back after 0.5 s of the 1 s automatch: {}", vol_at(&s, 2.5));
+    assert_eq!(vol_at(&s, 3.5), 0.0, "back to the old automation");
+    // thinned: a held value is a few keyframes, not 31
+    assert!(a1(&s).lane_keyframes(LANE_VOLUME).len() <= 5, "{:?}", a1(&s).lane_keyframes(LANE_VOLUME));
+    // one undo step removes the pass
+    s.execute("edit.undo", json!({})).unwrap();
+    assert!(a1(&s).lane_keyframes(LANE_VOLUME).is_empty());
+}
+
+#[test]
+fn touch_over_existing_automation_and_custom_automatch() {
+    let mut s = demo();
+    s.execute("prefs.set", json!({"key": "audio.automatchTime", "value": 2.0})).unwrap();
+    s.execute("mixer.writeAutomation", json!({"strip": "A1", "points": [[0, -20.0], [sec(8.0), -20.0]]})).unwrap();
+    set_mode(&mut s, "A1", "Touch");
+    s.execute("mixer.recordStart", json!({"time": sec(0.5)})).unwrap();
+    gesture(&mut s, "A1", &[(1.0, 0.0), (1.5, 0.0)]);
+    s.execute("mixer.release", json!({"strip": "A1", "time": sec(1.5)})).unwrap();
+    s.execute("mixer.recordStop", json!({"time": sec(6.0)})).unwrap();
+    assert_eq!(vol_at(&s, 0.9), -20.0);
+    assert_eq!(vol_at(&s, 1.25), 0.0);
+    assert!((vol_at(&s, 2.5) + 10.0).abs() < 0.05, "{}", vol_at(&s, 2.5));
+    assert_eq!(vol_at(&s, 4.0), -20.0);
+    assert_eq!(vol_at(&s, 7.0), -20.0);
+}
+
+#[test]
+fn latch_holds_until_stop() {
+    let mut s = demo();
+    s.execute("mixer.writeAutomation", json!({"strip": "A1", "points": [[0, 0.0], [sec(8.0), 0.0]]})).unwrap();
+    set_mode(&mut s, "A1", "Latch");
+    s.execute("mixer.recordStart", json!({"time": 0})).unwrap();
+    gesture(&mut s, "A1", &[(1.0, -4.0), (1.5, -8.0), (2.0, -12.0)]);
+    s.execute("mixer.release", json!({"strip": "A1", "time": sec(2.0)})).unwrap();
+    s.execute("mixer.recordStop", json!({"time": sec(4.0)})).unwrap();
+    assert_eq!(vol_at(&s, 0.5), 0.0);
+    assert!((vol_at(&s, 1.25) + 6.0).abs() < 1e-6);
+    assert_eq!(vol_at(&s, 3.0), -12.0, "latched");
+    assert_eq!(vol_at(&s, 3.99), -12.0);
+    assert!(vol_at(&s, 4.5) > -12.0, "existing automation after the stop resumes");
+}
+
+#[test]
+fn write_overwrites_from_start_and_switches_to_touch() {
+    let mut s = demo();
+    s.execute("mixer.writeAutomation", json!({"strip": "A1", "points": [[0, -30.0], [sec(8.0), 0.0]]})).unwrap();
+    s.execute("mixer.setStrip", json!({"strip": "A1", "mode": "Write"})).unwrap();
+    s.execute("mixer.recordStart", json!({"time": sec(2.0)})).unwrap();
+    let start_val = -30.0 + 30.0 * 2.0 / 8.0;
+    // untouched until 3 s: the fader's value at the start is written
+    gesture(&mut s, "A1", &[(3.0, -6.0), (3.5, -6.0)]);
+    s.execute("mixer.release", json!({"strip": "A1", "time": sec(3.5)})).unwrap();
+    s.execute("mixer.recordStop", json!({"time": sec(5.0)})).unwrap();
+    assert!((vol_at(&s, 1.0) - (-30.0 + 30.0 / 8.0)).abs() < 0.05, "before the pass: unchanged");
+    assert!((vol_at(&s, 2.5) - start_val).abs() < 0.05, "{}", vol_at(&s, 2.5));
+    assert_eq!(vol_at(&s, 4.0), -6.0);
+    assert_eq!(vol_at(&s, 4.9), -6.0, "Write holds the last value to the stop");
+    assert_eq!(a1(&s).mixer.mode, AutomationMode::Touch, "Switch to Touch after Write");
+    // pan and mute are written too
+    assert!(a1(&s).lane_keyframes("pan").len() >= 2 && a1(&s).lane_keyframes("mute").len() >= 2);
+    // the preference can keep Write
+    s.execute("prefs.set", json!({"key": "audio.switchToTouchAfterWrite", "value": false})).unwrap();
+    s.execute("mixer.setStrip", json!({"strip": "A1", "mode": "Write"})).unwrap();
+    s.execute("mixer.recordStart", json!({"time": sec(6.0)})).unwrap();
+    s.execute("mixer.recordStop", json!({"time": sec(7.0)})).unwrap();
+    assert_eq!(a1(&s).mixer.mode, AutomationMode::Write);
+}
+
+#[test]
+fn read_mode_does_not_record_and_commits_once_without_a_pass() {
+    let mut s = demo();
+    s.execute("mixer.recordStart", json!({"time": 0})).unwrap();
+    gesture(&mut s, "A1", &[(1.0, -6.0), (2.0, -9.0)]);
+    s.execute("mixer.release", json!({"strip": "A1", "time": sec(2.0)})).unwrap();
+    let r = s.execute("mixer.recordStop", json!({"time": sec(3.0)})).unwrap();
+    assert_eq!(r["lanes"], 0);
+    assert!(a1(&s).lane_keyframes(LANE_VOLUME).is_empty());
+    // stopped: a drag is heard live, then committed as one undo step
+    let undo0 = s.history.undo.len();
+    gesture(&mut s, "A1", &[(0.0, -2.0), (0.0, -4.0), (0.0, -5.0)]);
+    assert_eq!(a1(&s).volume_db, 0.0);
+    s.execute("mixer.release", json!({"strip": "A1"})).unwrap();
+    assert_eq!(a1(&s).volume_db, -5.0);
+    assert_eq!(s.history.undo.len(), undo0 + 1);
+}
+
+#[test]
+fn recorded_pass_plays_back_through_the_mix() {
+    let mut s = demo();
+    // only A1 (the demo has music on another track)
+    s.execute("mixer.setStrip", json!({"strip": "A1", "solo": true})).unwrap();
+    set_mode(&mut s, "A1", "Latch");
+    s.execute("mixer.recordStart", json!({"time": 0})).unwrap();
+    gesture(&mut s, "A1", &[(0.5, -96.0)]);
+    s.execute("mixer.release", json!({"strip": "A1", "time": sec(0.5)})).unwrap();
+    s.execute("mixer.recordStop", json!({"time": sec(2.0)})).unwrap();
+    let q = s.active_sequence().unwrap();
+    let seq_id = s.state.active_sequence.unwrap();
+    let provider = s.media.provider(s.project.clone(), s.services.clone());
+    let b = s.previews.mix(&s.project, seq_id, 48_000, 4_800, &provider);
+    assert!(b.channels[0].iter().all(|x| x.abs() < 1e-6), "faded out by the recorded automation");
+    let before = filmcraft_render::audio::mix_sequence(&s.project, q, 0, 4_800, &provider);
+    assert!(before.channels[0].iter().any(|x| x.abs() > 1e-4), "audible before the move");
+    // master strip automation
+    s.execute("mixer.setKeyframe", json!({"strip": "Mix", "time": 0, "value": -6.0})).unwrap();
+    assert_eq!(s.active_sequence().unwrap().master_volume_at(Tick(sec(1.0))), -6.0);
+    assert!(s.active_sequence().unwrap().strip(MASTER_STRIP).is_some());
+}
+
+#[test]
+fn audio_gain_modes_and_peak() {
+    let mut s = demo();
+    let clips: Vec<u64> = a1(&s).items.iter().take(3).map(|i| i.id.0).collect();
+    s.execute("timeline.select", json!({"clips": clips})).unwrap();
+    let pk = s.execute("clip.audioPeak", json!({})).unwrap();
+    let peak = pk["peakDb"].as_f64().unwrap();
+    assert!(peak.is_finite() && peak > -60.0, "{pk}");
+    // adjust (and the old {db, relative} form)
+    s.execute("clip.audioGain", json!({"mode": "adjust", "db": -2.0})).unwrap();
+    assert_eq!(a1(&s).items[0].gain_db, -2.0);
+    s.execute("clip.audioGain", json!({"db": 1.0, "relative": true})).unwrap();
+    assert_eq!(a1(&s).items[0].gain_db, -1.0);
+    s.execute("clip.audioGain", json!({"mode": "set", "db": 3.0})).unwrap();
+    assert!(a1(&s).items.iter().take(3).all(|i| i.gain_db == 3.0));
+    // normalize max peak: the loudest clip lands on the target, the others keep their offsets
+    s.execute("clip.audioGain", json!({"mode": "normalizeMax", "db": -1.0})).unwrap();
+    let pk = s.execute("clip.audioPeak", json!({})).unwrap();
+    assert!((pk["peakDb"].as_f64().unwrap() + 1.0).abs() < 1e-6, "{pk}");
+    let g: Vec<f64> = a1(&s).items.iter().take(3).map(|i| i.gain_db).collect();
+    assert!(g.windows(2).all(|w| (w[0] - w[1]).abs() < 1e-9), "same adjustment for all: {g:?}");
+    // normalize all peaks: every clip on the target
+    s.execute("clip.audioGain", json!({"mode": "normalizeAll", "db": -6.0})).unwrap();
+    let pk = s.execute("clip.audioPeak", json!({})).unwrap();
+    for c in pk["clips"].as_array().unwrap() {
+        let total = c["sourcePeakDb"].as_f64().unwrap() + c["gainDb"].as_f64().unwrap();
+        assert!((total + 6.0).abs() < 1e-6, "{c}");
+    }
+    assert!(s.execute("clip.audioGain", json!({"mode": "loud"})).is_err());
+}
+
+#[test]
+fn default_audio_transition_is_used_by_apply() {
+    let mut s = demo();
+    s.execute("effects.setDefaultTransition", json!({"effect": "Exponential Fade"})).unwrap();
+    assert_eq!(s.state.default_audio_transition, "exponential_fade");
+    assert!(s.execute("effects.setDefaultTransition", json!({"effect": "amplify"})).is_err());
+    let clip = a1(&s).items[1].id.0;
+    s.execute("sequence.applyAudioTransition", json!({"clip": clip})).unwrap();
+    let tr = &a1(&s).transitions;
+    assert_eq!(tr.len(), 1);
+    assert_eq!(tr[0].effect.effect, "exponential_fade");
+}
diff --git a/crates/engine/src/previews.rs b/crates/engine/src/previews.rs
index c031ea1b2..c49db99c0 100644
--- a/crates/engine/src/previews.rs
+++ b/crates/engine/src/previews.rs
@@ -79,6 +79,8 @@ pub struct PreviewStore {
     audio_memo: Mutex<Vec<AudioMemo>>,
     /// Bumped whenever the set of preview files changes.
     pub generation: AtomicU64,
+    /// Live mixer state shared with playback: held controls, meters, newest project snapshot.
+    pub live: Arc<filmcraft_render::mixer::LiveMix>,
 }
 
 fn video_name(hash: &str) -> String {
@@ -244,9 +246,11 @@ impl PreviewStore {
     /// live mix ([`filmcraft_render::audio::mix_sequence`]) everywhere else.
     pub fn mix(&self, project: &Arc<Project>, seq: ItemId, start: i64, frames: usize, sources: &dyn filmcraft_render::SourceProvider) -> AudioBuffer {
         let Some(q) = project.sequence(seq) else { return AudioBuffer::silence(48_000, 2, frames) };
+        let live = Some(&*self.live);
         let has_audio = self.files.read().unwrap_or_else(|e| e.into_inner()).iter().any(|n| n.ends_with(".wav"));
-        if !has_audio {
-            return filmcraft_render::audio::mix_sequence(project, q, start, frames, sources);
+        // held mixer controls are heard live (rendered previews don't know them)
+        if !has_audio || self.live.is_active() {
+            return filmcraft_render::mixer::mix_graph(project, q, start, frames, sources, live);
         }
         let segs = self.audio_segments(project, seq);
         let mut out = AudioBuffer::silence(q.settings.sample_rate, 2, frames);
@@ -271,7 +275,7 @@ impl PreviewStore {
                     }
                 }
                 _ => {
-                    let b = filmcraft_render::audio::mix_sequence(project, q, pos, n, sources);
+                    let b = filmcraft_render::mixer::mix_graph(project, q, pos, n, sources, live);
                     for c in 0..2 {
                         out.channels[c][off..off + n].copy_from_slice(&b.channels[c.min(b.channels.len() - 1)][..n]);
                     }
diff --git a/crates/engine/src/shortcut_presets.rs b/crates/engine/src/shortcut_presets.rs
new file mode 100644
index 000000000..4f4d36c59
--- /dev/null
+++ b/crates/engine/src/shortcut_presets.rs
@@ -0,0 +1,247 @@
+//! Built-in keyboard shortcut tables (command id, keys, panel; "" = application-wide).
+//!
+//! Key assignments are functional facts about how other editors are operated; these tables map
+//! them onto FilmCraft's own command ids. No files from any other application are used.
+//! Keys use FilmCraft's canonical notation (`Cmd` = ⌘ on macOS / Ctrl elsewhere, `Ctrl` = the
+//! macOS Control key, `Alt` = ⌥ Option / Alt; `Backspace` = the Mac "delete" key, `Delete` = the
+//! forward-delete key).
+
+pub type Entry = (&'static str, &'static str, &'static str);
+
+/// FilmCraft additions to the per-command defaults: panel-specific shortcuts.
+pub const FILMCRAFT_PANEL: &[Entry] = &[
+    ("project.delete", "Backspace", "Project"),
+    ("file.newBin", "Cmd+B", "Project"),
+    ("edit.undo", "Left", "History"),
+    ("edit.redo", "Right", "History"),
+    ("sequence.close", "Cmd+W", "Timeline"),
+];
+
+/// Premiere Pro's default keyboard (macOS) mapped onto FilmCraft commands. FilmCraft Default takes
+/// every entry whose command has no shortcut yet and whose key is free (the shortcut audit);
+/// the "Premiere Pro Compatible" preset applies all of them.
+pub const PREMIERE: &[Entry] = &[
+    // Tools
+    ("tool.selection", "V", ""),
+    ("tool.trackSelectBackward", "Shift+A", ""),
+    ("tool.trackSelectForward", "A", ""),
+    ("tool.ripple", "B", ""),
+    ("tool.rolling", "N", ""),
+    ("tool.rateStretch", "R", ""),
+    ("tool.razor", "C", ""),
+    ("tool.slip", "Y", ""),
+    ("tool.slide", "U", ""),
+    ("tool.pen", "P", ""),
+    ("tool.hand", "H", ""),
+    ("tool.zoom", "Z", ""),
+    ("tool.type", "T", ""),
+    // Application
+    ("app.preferences.autoSave", "Cmd+,", ""),
+    ("app.keyboardShortcuts", "Cmd+Alt+K", ""),
+    // File
+    ("file.newProject", "Cmd+Alt+N", ""),
+    ("file.newSequence", "Cmd+N", ""),
+    ("file.newBin", "Cmd+/", ""),
+    ("file.newBin", "Cmd+B", "Project"),
+    ("file.open", "Cmd+O", ""),
+    ("file.save", "Cmd+S", ""),
+    ("file.saveAs", "Cmd+Shift+S", ""),
+    ("file.saveCopy", "Cmd+Alt+S", ""),
+    ("file.import", "Cmd+I", ""),
+    ("mode.export", "Cmd+M", ""),
+    // Edit
+    ("edit.undo", "Cmd+Z", ""),
+    ("edit.redo", "Cmd+Shift+Z", ""),
+    ("edit.cut", "Cmd+X", ""),
+    ("edit.copy", "Cmd+C", ""),
+    ("edit.paste", "Cmd+V", ""),
+    ("edit.pasteInsert", "Cmd+Shift+V", ""),
+    ("edit.clear", "Delete", ""),
+    ("edit.clear", "Backspace", "Timeline"),
+    ("edit.rippleDelete", "Shift+Delete", ""),
+    ("edit.rippleDelete", "Alt+Backspace", "Timeline"),
+    ("edit.duplicate", "Cmd+Shift+/", ""),
+    ("edit.selectAll", "Cmd+A", ""),
+    ("edit.deselectAll", "Cmd+Shift+A", ""),
+    // Clip
+    ("clip.speedDuration", "Cmd+R", ""),
+    ("source.insert", ",", ""),
+    ("source.overwrite", ".", ""),
+    ("clip.enable", "Cmd+Shift+E", ""),
+    ("clip.link", "Cmd+L", ""),
+    ("clip.group", "Cmd+G", ""),
+    ("clip.ungroup", "Cmd+Shift+G", ""),
+    ("clip.audioGain", "G", ""),
+    // Sequence
+    ("sequence.renderEffectsInToOut", "Enter", ""),
+    ("sequence.matchFrame", "F", ""),
+    ("sequence.addEdit", "Cmd+K", ""),
+    ("sequence.addEditAllTracks", "Cmd+Shift+K", ""),
+    ("trim.edit", "Shift+T", ""),
+    ("trim.extendToPlayhead", "E", ""),
+    ("sequence.applyVideoTransition", "Cmd+D", ""),
+    ("sequence.applyAudioTransition", "Cmd+Shift+D", ""),
+    ("trim.applyDefaultTransition", "Shift+D", ""),
+    ("sequence.lift", ";", ""),
+    ("sequence.extract", "'", ""),
+    ("view.zoomIn", "=", ""),
+    ("view.zoomOut", "-", ""),
+    ("sequence.snap", "S", ""),
+    // Markers
+    ("markers.markIn", "I", ""),
+    ("markers.markOut", "O", ""),
+    ("markers.markClip", "X", ""),
+    ("markers.markSelection", "/", ""),
+    ("markers.goToIn", "Shift+I", ""),
+    ("markers.goToOut", "Shift+O", ""),
+    ("markers.clearIn", "Alt+I", ""),
+    ("markers.clearOut", "Alt+O", ""),
+    ("markers.clearInOut", "Alt+X", ""),
+    ("markers.add", "M", ""),
+    ("markers.goNext", "Shift+M", ""),
+    ("markers.goPrev", "Cmd+Shift+M", ""),
+    ("markers.clearCurrent", "Alt+M", ""),
+    ("markers.clearAll", "Cmd+Alt+M", ""),
+    // Window
+    ("window.workspace.reset", "Alt+Shift+0", ""),
+    ("window.workspace.editing", "Alt+Shift+1", ""),
+    ("window.workspace.assembly", "Alt+Shift+2", ""),
+    ("window.workspace.color", "Alt+Shift+3", ""),
+    ("window.workspace.effects", "Alt+Shift+4", ""),
+    ("window.workspace.audio", "Alt+Shift+5", ""),
+    ("window.workspace.captionsandgraphics", "Alt+Shift+6", ""),
+    ("window.panel.Project", "Shift+1", ""),
+    ("window.panel.Source", "Shift+2", ""),
+    ("window.panel.Timeline", "Shift+3", ""),
+    ("window.panel.Program", "Shift+4", ""),
+    ("window.panel.EffectControls", "Shift+5", ""),
+    ("window.panel.AudioTrackMixer", "Shift+6", ""),
+    ("window.panel.Effects", "Shift+7", ""),
+    ("window.panel.MediaBrowser", "Shift+8", ""),
+    ("window.panel.AudioClipMixer", "Shift+9", ""),
+    // Captions
+    ("captions.newTrack", "Cmd+Alt+A", ""),
+    ("captions.add", "Cmd+Alt+C", ""),
+    ("captions.next", "Cmd+Alt+Down", "Timeline"),
+    ("captions.previous", "Cmd+Alt+Up", "Timeline"),
+    // Navigation and playback
+    ("playhead.nextEdit", "Down", ""),
+    ("playhead.prevEdit", "Up", ""),
+    ("playhead.start", "Home", ""),
+    ("playhead.end", "End", ""),
+    ("playhead.stepBack", "Left", ""),
+    ("playhead.stepBack5", "Shift+Left", ""),
+    ("playhead.stepForward", "Right", ""),
+    ("playhead.stepForward5", "Shift+Right", ""),
+    ("playback.toggle", "Space", ""),
+    ("playback.reverse", "J", ""),
+    ("playback.stop", "K", ""),
+    ("playback.forward", "L", ""),
+    ("playback.slowReverse", "Shift+J", ""),
+    ("playback.slowForward", "Shift+L", ""),
+    ("playback.playAround", "Shift+K", ""),
+    ("playback.inToOut", "Alt+K", ""),
+    ("view.zoomToSequence", "\\", ""),
+    // Trimming
+    ("trim.ripplePrevious", "Q", ""),
+    ("trim.rippleNext", "W", ""),
+    ("trim.previous", "Alt+Q", ""),
+    ("trim.next", "Alt+W", ""),
+    ("trim.toggleType", "Ctrl+T", ""),
+    ("trim.backward", "Alt+Left", ""),
+    ("trim.backwardMany", "Alt+Shift+Left", ""),
+    ("trim.forward", "Alt+Right", ""),
+    ("trim.forwardMany", "Alt+Shift+Right", ""),
+    // Panels
+    ("project.delete", "Backspace", "Project"),
+    ("source.open", "Shift+O", "Project"),
+    ("edit.undo", "Left", "History"),
+    ("edit.redo", "Right", "History"),
+];
+
+/// Final Cut Pro's default keys for the equivalent FilmCraft commands.
+pub const FINAL_CUT: &[Entry] = &[
+    ("tool.selection", "A", ""),
+    ("tool.razor", "B", ""),
+    ("tool.ripple", "T", ""),
+    ("tool.zoom", "Z", ""),
+    ("tool.hand", "H", ""),
+    ("source.insert", "W", ""),
+    ("source.overwrite", "D", ""),
+    ("sequence.addEdit", "Cmd+B", ""),
+    ("sequence.addEditAllTracks", "Cmd+Shift+B", ""),
+    ("edit.rippleDelete", "Backspace", ""),
+    ("sequence.lift", "Shift+Backspace", ""),
+    ("markers.markIn", "I", ""),
+    ("markers.markOut", "O", ""),
+    ("markers.markClip", "X", ""),
+    ("markers.clearInOut", "Alt+X", ""),
+    ("markers.add", "M", ""),
+    ("markers.goNext", "Ctrl+'", ""),
+    ("markers.goPrev", "Ctrl+;", ""),
+    ("playhead.nextEdit", "Down", ""),
+    ("playhead.prevEdit", "Up", ""),
+    ("playhead.stepForward5", "Shift+Right", ""),
+    ("playhead.stepBack5", "Shift+Left", ""),
+    ("playback.toggle", "Space", ""),
+    ("playback.reverse", "J", ""),
+    ("playback.stop", "K", ""),
+    ("playback.forward", "L", ""),
+    ("playback.loop", "Cmd+L", ""),
+    ("playback.inToOut", "/", ""),
+    ("sequence.snap", "N", ""),
+    ("view.zoomIn", "Cmd+=", ""),
+    ("view.zoomOut", "Cmd+-", ""),
+    ("view.zoomToSequence", "Shift+Z", ""),
+    ("sequence.applyVideoTransition", "Cmd+T", ""),
+    ("clip.speedDuration", "Cmd+R", ""),
+    ("clip.enable", "V", ""),
+    ("clip.nest", "Alt+G", ""),
+    ("sequence.matchFrame", "Shift+F", ""),
+    ("trim.extendToPlayhead", "Shift+X", ""),
+    ("trim.backward", ",", ""),
+    ("trim.forward", ".", ""),
+    ("trim.backwardMany", "Shift+,", ""),
+    ("trim.forwardMany", "Shift+.", ""),
+    ("file.newBin", "Alt+N", ""),
+    ("mode.export", "Cmd+E", ""),
+    ("sequence.renderEffectsInToOut", "Ctrl+R", ""),
+    ("sequence.renderInToOut", "Ctrl+Shift+R", ""),
+];
+
+/// Avid Media Composer's default keys for the equivalent FilmCraft commands.
+pub const AVID: &[Entry] = &[
+    ("playback.reverse", "J", ""),
+    ("playback.stop", "K", ""),
+    ("playback.forward", "L", ""),
+    ("playback.toggle", "Space", ""),
+    ("markers.markIn", "I", ""),
+    ("markers.markIn", "E", ""),
+    ("markers.markOut", "O", ""),
+    ("markers.markOut", "R", ""),
+    ("markers.markClip", "T", ""),
+    ("markers.clearIn", "D", ""),
+    ("markers.clearOut", "F", ""),
+    ("markers.clearInOut", "G", ""),
+    ("markers.goToIn", "Q", ""),
+    ("markers.goToOut", "W", ""),
+    ("source.insert", "V", ""),
+    ("source.overwrite", "B", ""),
+    ("sequence.lift", "Z", ""),
+    ("sequence.extract", "X", ""),
+    ("sequence.addEdit", "H", ""),
+    ("playhead.stepBack5", "1", ""),
+    ("playhead.stepForward5", "2", ""),
+    ("playhead.stepBack", "3", ""),
+    ("playhead.stepForward", "4", ""),
+    ("playhead.prevEdit", "A", ""),
+    ("playhead.nextEdit", "S", ""),
+    ("trim.edit", "U", ""),
+    ("trim.backwardMany", "M", ""),
+    ("trim.backward", ",", ""),
+    ("trim.forward", ".", ""),
+    ("trim.forwardMany", "/", ""),
+    ("view.zoomIn", "Cmd+]", ""),
+    ("view.zoomOut", "Cmd+[", ""),
+    ("markers.add", "F5", ""),
+];
diff --git a/crates/engine/src/shortcuts.rs b/crates/engine/src/shortcuts.rs
new file mode 100644
index 000000000..ac76902fb
--- /dev/null
+++ b/crates/engine/src/shortcuts.rs
@@ -0,0 +1,1152 @@
+//! Keyboard shortcuts as data: the active key bindings, presets, conflict detection and the
+//! `shortcuts.*` commands (Edit ▸ Keyboard Shortcuts…, and the same operations for agents over MCP).
+//!
+//! A [`Binding`] maps a key chord to a command id, either application-wide or for one panel
+//! (panel shortcuts apply while that panel has focus and override application shortcuts).
+//! Chords are stored in a canonical, platform-neutral notation:
+//!
+//! | token | macOS | Windows / Linux |
+//! |---|---|---|
+//! | `Cmd` | ⌘ Command | Ctrl |
+//! | `Ctrl` | ⌃ Control | Ctrl (folds into `Cmd`; conflicts are reported) |
+//! | `Alt` | ⌥ Option | Alt |
+//! | `Shift` | ⇧ Shift | Shift |
+//!
+//! so one preset works on every OS. Preset files written for Windows (`"platform": "windows"`)
+//! are converted on import: their `Ctrl` is the primary modifier (`Cmd`) and `Win`/`Meta` maps to
+//! the macOS Control key.
+//!
+//! Built-in presets: **FilmCraft Default** (each command's default plus the Premiere-default audit,
+//! see [`Shortcuts::audit`]), **Premiere Pro Compatible**, **Final Cut Pro Compatible** and
+//! **Avid Media Composer Compatible** ([`crate::shortcut_presets`]). Custom presets are JSON files in
+//! `<data dir>/Keyboard Shortcuts/`; the active set persists in `active.json` there.
+//!
+//! Commands the frontend owns (tools, transport, panels, workspaces) are registered with
+//! [`Shortcuts::register_external`] so they can be listed, bound and resolved here too.
+
+use std::collections::BTreeMap;
+use std::path::{Path, PathBuf};
+
+use serde::{Deserialize, Serialize};
+use serde_json::{Value, json};
+
+use crate::commands::{CommandSpec, always, bad, bool_p, str_p};
+use crate::shortcut_presets::{self as presets, Entry};
+use crate::{EngineError, Session};
+
+pub const APPLICATION: &str = "Application";
+
+/// Panels that can have panel-specific shortcuts (the shortcut editor's "Commands" menu).
+pub const PANELS: &[&str] = &[
+    "Timeline",
+    "Program",
+    "Source",
+    "Project",
+    "Effect Controls",
+    "Effects",
+    "History",
+    "Markers",
+    "Media Browser",
+    "Audio Track Mixer",
+    "Audio Clip Mixer",
+    "Essential Graphics",
+    "Text",
+    "Properties",
+    "Lumetri Color",
+];
+
+pub const DEFAULT_PRESET: &str = "FilmCraft Default";
+pub const PREMIERE_PRESET: &str = "Premiere Pro Compatible";
+pub const FCP_PRESET: &str = "Final Cut Pro Compatible";
+pub const AVID_PRESET: &str = "Avid Media Composer Compatible";
+pub const BUILTIN_PRESETS: [&str; 4] = [DEFAULT_PRESET, PREMIERE_PRESET, FCP_PRESET, AVID_PRESET];
+
+const FILE_FORMAT: &str = "filmcraft-keyboard-shortcuts";
+const DIR_NAME: &str = "Keyboard Shortcuts";
+const ACTIVE_FILE: &str = "active.json";
+
+/// Every key the editor's keyboard shows, in canonical spelling (row order).
+pub const KEYS: &[&str] = &[
+    "Escape",
+    "F1",
+    "F2",
+    "F3",
+    "F4",
+    "F5",
+    "F6",
+    "F7",
+    "F8",
+    "F9",
+    "F10",
+    "F11",
+    "F12", //
+    "`",
+    "1",
+    "2",
+    "3",
+    "4",
+    "5",
+    "6",
+    "7",
+    "8",
+    "9",
+    "0",
+    "-",
+    "=",
+    "Backspace", //
+    "Tab",
+    "Q",
+    "W",
+    "E",
+    "R",
+    "T",
+    "Y",
+    "U",
+    "I",
+    "O",
+    "P",
+    "[",
+    "]",
+    "\\", //
+    "A",
+    "S",
+    "D",
+    "F",
+    "G",
+    "H",
+    "J",
+    "K",
+    "L",
+    ";",
+    "'",
+    "Enter", //
+    "Z",
+    "X",
+    "C",
+    "V",
+    "B",
+    "N",
+    "M",
+    ",",
+    ".",
+    "/", //
+    "Space",
+    "Insert",
+    "Delete",
+    "Home",
+    "End",
+    "PageUp",
+    "PageDown",
+    "Up",
+    "Down",
+    "Left",
+    "Right",
+];
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum Platform {
+    Mac,
+    Windows,
+    Linux,
+}
+
+impl Platform {
+    pub fn current() -> Self {
+        if cfg!(target_os = "macos") {
+            Platform::Mac
+        } else if cfg!(windows) {
+            Platform::Windows
+        } else {
+            Platform::Linux
+        }
+    }
+    pub fn from_name(s: &str) -> Option<Self> {
+        match s.to_ascii_lowercase().as_str() {
+            "mac" | "macos" | "osx" | "darwin" => Some(Platform::Mac),
+            "windows" | "win" => Some(Platform::Windows),
+            "linux" => Some(Platform::Linux),
+            _ => None,
+        }
+    }
+    pub fn is_mac(self) -> bool {
+        self == Platform::Mac
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
+pub struct Mods {
+    pub cmd: bool,
+    pub ctrl: bool,
+    pub alt: bool,
+    pub shift: bool,
+}
+
+impl Mods {
+    pub fn count(self) -> u8 {
+        self.cmd as u8 + self.ctrl as u8 + self.alt as u8 + self.shift as u8
+    }
+    /// Canonical prefix, e.g. `Cmd+Alt+`.
+    pub fn prefix(self) -> String {
+        let mut s = String::new();
+        for (on, n) in [(self.cmd, "Cmd+"), (self.ctrl, "Ctrl+"), (self.alt, "Alt+"), (self.shift, "Shift+")] {
+            if on {
+                s.push_str(n);
+            }
+        }
+        s
+    }
+}
+
+/// A key plus modifiers.
+#[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub struct Chord {
+    pub mods: Mods,
+    pub key: &'static str,
+}
+
+fn canon_key(tok: &str) -> Option<&'static str> {
+    if let Some(k) = KEYS.iter().find(|k| k.eq_ignore_ascii_case(tok)) {
+        return Some(k);
+    }
+    let t = tok.to_ascii_lowercase().replace([' ', '_'], "");
+    Some(match t.as_str() {
+        "return" | "⏎" | "↩" | "numpadenter" => "Enter",
+        "esc" | "⎋" => "Escape",
+        "del" | "forwarddelete" | "fwddelete" | "⌦" => "Delete",
+        "⌫" | "back" => "Backspace",
+        "arrowup" | "↑" => "Up",
+        "arrowdown" | "↓" => "Down",
+        "arrowleft" | "←" => "Left",
+        "arrowright" | "→" => "Right",
+        "pgup" | "pageup" => "PageUp",
+        "pgdn" | "pagedown" => "PageDown",
+        "spacebar" | "␣" => "Space",
+        "help" | "ins" => "Insert",
+        "⇥" => "Tab",
+        "grave" | "backtick" | "backquote" => "`",
+        "minus" => "-",
+        "equal" | "equals" => "=",
+        "semicolon" => ";",
+        "quote" | "apostrophe" => "'",
+        "comma" => ",",
+        "period" | "dot" => ".",
+        "slash" => "/",
+        "backslash" => "\\",
+        "openbracket" | "bracketleft" => "[",
+        "closebracket" | "bracketright" => "]",
+        _ => return None,
+    })
+}
+
+impl Chord {
+    /// Parse canonical (or macOS-style) text: `Cmd+Shift+K`, `⌥⌘K`, `opt+left`…
+    pub fn parse(s: &str) -> std::result::Result<Chord, String> {
+        Self::parse_for(s, Platform::Mac)
+    }
+
+    /// Parse text written for `platform` (on Windows/Linux `Ctrl` is the primary modifier).
+    pub fn parse_for(s: &str, platform: Platform) -> std::result::Result<Chord, String> {
+        let s = s.trim();
+        if s.is_empty() {
+            return Err("empty shortcut".into());
+        }
+        // glyph runs like "⌥⇧⌘K" → tokens
+        let mut text = String::new();
+        for ch in s.chars() {
+            match ch {
+                '⌘' => text.push_str("Cmd+"),
+                '⌃' => text.push_str("Ctrl+"),
+                '⌥' => text.push_str("Alt+"),
+                '⇧' => text.push_str("Shift+"),
+                c => text.push(c),
+            }
+        }
+        let text = text.replace("++", "+").trim_end_matches('+').to_string();
+        let mut mods = Mods::default();
+        let mut key = None;
+        let parts: Vec<&str> = text.split('+').map(str::trim).filter(|p| !p.is_empty()).collect();
+        for (i, p) in parts.iter().enumerate() {
+            let low = p.to_ascii_lowercase();
+            let is_last = i + 1 == parts.len();
+            match low.as_str() {
+                "cmd" | "command" | "super" => mods.cmd = true,
+                "meta" | "win" | "windows" if !platform.is_mac() => mods.ctrl = true,
+                "meta" => mods.cmd = true,
+                "ctrl" | "control" | "ctl" => {
+                    if platform.is_mac() {
+                        mods.ctrl = true
+                    } else {
+                        mods.cmd = true
+                    }
+                }
+                "alt" | "opt" | "option" => mods.alt = true,
+                "shift" => mods.shift = true,
+                _ if is_last => key = Some(canon_key(p).ok_or_else(|| format!("unknown key `{p}`"))?),
+                _ => return Err(format!("unknown modifier `{p}`")),
+            }
+        }
+        let key = key.ok_or_else(|| format!("`{s}` has no key"))?;
+        Ok(Chord { mods, key })
+    }
+
+    pub fn canonical(&self) -> String {
+        format!("{}{}", self.mods.prefix(), self.key)
+    }
+
+    /// The chord as this OS sees it: off macOS the Control key is the primary modifier, so `Ctrl`
+    /// and `Cmd` are the same key.
+    pub fn effective(&self, p: Platform) -> Chord {
+        let mut c = self.clone();
+        if !p.is_mac() && c.mods.ctrl {
+            c.mods.ctrl = false;
+            c.mods.cmd = true;
+        }
+        c
+    }
+
+    /// Human text: `⌥⇧⌘K` on macOS, `Ctrl+Alt+Shift+K` elsewhere.
+    pub fn display(&self, p: Platform) -> String {
+        if p.is_mac() {
+            let mut s = String::new();
+            for (on, g) in [(self.mods.ctrl, "⌃"), (self.mods.alt, "⌥"), (self.mods.shift, "⇧"), (self.mods.cmd, "⌘")] {
+                if on {
+                    s.push_str(g);
+                }
+            }
+            let k = match self.key {
+                "Backspace" => "⌫",
+                "Delete" => "⌦",
+                "Enter" => "↩",
+                "Escape" => "⎋",
+                "Tab" => "⇥",
+                "Left" => "←",
+                "Right" => "→",
+                "Up" => "↑",
+                "Down" => "↓",
+                "PageUp" => "Page Up",
+                "PageDown" => "Page Down",
+                k => k,
+            };
+            s.push_str(k);
+            s
+        } else {
+            let e = self.effective(p);
+            let mut s = String::new();
+            for (on, n) in [(e.mods.cmd, "Ctrl+"), (e.mods.alt, "Alt+"), (e.mods.shift, "Shift+")] {
+                if on {
+                    s.push_str(n);
+                }
+            }
+            s.push_str(match self.key {
+                "PageUp" => "Page Up",
+                "PageDown" => "Page Down",
+                k => k,
+            });
+            s
+        }
+    }
+}
+
+/// Canonical spelling of a chord (`opt+cmd+k` → `Cmd+Alt+K`).
+pub fn normalize(s: &str) -> std::result::Result<String, String> {
+    Chord::parse(s).map(|c| c.canonical())
+}
+
+/// One key binding. `panel: None` = application-wide.
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Binding {
+    pub command: String,
+    pub keys: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub panel: Option<String>,
+}
+
+impl Binding {
+    fn new(command: &str, keys: &str, panel: Option<&str>) -> Self {
+        Binding { command: command.to_string(), keys: normalize(keys).unwrap_or_else(|_| keys.to_string()), panel: panel.map(str::to_string) }
+    }
+    fn chord(&self) -> Option<Chord> {
+        Chord::parse(&self.keys).ok()
+    }
+    fn context(&self) -> &str {
+        self.panel.as_deref().unwrap_or(APPLICATION)
+    }
+}
+
+/// A command that can be bound (engine command or one registered by the frontend).
+#[derive(Clone, Debug, Serialize)]
+pub struct CommandInfo {
+    pub id: String,
+    pub label: String,
+    pub category: String,
+    pub menu: Vec<String>,
+    /// Default bindings: (keys, panel).
+    #[serde(skip)]
+    pub defaults: Vec<(String, Option<String>)>,
+}
+
+impl CommandInfo {
+    pub fn new(id: &str, label: &str, menu: &[&str], default: Option<&str>) -> Self {
+        CommandInfo {
+            id: id.into(),
+            label: label.into(),
+            category: category_of(id, menu),
+            menu: menu.iter().map(|s| s.to_string()).collect(),
+            defaults: default.map(|k| vec![(k.to_string(), None)]).unwrap_or_default(),
+        }
+    }
+}
+
+fn category_of(id: &str, menu: &[&str]) -> String {
+    let prefix = id.split('.').next().unwrap_or("");
+    match prefix {
+        "tool" => "Tools".into(),
+        "playback" => "Playback".into(),
+        "playhead" => "Navigation".into(),
+        "trim" => "Trimming".into(),
+        "window" => "Window".into(),
+        "view" => "View".into(),
+        "app" | "help" | "mode" => "Application".into(),
+        "captions" => "Captions".into(),
+        _ => menu.first().map(|s| s.to_string()).unwrap_or_else(|| {
+            let mut c = prefix.chars();
+            c.next().map(|f| f.to_uppercase().collect::<String>() + c.as_str()).unwrap_or_default()
+        }),
+    }
+}
+
+/// Engine commands worth binding: undoable actions that need no required parameters.
+fn bindable(c: &CommandSpec) -> bool {
+    if !c.journal || c.id.starts_with("shortcuts.") || c.id.starts_with("prefs.") || c.id == "trim.tick" {
+        return false;
+    }
+    if c.shortcut.is_some() {
+        return true;
+    }
+    let body = c.params.trim().trim_start_matches('{').trim_end_matches('}');
+    if body.trim().is_empty() {
+        return true;
+    }
+    let mut depth = 0;
+    let mut fields = vec![String::new()];
+    for ch in body.chars() {
+        match ch {
+            '[' | '{' => depth += 1,
+            ']' | '}' => depth -= 1,
+            ',' if depth == 0 => {
+                fields.push(String::new());
+                continue;
+            }
+            _ => {}
+        }
+        fields.last_mut().expect("field").push(ch);
+    }
+    fields.iter().all(|f| f.contains('?') || f.contains('='))
+}
+
+/// The preset file / `active.json` format.
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct PresetFile {
+    pub format: String,
+    pub version: u32,
+    pub name: String,
+    /// The OS the key names were written for; None = canonical (FilmCraft) notation.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub platform: Option<Platform>,
+    /// `active.json` only: the active set differs from the preset it started from.
+    #[serde(default)]
+    pub modified: bool,
+    pub bindings: Vec<Binding>,
+}
+
+#[derive(Clone, Debug)]
+struct Snapshot {
+    bindings: Vec<Binding>,
+    preset: String,
+    modified: bool,
+}
+
+/// The active key bindings and their editing history.
+#[derive(Clone, Debug)]
+pub struct Shortcuts {
+    pub bindings: Vec<Binding>,
+    /// Preset the active set came from (or was saved as).
+    pub preset: String,
+    /// Edited since the preset was loaded.
+    pub modified: bool,
+    /// Bumped on every change (frontends rebuild key maps and menus).
+    pub revision: u64,
+    undo: Vec<Snapshot>,
+    redo: Vec<Snapshot>,
+    external: Vec<CommandInfo>,
+    dir: Option<PathBuf>,
+    /// The editor dialog's starting point (Cancel restores it).
+    session_start: Option<Snapshot>,
+}
+
+impl Default for Shortcuts {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Shortcuts {
+    pub fn new() -> Self {
+        let mut s = Shortcuts {
+            bindings: Vec::new(),
+            preset: DEFAULT_PRESET.into(),
+            modified: false,
+            revision: 1,
+            undo: Vec::new(),
+            redo: Vec::new(),
+            external: Vec::new(),
+            dir: None,
+            session_start: None,
+        };
+        s.bindings = s.builtin(DEFAULT_PRESET).expect("default preset");
+        s
+    }
+
+    // ---------------------------------------------------------------- commands
+
+    /// Every bindable command (engine + frontend), in registry order.
+    pub fn commands(&self) -> Vec<CommandInfo> {
+        let mut v: Vec<CommandInfo> =
+            crate::commands::command_specs().iter().filter(|c| bindable(c)).map(|c| CommandInfo::new(c.id, c.label, c.menu, c.shortcut)).collect();
+        for e in &self.external {
+            if !v.iter().any(|c| c.id == e.id) {
+                v.push(e.clone());
+            }
+        }
+        v
+    }
+
+    pub fn command(&self, id: &str) -> Option<CommandInfo> {
+        self.commands().into_iter().find(|c| c.id == id)
+    }
+
+    fn known(&self, id: &str) -> bool {
+        crate::commands::find(id).is_some() || self.external.iter().any(|c| c.id == id)
+    }
+
+    /// Commands owned by the frontend (tools, transport, panels…). Rebuilds the active set when it
+    /// is an unmodified built-in preset, so their defaults appear.
+    pub fn register_external(&mut self, cmds: Vec<CommandInfo>) {
+        self.external = cmds;
+        if !self.modified
+            && let Some(b) = self.builtin(&self.preset.clone())
+        {
+            self.bindings = b;
+            self.revision += 1;
+        }
+    }
+
+    // ---------------------------------------------------------------- presets
+
+    /// Default bindings of every known command, plus FilmCraft's panel shortcuts.
+    fn base_defaults(&self) -> Vec<Binding> {
+        let mut out = Vec::new();
+        for c in self.commands() {
+            for (k, p) in &c.defaults {
+                out.push(Binding::new(&c.id, k, p.as_deref()));
+            }
+        }
+        for (c, k, p) in presets::FILMCRAFT_PANEL {
+            if self.known(c) {
+                out.push(Binding::new(c, k, panel_opt(p)));
+            }
+        }
+        out
+    }
+
+    /// Premiere-default entries FilmCraft Default adopts: commands with no shortcut of their own
+    /// whose Premiere key is free in that context.
+    pub fn audit(&self) -> Vec<Binding> {
+        let base = self.base_defaults();
+        let mut added: Vec<Binding> = Vec::new();
+        for (c, k, p) in presets::PREMIERE {
+            if !self.known(c) || base.iter().any(|b| b.command == *c) {
+                continue;
+            }
+            let b = Binding::new(c, k, panel_opt(p));
+            let taken = base.iter().chain(added.iter()).any(|o| o.context() == b.context() && o.chord() == b.chord());
+            if !taken {
+                added.push(b);
+            }
+        }
+        added
+    }
+
+    /// The bindings of a built-in preset.
+    pub fn builtin(&self, name: &str) -> Option<Vec<Binding>> {
+        let mut b = self.base_defaults();
+        b.extend(self.audit());
+        let table: &[Entry] = match name {
+            DEFAULT_PRESET => &[],
+            PREMIERE_PRESET => presets::PREMIERE,
+            FCP_PRESET => presets::FINAL_CUT,
+            AVID_PRESET => presets::AVID,
+            _ => return None,
+        };
+        self.apply_table(&mut b, table);
+        Some(b)
+    }
+
+    /// Apply a preset table: listed commands get exactly the listed keys, and a listed key is taken
+    /// away from whatever else had it in that context.
+    fn apply_table(&self, b: &mut Vec<Binding>, table: &[Entry]) {
+        let listed: Vec<&str> = table.iter().map(|e| e.0).filter(|c| self.known(c)).collect();
+        b.retain(|x| !listed.contains(&x.command.as_str()));
+        for (c, k, p) in table {
+            if !self.known(c) {
+                continue;
+            }
+            let nb = Binding::new(c, k, panel_opt(p));
+            b.retain(|o| !(o.context() == nb.context() && o.chord() == nb.chord()));
+            b.push(nb);
+        }
+    }
+
+    fn presets_dir(&self) -> Option<PathBuf> {
+        self.dir.as_ref().map(|d| d.join(DIR_NAME))
+    }
+
+    /// Custom preset names (files in the presets directory).
+    pub fn user_presets(&self) -> Vec<String> {
+        let Some(dir) = self.presets_dir() else { return Vec::new() };
+        let Ok(rd) = std::fs::read_dir(dir) else { return Vec::new() };
+        let mut v: Vec<String> = rd
+            .flatten()
+            .filter(|e| e.file_name() != ACTIVE_FILE)
+            .filter_map(|e| std::fs::read(e.path()).ok().and_then(|b| serde_json::from_slice::<PresetFile>(&b).ok()).map(|p| p.name))
+            .filter(|n| !BUILTIN_PRESETS.contains(&n.as_str()))
+            .collect();
+        v.sort();
+        v.dedup();
+        v
+    }
+
+    fn preset_path(&self, name: &str) -> Option<PathBuf> {
+        let safe: String = name.chars().map(|c| if c.is_alphanumeric() || " -_().".contains(c) { c } else { '_' }).collect();
+        self.presets_dir().map(|d| d.join(format!("{}.json", safe.trim())))
+    }
+
+    /// Use the per-user data directory: loads the active set saved there (if any).
+    pub fn set_dir(&mut self, data_dir: &Path) {
+        self.dir = Some(data_dir.to_path_buf());
+        let Some(path) = self.presets_dir().map(|d| d.join(ACTIVE_FILE)) else { return };
+        let Ok(bytes) = std::fs::read(&path) else { return };
+        match serde_json::from_slice::<PresetFile>(&bytes) {
+            Ok(f) => {
+                self.preset = f.name.clone();
+                if !f.modified
+                    && let Some(b) = self.builtin(&f.name)
+                {
+                    self.bindings = b;
+                    self.modified = false;
+                } else {
+                    self.bindings = convert(f.bindings, f.platform);
+                    self.modified = f.modified;
+                }
+                self.revision += 1;
+            }
+            Err(e) => log::warn!("{}: {e}", path.display()),
+        }
+    }
+
+    fn file(&self, name: &str, modified: bool) -> PresetFile {
+        PresetFile { format: FILE_FORMAT.into(), version: 1, name: name.into(), platform: None, modified, bindings: self.bindings.clone() }
+    }
+
+    fn persist(&self) {
+        let Some(dir) = self.presets_dir() else { return };
+        let f = self.file(&self.preset, self.modified);
+        if let Err(e) = std::fs::create_dir_all(&dir)
+            .and_then(|_| filmcraft_format::atomic_write(&dir.join(ACTIVE_FILE), &serde_json::to_vec_pretty(&f).unwrap_or_default()))
+        {
+            log::warn!("saving keyboard shortcuts: {e}");
+        }
+    }
+
+    // ---------------------------------------------------------------- editing
+
+    fn snapshot(&self) -> Snapshot {
+        Snapshot { bindings: self.bindings.clone(), preset: self.preset.clone(), modified: self.modified }
+    }
+
+    fn restore(&mut self, s: Snapshot) {
+        self.bindings = s.bindings;
+        self.preset = s.preset;
+        self.modified = s.modified;
+    }
+
+    fn changed(&mut self, before: Snapshot) {
+        self.undo.push(before);
+        if self.undo.len() > 500 {
+            self.undo.remove(0);
+        }
+        self.redo.clear();
+        self.revision += 1;
+        self.persist();
+    }
+
+    /// Assign `keys` to `command`. Unless `add`, the command's other shortcuts in that context are
+    /// replaced. Unless `keep_conflicts`, the key is taken away from any other command bound to it
+    /// in the same context (returned as `reassigned`).
+    pub fn set(&mut self, command: &str, keys: &str, panel: Option<&str>, add: bool, keep_conflicts: bool) -> std::result::Result<Vec<Binding>, String> {
+        if !self.known(command) {
+            return Err(format!("unknown command `{command}`"));
+        }
+        let panel = check_panel(panel)?;
+        let chord = Chord::parse(keys)?;
+        let nb = Binding { command: command.into(), keys: chord.canonical(), panel: panel.map(str::to_string) };
+        let before = self.snapshot();
+        if !add {
+            self.bindings.retain(|b| !(b.command == command && b.context() == nb.context()));
+        }
+        let mut reassigned = Vec::new();
+        if !keep_conflicts {
+            let p = Platform::current();
+            let eff = chord.effective(p);
+            self.bindings.retain(|b| {
+                let clash = b.command != command && b.context() == nb.context() && b.chord().is_some_and(|c| c.effective(p) == eff);
+                if clash {
+                    reassigned.push(b.clone());
+                }
+                !clash
+            });
+        }
+        if !self.bindings.contains(&nb) {
+            self.bindings.push(nb);
+        }
+        self.modified = true;
+        self.changed(before);
+        Ok(reassigned)
+    }
+
+    /// Remove shortcuts of `command` (one key, or all; in one context, or all).
+    pub fn clear(&mut self, command: &str, keys: Option<&str>, panel: Option<&str>) -> std::result::Result<usize, String> {
+        let chord = keys.map(Chord::parse).transpose()?;
+        let panel = match panel {
+            Some(p) => Some(check_panel(Some(p))?.map(str::to_string)),
+            None => None,
+        };
+        let before = self.snapshot();
+        let n0 = self.bindings.len();
+        self.bindings.retain(|b| {
+            let hit = b.command == command && chord.as_ref().is_none_or(|c| b.chord().as_ref() == Some(c)) && panel.as_ref().is_none_or(|p| &b.panel == p);
+            !hit
+        });
+        let n = n0 - self.bindings.len();
+        if n > 0 {
+            self.modified = true;
+            self.changed(before);
+        }
+        Ok(n)
+    }
+
+    pub fn undo(&mut self) -> bool {
+        let Some(s) = self.undo.pop() else { return false };
+        let cur = self.snapshot();
+        self.redo.push(cur);
+        self.restore(s);
+        self.revision += 1;
+        self.persist();
+        true
+    }
+
+    pub fn redo(&mut self) -> bool {
+        let Some(s) = self.redo.pop() else { return false };
+        let cur = self.snapshot();
+        self.undo.push(cur);
+        self.restore(s);
+        self.revision += 1;
+        self.persist();
+        true
+    }
+
+    pub fn can_undo(&self) -> bool {
+        !self.undo.is_empty()
+    }
+    pub fn can_redo(&self) -> bool {
+        !self.redo.is_empty()
+    }
+
+    /// The shortcut editor opened: remember where Cancel goes back to.
+    pub fn begin_editing(&mut self) {
+        self.session_start = Some(self.snapshot());
+        self.undo.clear();
+        self.redo.clear();
+    }
+
+    /// OK: keep the edits.
+    pub fn end_editing(&mut self) {
+        self.session_start = None;
+    }
+
+    /// Cancel: restore the set the editor opened with.
+    pub fn cancel_editing(&mut self) {
+        if let Some(s) = self.session_start.take() {
+            self.restore(s);
+            self.undo.clear();
+            self.redo.clear();
+            self.revision += 1;
+            self.persist();
+        }
+    }
+
+    pub fn load_preset(&mut self, name: &str) -> std::result::Result<(), String> {
+        let bindings = match self.builtin(name) {
+            Some(b) => b,
+            None => {
+                let path = self.preset_path(name).ok_or("no data directory for custom presets")?;
+                let f = read_file(&path)?;
+                convert(f.bindings, f.platform)
+            }
+        };
+        let before = self.snapshot();
+        self.bindings = bindings;
+        self.preset = name.into();
+        self.modified = false;
+        self.changed(before);
+        Ok(())
+    }
+
+    pub fn save_preset(&mut self, name: &str) -> std::result::Result<PathBuf, String> {
+        let name = name.trim();
+        if name.is_empty() {
+            return Err("a preset needs a name".into());
+        }
+        if BUILTIN_PRESETS.iter().any(|b| b.eq_ignore_ascii_case(name)) {
+            return Err(format!("`{name}` is a built-in preset; choose another name"));
+        }
+        let path = self.preset_path(name).ok_or("no data directory for custom presets")?;
+        write_file(&path, &self.file(name, false))?;
+        let before = self.snapshot();
+        self.preset = name.into();
+        self.modified = false;
+        self.changed(before);
+        Ok(path)
+    }
+
+    pub fn delete_preset(&mut self, name: &str) -> std::result::Result<(), String> {
+        if BUILTIN_PRESETS.contains(&name) {
+            return Err("built-in presets cannot be deleted".into());
+        }
+        let path = self.preset_path(name).ok_or("no data directory for custom presets")?;
+        std::fs::remove_file(&path).map_err(|e| format!("{}: {e}", path.display()))?;
+        if self.preset == name {
+            self.modified = true;
+            self.revision += 1;
+            self.persist();
+        }
+        Ok(())
+    }
+
+    pub fn export(&self, path: &Path) -> std::result::Result<(), String> {
+        write_file(path, &self.file(&self.preset, false))
+    }
+
+    /// Import a preset file: saved among the custom presets (when there is a data directory) and,
+    /// when `activate`, made the active set.
+    pub fn import(&mut self, path: &Path, activate: bool) -> std::result::Result<String, String> {
+        let f = read_file(path)?;
+        let name = if f.name.trim().is_empty() || BUILTIN_PRESETS.contains(&f.name.as_str()) {
+            path.file_stem().map(|s| s.to_string_lossy().to_string()).unwrap_or_else(|| "Imported".into())
+        } else {
+            f.name.clone()
+        };
+        let bindings: Vec<Binding> = convert(f.bindings, f.platform).into_iter().filter(|b| self.known(&b.command)).collect();
+        if let Some(p) = self.preset_path(&name) {
+            let file = PresetFile { format: FILE_FORMAT.into(), version: 1, name: name.clone(), platform: None, modified: false, bindings: bindings.clone() };
+            write_file(&p, &file)?;
+        }
+        if activate {
+            let before = self.snapshot();
+            self.bindings = bindings;
+            self.preset = name.clone();
+            self.modified = false;
+            self.changed(before);
+        }
+        Ok(name)
+    }
+
+    // ---------------------------------------------------------------- queries
+
+    pub fn for_command(&self, id: &str) -> Vec<&Binding> {
+        self.bindings.iter().filter(|b| b.command == id).collect()
+    }
+
+    /// The shortcut menus show: the first application-wide one.
+    pub fn primary(&self, id: &str) -> Option<String> {
+        self.bindings.iter().find(|b| b.command == id && b.panel.is_none()).map(|b| b.keys.clone())
+    }
+
+    /// The command a chord runs with `panel` focused (panel shortcuts first).
+    pub fn resolve(&self, chord: &Chord, panel: Option<&str>, p: Platform) -> Option<&Binding> {
+        let eff = chord.effective(p);
+        let m = |b: &&Binding| b.chord().is_some_and(|c| c.effective(p) == eff);
+        if let Some(pn) = panel
+            && let Some(b) = self.bindings.iter().filter(|b| b.panel.as_deref() == Some(pn)).find(m)
+        {
+            return Some(b);
+        }
+        self.bindings.iter().filter(|b| b.panel.is_none()).find(m)
+    }
+
+    /// Groups of bindings that share a key in one context on platform `p`.
+    pub fn conflicts(&self, p: Platform) -> Vec<(String, String, Vec<String>)> {
+        let mut map: BTreeMap<(String, String), Vec<String>> = BTreeMap::new();
+        for b in &self.bindings {
+            let Some(c) = b.chord() else { continue };
+            let e = map.entry((b.context().to_string(), c.effective(p).canonical())).or_default();
+            if !e.contains(&b.command) {
+                e.push(b.command.clone());
+            }
+        }
+        map.into_iter().filter(|(_, v)| v.len() > 1).map(|((ctx, k), v)| (ctx, k, v)).collect()
+    }
+
+    /// Panel shortcuts that shadow an application shortcut while their panel has focus.
+    pub fn overrides(&self, p: Platform) -> Vec<(String, String, String, String)> {
+        let mut out = Vec::new();
+        for b in self.bindings.iter().filter(|b| b.panel.is_some()) {
+            let Some(c) = b.chord() else { continue };
+            if let Some(a) = self.resolve(&c, None, p)
+                && a.command != b.command
+            {
+                out.push((b.panel.clone().unwrap_or_default(), b.keys.clone(), b.command.clone(), a.command.clone()));
+            }
+        }
+        out
+    }
+
+    /// Bindings on one key (any modifiers): the shortcut editor's "Key:" list.
+    pub fn for_key(&self, key: &str) -> Vec<&Binding> {
+        let Some(k) = canon_key(key) else { return Vec::new() };
+        let mut v: Vec<&Binding> = self.bindings.iter().filter(|b| b.chord().is_some_and(|c| c.key == k)).collect();
+        v.sort_by_key(|b| b.chord().map(|c| (c.mods.count(), c.mods)));
+        v
+    }
+
+    /// Commands assigned with exactly `mods` held, per key: (application command, panel command).
+    pub fn keyboard(&self, mods: Mods, panel: Option<&str>) -> BTreeMap<&'static str, (Option<String>, Option<String>)> {
+        let mut m: BTreeMap<&'static str, (Option<String>, Option<String>)> = BTreeMap::new();
+        for b in &self.bindings {
+            let Some(c) = b.chord() else { continue };
+            if c.mods != mods {
+                continue;
+            }
+            let e = m.entry(c.key).or_default();
+            match (&b.panel, panel) {
+                (None, _) => {
+                    e.0.get_or_insert(b.command.clone());
+                }
+                (Some(bp), Some(p)) if bp == p => {
+                    e.1.get_or_insert(b.command.clone());
+                }
+                (Some(_), None) => {
+                    e.1.get_or_insert(b.command.clone());
+                }
+                _ => {}
+            }
+        }
+        m
+    }
+
+    fn binding_json(&self, b: &Binding, p: Platform) -> Value {
+        json!({"keys": b.keys, "panel": b.panel, "display": b.chord().map(|c| c.display(p)).unwrap_or_else(|| b.keys.clone())})
+    }
+}
+
+fn panel_opt(p: &str) -> Option<&str> {
+    if p.is_empty() { None } else { Some(p) }
+}
+
+fn check_panel(panel: Option<&str>) -> std::result::Result<Option<&'static str>, String> {
+    match panel {
+        None => Ok(None),
+        Some(p) if p.is_empty() || p.eq_ignore_ascii_case(APPLICATION) => Ok(None),
+        Some(p) => {
+            let n = p.to_ascii_lowercase().replace([' ', '_', '-'], "");
+            let alias = match n.as_str() {
+                "programmonitor" => "program",
+                "sourcemonitor" => "source",
+                "projects" => "project",
+                "timelines" => "timeline",
+                _ => n.as_str(),
+            };
+            PANELS
+                .iter()
+                .copied()
+                .find(|x| x.to_ascii_lowercase().replace(' ', "") == alias)
+                .map(Some)
+                .ok_or_else(|| format!("unknown panel `{p}` (one of {})", PANELS.join(", ")))
+        }
+    }
+}
+
+/// Normalise bindings read from a file written for `platform`.
+fn convert(bindings: Vec<Binding>, platform: Option<Platform>) -> Vec<Binding> {
+    let p = platform.unwrap_or(Platform::Mac);
+    bindings
+        .into_iter()
+        .filter_map(|b| {
+            let c = Chord::parse_for(&b.keys, p).ok()?;
+            let panel = check_panel(b.panel.as_deref()).ok()?.map(str::to_string);
+            Some(Binding { command: b.command, keys: c.canonical(), panel })
+        })
+        .collect()
+}
+
+fn read_file(path: &Path) -> std::result::Result<PresetFile, String> {
+    let bytes = std::fs::read(path).map_err(|e| format!("{}: {e}", path.display()))?;
+    let f: PresetFile = serde_json::from_slice(&bytes).map_err(|e| format!("{}: {e}", path.display()))?;
+    if f.format != FILE_FORMAT {
+        return Err(format!("{}: not a FilmCraft keyboard shortcuts file", path.display()));
+    }
+    Ok(f)
+}
+
+fn write_file(path: &Path, f: &PresetFile) -> std::result::Result<(), String> {
+    if let Some(d) = path.parent() {
+        std::fs::create_dir_all(d).map_err(|e| format!("{}: {e}", d.display()))?;
+    }
+    filmcraft_format::atomic_write(path, &serde_json::to_vec_pretty(f).unwrap_or_default()).map_err(|e| format!("{}: {e}", path.display()))
+}
+
+// ------------------------------------------------------------------ commands
+
+fn platform_p(p: &Value) -> Platform {
+    str_p(p, "platform").and_then(Platform::from_name).unwrap_or_else(Platform::current)
+}
+
+fn err(cmd: &str) -> impl Fn(String) -> EngineError + '_ {
+    move |m| bad(cmd, m)
+}
+
+fn presets_json(s: &Session) -> Value {
+    let sc = &s.shortcuts;
+    json!({"active": sc.preset, "modified": sc.modified, "builtin": BUILTIN_PRESETS, "custom": sc.user_presets(), "canUndo": sc.can_undo(), "canRedo": sc.can_redo()})
+}
+
+fn list(s: &Session, p: &Value) -> Value {
+    let sc = &s.shortcuts;
+    let plat = platform_p(p);
+    let q = str_p(p, "query").map(str::to_ascii_lowercase);
+    let assigned_only = bool_p(p, "assigned").unwrap_or(false);
+    let panel = str_p(p, "panel").and_then(|x| check_panel(Some(x)).ok().flatten());
+    let rows: Vec<Value> = sc
+        .commands()
+        .into_iter()
+        .filter_map(|c| {
+            let bs: Vec<&Binding> = sc.for_command(&c.id).into_iter().filter(|b| panel.is_none() || b.panel.as_deref() == panel).collect();
+            if assigned_only && bs.is_empty() {
+                return None;
+            }
+            if let Some(q) = &q {
+                let hit = c.label.to_ascii_lowercase().contains(q.as_str())
+                    || c.id.to_ascii_lowercase().contains(q.as_str())
+                    || bs.iter().any(|b| b.keys.to_ascii_lowercase().contains(q.as_str()) || b.chord().is_some_and(|ch| ch.display(plat).to_ascii_lowercase().contains(q.as_str())));
+                if !hit {
+                    return None;
+                }
+            }
+            Some(json!({"id": c.id, "label": c.label, "category": c.category, "menu": c.menu, "shortcuts": bs.iter().map(|b| sc.binding_json(b, plat)).collect::<Vec<_>>()}))
+        })
+        .collect();
+    json!(rows)
+}
+
+pub fn commands() -> Vec<CommandSpec> {
+    macro_rules! sc {
+        ($id:literal, $label:literal, $params:literal, $journal:expr, $run:expr) => {
+            CommandSpec { id: $id, label: $label, menu: &[], shortcut: None, params: $params, enabled: always, run: $run, journal: $journal }
+        };
+    }
+    vec![
+        sc!("shortcuts.list", "List Keyboard Shortcuts", r#"{"query":str?,"panel":str?,"assigned":bool?,"platform":"mac|windows|linux"?}"#, false, |s, p| Ok(
+            list(s, p)
+        )),
+        sc!("shortcuts.get", "Get Shortcuts of a Command", r#"{"command":id,"platform":str?}"#, false, |s, p| {
+            let id = str_p(p, "command").ok_or_else(|| bad("shortcuts.get", "need `command`"))?;
+            let c = s.shortcuts.command(id).ok_or_else(|| bad("shortcuts.get", format!("unknown command `{id}`")))?;
+            let plat = platform_p(p);
+            let bs: Vec<Value> = s.shortcuts.for_command(id).into_iter().map(|b| s.shortcuts.binding_json(b, plat)).collect();
+            Ok(json!({"id": c.id, "label": c.label, "category": c.category, "shortcuts": bs}))
+        }),
+        sc!("shortcuts.set", "Assign Shortcut", r#"{"command":id,"keys":"Cmd+Shift+K","panel":str?,"add":bool?,"keepConflicts":bool?}"#, true, |s, p| {
+            let id = str_p(p, "command").ok_or_else(|| bad("shortcuts.set", "need `command`"))?;
+            let keys = str_p(p, "keys").ok_or_else(|| bad("shortcuts.set", "need `keys`"))?;
+            let r = s
+                .shortcuts
+                .set(id, keys, str_p(p, "panel"), bool_p(p, "add").unwrap_or(false), bool_p(p, "keepConflicts").unwrap_or(false))
+                .map_err(err("shortcuts.set"))?;
+            let plat = Platform::current();
+            let conflicts: Vec<Value> = s.shortcuts.conflicts(plat).into_iter().map(|(c, k, v)| json!({"context": c, "keys": k, "commands": v})).collect();
+            Ok(json!({"keys": normalize(keys).unwrap_or_default(), "reassigned": r, "conflicts": conflicts}))
+        }),
+        sc!("shortcuts.clear", "Clear Shortcut", r#"{"command":id,"keys":str?,"panel":str?}"#, true, |s, p| {
+            let id = str_p(p, "command").ok_or_else(|| bad("shortcuts.clear", "need `command`"))?;
+            let n = s.shortcuts.clear(id, str_p(p, "keys"), str_p(p, "panel")).map_err(err("shortcuts.clear"))?;
+            Ok(json!({"removed": n}))
+        }),
+        sc!("shortcuts.undo", "Undo Shortcut Change", "{}", true, |s, _| Ok(json!({"undone": s.shortcuts.undo()}))),
+        sc!("shortcuts.redo", "Redo Shortcut Change", "{}", true, |s, _| Ok(json!({"redone": s.shortcuts.redo()}))),
+        sc!("shortcuts.conflicts", "Shortcut Conflicts", r#"{"platform":"mac|windows|linux"?}"#, false, |s, p| {
+            let plat = platform_p(p);
+            let c: Vec<Value> = s.shortcuts.conflicts(plat).into_iter().map(|(c, k, v)| json!({"context": c, "keys": k, "commands": v})).collect();
+            let o: Vec<Value> =
+                s.shortcuts.overrides(plat).into_iter().map(|(pn, k, cmd, app)| json!({"panel": pn, "keys": k, "command": cmd, "overrides": app})).collect();
+            Ok(json!({"conflicts": c, "panelOverrides": o}))
+        }),
+        sc!("shortcuts.forKey", "Shortcuts on a Key", r#"{"key":"K","platform":str?}"#, false, |s, p| {
+            let k = str_p(p, "key").ok_or_else(|| bad("shortcuts.forKey", "need `key`"))?;
+            let plat = platform_p(p);
+            Ok(json!(
+                s.shortcuts
+                    .for_key(k)
+                    .into_iter()
+                    .map(|b| json!({"keys": b.keys, "display": b.chord().map(|c| c.display(plat)), "command": b.command, "panel": b.panel}))
+                    .collect::<Vec<_>>()
+            ))
+        }),
+        sc!("shortcuts.resolve", "Resolve Shortcut", r#"{"keys":str,"panel":str?,"platform":str?}"#, false, |s, p| {
+            let keys = str_p(p, "keys").ok_or_else(|| bad("shortcuts.resolve", "need `keys`"))?;
+            let c = Chord::parse(keys).map_err(err("shortcuts.resolve"))?;
+            let panel = check_panel(str_p(p, "panel")).map_err(err("shortcuts.resolve"))?;
+            Ok(s.shortcuts.resolve(&c, panel, platform_p(p)).map(|b| json!({"command": b.command, "panel": b.panel})).unwrap_or(Value::Null))
+        }),
+        sc!("shortcuts.presets", "Keyboard Shortcut Presets", "{}", false, |s, _| Ok(presets_json(s))),
+        sc!("shortcuts.loadPreset", "Load Shortcut Preset", r#"{"name":str}"#, true, |s, p| {
+            let n = str_p(p, "name").ok_or_else(|| bad("shortcuts.loadPreset", "need `name`"))?;
+            s.shortcuts.load_preset(n).map_err(err("shortcuts.loadPreset"))?;
+            Ok(presets_json(s))
+        }),
+        sc!("shortcuts.savePreset", "Save Shortcut Preset As", r#"{"name":str}"#, true, |s, p| {
+            let n = str_p(p, "name").ok_or_else(|| bad("shortcuts.savePreset", "need `name`"))?;
+            let path = s.shortcuts.save_preset(n).map_err(err("shortcuts.savePreset"))?;
+            Ok(json!({"path": path, "presets": presets_json(s)}))
+        }),
+        sc!("shortcuts.deletePreset", "Delete Shortcut Preset", r#"{"name":str}"#, true, |s, p| {
+            let n = str_p(p, "name").ok_or_else(|| bad("shortcuts.deletePreset", "need `name`"))?;
+            s.shortcuts.delete_preset(n).map_err(err("shortcuts.deletePreset"))?;
+            Ok(presets_json(s))
+        }),
+        sc!("shortcuts.export", "Export Keyboard Shortcuts", r#"{"path":str}"#, true, |s, p| {
+            let path = str_p(p, "path").ok_or_else(|| bad("shortcuts.export", "need `path`"))?;
+            s.shortcuts.export(Path::new(path)).map_err(err("shortcuts.export"))?;
+            Ok(json!({"path": path, "bindings": s.shortcuts.bindings.len()}))
+        }),
+        sc!("shortcuts.import", "Import Keyboard Shortcuts", r#"{"path":str,"activate":bool=true}"#, true, |s, p| {
+            let path = str_p(p, "path").ok_or_else(|| bad("shortcuts.import", "need `path`"))?;
+            let name = s.shortcuts.import(Path::new(path), bool_p(p, "activate").unwrap_or(true)).map_err(err("shortcuts.import"))?;
+            Ok(json!({"name": name, "presets": presets_json(s)}))
+        }),
+        sc!("shortcuts.audit", "Shortcut Audit", "{}", false, |s, _| {
+            let a = s.shortcuts.audit();
+            Ok(json!({"count": a.len(), "assigned": a}))
+        }),
+    ]
+}
diff --git a/crates/engine/src/shortcuts_tests.rs b/crates/engine/src/shortcuts_tests.rs
new file mode 100644
index 000000000..23dc6dec6
--- /dev/null
+++ b/crates/engine/src/shortcuts_tests.rs
@@ -0,0 +1,215 @@
+//! Keyboard shortcuts: chords, presets, conflicts, panel scope, undo, files.
+
+use super::*;
+use crate::shortcuts::{Binding, Chord, CommandInfo, Platform, Shortcuts};
+use serde_json::json;
+
+fn temp_dir(tag: &str) -> std::path::PathBuf {
+    let d = std::env::temp_dir().join(format!("fc-shortcuts-{tag}-{}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&d);
+    std::fs::create_dir_all(&d).unwrap();
+    d
+}
+
+/// The frontend's commands, as the egui UI registers them (a few are enough here).
+fn with_ui_commands(s: &mut Session) {
+    s.shortcuts.register_external(vec![
+        CommandInfo::new("playback.toggle", "Play/Stop", &[], Some("Space")),
+        CommandInfo::new("playback.forward", "Shuttle Right", &[], Some("L")),
+        CommandInfo::new("playback.slowForward", "Shuttle Slow Right", &[], None),
+        CommandInfo::new("playback.playAround", "Play Around", &[], None),
+        CommandInfo::new("tool.razor", "Razor Tool", &[], Some("C")),
+        CommandInfo::new("app.keyboardShortcuts", "Keyboard Shortcuts…", &["Edit"], Some("Cmd+Alt+K")),
+    ]);
+}
+
+#[test]
+fn chords_parse_normalise_and_display_per_os() {
+    let c = Chord::parse("⌥⇧⌘K").unwrap();
+    assert_eq!(c.canonical(), "Cmd+Alt+Shift+K");
+    assert_eq!(Chord::parse("shift+opt+command+k").unwrap(), c);
+    assert_eq!(c.display(Platform::Mac), "⌥⇧⌘K");
+    assert_eq!(c.display(Platform::Windows), "Ctrl+Alt+Shift+K");
+    assert_eq!(Chord::parse("Return").unwrap().canonical(), "Enter");
+    assert_eq!(Chord::parse("Forward Delete").unwrap().canonical(), "Delete");
+    assert_eq!(Chord::parse("Shift+Left").unwrap().display(Platform::Mac), "⇧←");
+    // Windows text: Ctrl is the primary modifier
+    assert_eq!(Chord::parse_for("Ctrl+Shift+Z", Platform::Windows).unwrap().canonical(), "Cmd+Shift+Z");
+    assert_eq!(Chord::parse_for("Win+T", Platform::Windows).unwrap().canonical(), "Ctrl+T");
+    // macOS Control folds into Ctrl elsewhere
+    assert_eq!(Chord::parse("Ctrl+T").unwrap().effective(Platform::Windows), Chord::parse("Cmd+T").unwrap());
+    assert!(Chord::parse("Cmd+").is_err());
+    assert!(Chord::parse("Hyper+K").is_err());
+}
+
+#[test]
+fn defaults_follow_the_registry_and_the_premiere_audit() {
+    let mut s = Session::default();
+    with_ui_commands(&mut s);
+    let sc = &s.shortcuts;
+    assert_eq!(sc.preset, "FilmCraft Default");
+    assert_eq!(sc.primary("sequence.addEdit").as_deref(), Some("Cmd+K"));
+    assert_eq!(sc.primary("playback.toggle").as_deref(), Some("Space"));
+    // the audit adopts Premiere defaults for commands that had none
+    let audit = sc.audit();
+    let has = |c: &str, k: &str, p: Option<&str>| audit.iter().any(|b| b.command == c && b.keys == k && b.panel.as_deref() == p);
+    assert!(has("trim.applyDefaultTransition", "Shift+D", None), "{audit:?}");
+    assert!(has("playback.slowForward", "Shift+L", None));
+    assert!(has("playback.playAround", "Shift+K", None));
+    assert!(has("source.open", "Shift+O", Some("Project")));
+    assert_eq!(sc.primary("trim.applyDefaultTransition").as_deref(), Some("Shift+D"));
+    // no conflicts in any built-in preset (macOS)
+    for name in crate::shortcuts::BUILTIN_PRESETS {
+        let mut t = Session::default();
+        with_ui_commands(&mut t);
+        t.shortcuts.load_preset(name).unwrap();
+        assert!(t.shortcuts.conflicts(Platform::Mac).is_empty(), "{name}: {:?}", t.shortcuts.conflicts(Platform::Mac));
+    }
+    // command.list reports the live bindings
+    let list = s.execute("command.list", json!({})).unwrap();
+    let ae = list.as_array().unwrap().iter().find(|c| c["id"] == "sequence.addEdit").unwrap();
+    assert_eq!(ae["shortcut"], json!("Cmd+K"));
+}
+
+#[test]
+fn assign_reassigns_conflicts_and_undoes() {
+    let mut s = Session::default();
+    let r = s.execute("shortcuts.set", json!({"command": "edit.undo", "keys": "Cmd+Shift+K"})).unwrap();
+    assert_eq!(r["reassigned"][0]["command"], json!("sequence.addEditAllTracks"), "{r}");
+    assert!(s.shortcuts.primary("sequence.addEditAllTracks").is_none());
+    assert_eq!(s.shortcuts.primary("edit.undo").as_deref(), Some("Cmd+Shift+K"), "replaces Cmd+Z");
+    let hit = s.execute("shortcuts.resolve", json!({"keys": "⇧⌘K"})).unwrap();
+    assert_eq!(hit["command"], json!("edit.undo"));
+    assert!(s.shortcuts.modified);
+    // add a second shortcut, keep a conflict on purpose
+    s.execute("shortcuts.set", json!({"command": "edit.undo", "keys": "Cmd+Z", "add": true})).unwrap();
+    assert_eq!(s.shortcuts.for_command("edit.undo").iter().filter(|b| b.panel.is_none()).count(), 2);
+    let r = s.execute("shortcuts.set", json!({"command": "edit.redo", "keys": "M", "keepConflicts": true})).unwrap();
+    assert_eq!(r["conflicts"].as_array().unwrap().len(), 1, "{r}");
+    let c = s.execute("shortcuts.conflicts", json!({"platform": "mac"})).unwrap();
+    assert_eq!(c["conflicts"][0]["keys"], json!("M"));
+    // undo / redo within the editor
+    s.execute("shortcuts.undo", json!({})).unwrap();
+    assert!(s.execute("shortcuts.conflicts", json!({})).unwrap()["conflicts"].as_array().unwrap().is_empty());
+    s.execute("shortcuts.undo", json!({})).unwrap();
+    s.execute("shortcuts.undo", json!({})).unwrap();
+    assert_eq!(s.shortcuts.primary("edit.undo").as_deref(), Some("Cmd+Z"));
+    assert_eq!(s.shortcuts.primary("sequence.addEditAllTracks").as_deref(), Some("Cmd+Shift+K"));
+    s.execute("shortcuts.redo", json!({})).unwrap();
+    assert_eq!(s.shortcuts.primary("edit.undo").as_deref(), Some("Cmd+Shift+K"));
+    // clear
+    let r = s.execute("shortcuts.clear", json!({"command": "edit.undo"})).unwrap();
+    assert_eq!(r["removed"], json!(2), "Cmd+Shift+K and History ▸ Left");
+    assert!(s.shortcuts.for_command("edit.undo").is_empty());
+    assert!(s.execute("shortcuts.set", json!({"command": "no.such", "keys": "K"})).is_err());
+    assert!(s.execute("shortcuts.set", json!({"command": "edit.undo", "keys": "K", "panel": "Nowhere"})).is_err());
+    // editor Cancel restores the set it opened with
+    s.shortcuts.begin_editing();
+    s.execute("shortcuts.set", json!({"command": "edit.undo", "keys": "U"})).unwrap();
+    s.shortcuts.cancel_editing();
+    assert!(s.shortcuts.for_command("edit.undo").is_empty());
+}
+
+#[test]
+fn panel_shortcuts_override_application_ones_with_focus() {
+    let s = Session::default();
+    let left = Chord::parse("Left").unwrap();
+    let p = Platform::Mac;
+    assert_eq!(s.shortcuts.resolve(&left, None, p).unwrap().command, "playhead.stepBack");
+    assert_eq!(s.shortcuts.resolve(&left, Some("Timeline"), p).unwrap().command, "playhead.stepBack");
+    assert_eq!(s.shortcuts.resolve(&left, Some("History"), p).unwrap().command, "edit.undo");
+    let bs = Chord::parse("Backspace").unwrap();
+    assert_eq!(s.shortcuts.resolve(&bs, Some("Project"), p).unwrap().command, "project.delete");
+    assert_eq!(s.shortcuts.resolve(&bs, None, p).unwrap().command, "edit.clear");
+    let ov = s.shortcuts.overrides(p);
+    assert!(ov.iter().any(|(panel, k, cmd, app)| panel == "History" && k == "Left" && cmd == "edit.undo" && app == "playhead.stepBack"), "{ov:?}");
+    // Windows: macOS-Control shortcuts fold into Ctrl and can clash
+    let mut t = Session::default();
+    t.execute("shortcuts.set", json!({"command": "edit.copy", "keys": "Ctrl+C", "add": true, "keepConflicts": true})).unwrap();
+    assert!(t.shortcuts.conflicts(Platform::Mac).is_empty());
+    assert!(!t.shortcuts.conflicts(Platform::Windows).is_empty() || t.shortcuts.for_command("edit.copy").len() == 2);
+    let k = t.execute("shortcuts.forKey", json!({"key": "C"})).unwrap();
+    assert!(k.as_array().unwrap().iter().any(|b| b["command"] == "edit.copy" && b["keys"] == "Ctrl+C"), "{k}");
+}
+
+#[test]
+fn compat_presets_map_other_editors() {
+    let mut s = Session::default();
+    with_ui_commands(&mut s);
+    s.execute("shortcuts.loadPreset", json!({"name": "Premiere Pro Compatible"})).unwrap();
+    assert_eq!(s.shortcuts.primary("markers.clearIn").as_deref(), Some("Alt+I"));
+    assert_eq!(s.shortcuts.primary("edit.clear").as_deref(), Some("Delete"));
+    assert!(s.shortcuts.for_command("edit.clear").iter().any(|b| b.panel.as_deref() == Some("Timeline") && b.keys == "Backspace"));
+    s.execute("shortcuts.loadPreset", json!({"name": "Final Cut Pro Compatible"})).unwrap();
+    assert_eq!(s.shortcuts.primary("source.insert").as_deref(), Some("W"));
+    assert_eq!(s.shortcuts.primary("tool.razor").as_deref(), Some("B"));
+    assert!(s.shortcuts.primary("trim.rippleNext").is_none(), "W was taken by Insert");
+    s.execute("shortcuts.loadPreset", json!({"name": "Avid Media Composer Compatible"})).unwrap();
+    assert_eq!(s.shortcuts.primary("sequence.lift").as_deref(), Some("Z"));
+    assert_eq!(s.shortcuts.for_command("markers.markIn").len(), 2, "I and E");
+    assert!(!s.shortcuts.modified);
+    assert!(s.execute("shortcuts.loadPreset", json!({"name": "Nope"})).is_err());
+    s.execute("shortcuts.loadPreset", json!({"name": "FilmCraft Default"})).unwrap();
+    assert_eq!(s.shortcuts.primary("source.insert").as_deref(), Some(","));
+}
+
+#[test]
+fn custom_presets_persist_export_and_import() {
+    let dir = temp_dir("presets");
+    let mut s = Session::default();
+    s.shortcuts.set_dir(&dir);
+    s.execute("shortcuts.set", json!({"command": "sequence.addEdit", "keys": "Cmd+Shift+B"})).unwrap();
+    let r = s.execute("shortcuts.savePreset", json!({"name": "My Keys"})).unwrap();
+    assert!(std::path::Path::new(r["path"].as_str().unwrap()).exists());
+    let p = s.execute("shortcuts.presets", json!({})).unwrap();
+    assert_eq!(p["active"], json!("My Keys"));
+    assert_eq!(p["custom"], json!(["My Keys"]));
+    assert!(s.execute("shortcuts.savePreset", json!({"name": "FilmCraft Default"})).is_err());
+    // the active set survives a restart
+    let mut t = Shortcuts::new();
+    t.set_dir(&dir);
+    assert_eq!(t.preset, "My Keys");
+    assert_eq!(t.primary("sequence.addEdit").as_deref(), Some("Cmd+Shift+B"));
+    // switch away and back
+    s.execute("shortcuts.loadPreset", json!({"name": "FilmCraft Default"})).unwrap();
+    assert_eq!(s.shortcuts.primary("sequence.addEdit").as_deref(), Some("Cmd+K"));
+    s.execute("shortcuts.loadPreset", json!({"name": "My Keys"})).unwrap();
+    assert_eq!(s.shortcuts.primary("sequence.addEdit").as_deref(), Some("Cmd+Shift+B"));
+    // export, then import a Windows-notation file
+    let out = dir.join("export.json");
+    s.execute("shortcuts.export", json!({"path": out.to_string_lossy()})).unwrap();
+    let f: crate::shortcuts::PresetFile = serde_json::from_slice(&std::fs::read(&out).unwrap()).unwrap();
+    assert!(f.bindings.contains(&Binding { command: "sequence.addEdit".into(), keys: "Cmd+Shift+B".into(), panel: None }));
+    let win = dir.join("win.json");
+    std::fs::write(
+        &win,
+        serde_json::to_vec(&json!({"format": "filmcraft-keyboard-shortcuts", "version": 1, "name": "From Windows", "platform": "windows",
+            "bindings": [{"command": "edit.undo", "keys": "Ctrl+Z"}, {"command": "sequence.addEdit", "keys": "Ctrl+Alt+K"}, {"command": "no.such", "keys": "K"}]}))
+        .unwrap(),
+    )
+    .unwrap();
+    let r = s.execute("shortcuts.import", json!({"path": win.to_string_lossy()})).unwrap();
+    assert_eq!(r["name"], json!("From Windows"));
+    assert_eq!(s.shortcuts.primary("edit.undo").as_deref(), Some("Cmd+Z"));
+    assert_eq!(s.shortcuts.primary("sequence.addEdit").as_deref(), Some("Cmd+Alt+K"));
+    assert_eq!(s.shortcuts.bindings.len(), 2, "unknown commands dropped");
+    s.execute("shortcuts.deletePreset", json!({"name": "My Keys"})).unwrap();
+    assert!(s.execute("shortcuts.deletePreset", json!({"name": "FilmCraft Default"})).is_err());
+    assert_eq!(s.execute("shortcuts.presets", json!({})).unwrap()["custom"], json!(["From Windows"]));
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
+#[test]
+fn list_searches_labels_and_keys() {
+    let s = Session::default();
+    let r = s.shortcuts.commands();
+    assert!(r.iter().any(|c| c.id == "trim.forward"));
+    assert!(!r.iter().any(|c| c.id == "timeline.move"), "commands with required params are not bindable");
+    let mut s = s;
+    let v = s.execute("shortcuts.list", json!({"query": "ripple delete"})).unwrap();
+    assert!(v.as_array().unwrap().iter().any(|c| c["id"] == "edit.rippleDelete"), "{v}");
+    let v = s.execute("shortcuts.list", json!({"query": "cmd+k", "platform": "windows"})).unwrap();
+    assert!(v.as_array().unwrap().iter().any(|c| c["id"] == "sequence.addEdit"), "{v}");
+    let v = s.execute("shortcuts.list", json!({"panel": "History", "assigned": true})).unwrap();
+    assert_eq!(v.as_array().unwrap().len(), 2, "{v}");
+}
diff --git a/crates/engine/src/trim.rs b/crates/engine/src/trim.rs
index aa8494827..b334bd801 100644
--- a/crates/engine/src/trim.rs
+++ b/crates/engine/src/trim.rs
@@ -4,11 +4,24 @@
 //! on the edge shared with the adjacent clip on the same track. Trimming delegates to the
 //! `timeline.trim` / `timeline.roll` commands so linked partners and sync locks behave the same as
 //! with the mouse.
+//!
+//! **Trim Monitor** ([`monitor_info`]): while edit points are selected the Program monitor shows the
+//! outgoing clip's last frame and the incoming clip's first frame, with the Out/In shift counters
+//! ([`TrimShift`]) that count how far each side moved since the edit point was selected.
+//!
+//! **Dynamic trimming** ([`TrimPlayback`]): in trim mode J/L "play" the edit point — it moves at the
+//! shuttle speed (L forward, J backward, pressing again doubles the speed up to 8×, Shift = slow)
+//! and the sequence updates live. K stops and commits: the whole dynamic trim is **one** undo step.
+//! Space loops playback around the edit (Preferences ▸ Playback preroll/postroll). Everything is
+//! driven by a caller-supplied clock (`clock`, seconds): the UI passes its frame time, tests pass
+//! exact values, so dynamic trims are deterministic.
+
+use std::sync::Arc;
 
 use serde::{Deserialize, Serialize};
 use serde_json::{Value, json};
 
-use filmcraft_project::{ClipId, Sequence, TrackId};
+use filmcraft_project::{ClipId, Project, Sequence, TrackId, TrackKind};
 use filmcraft_time::{Tick, TimeRange};
 
 use crate::{EngineError, Result, Session};
@@ -34,6 +47,15 @@ impl TrimKind {
     }
 }
 
+/// Trim Monitor counters: how far the outgoing clip's Out point and the incoming clip's In point
+/// moved since the edit point was selected.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TrimShift {
+    pub out_shift: Tick,
+    pub in_shift: Tick,
+}
+
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub struct EditPoint {
     pub clip: ClipId,
@@ -82,6 +104,7 @@ pub fn select(s: &mut Session, p: &Value) -> Result<Value> {
         s.state.edit_points = vec![ep];
     }
     s.state.selection.clear();
+    reset_shift(s);
     Ok(json!({"editPoints": s.state.edit_points}))
 }
 
@@ -132,6 +155,7 @@ pub fn select_nearest(s: &mut Session, p: &Value) -> Result<Value> {
     }
     s.state.edit_points = points;
     s.state.selection.clear();
+    reset_shift(s);
     Ok(json!({"editPoints": s.state.edit_points}))
 }
 
@@ -145,6 +169,31 @@ pub fn toggle_type(s: &mut Session) -> Result<Value> {
 
 /// Trim every selected edit point by `delta` (edit point movement; positive = later).
 fn trim_all(s: &mut Session, delta: Tick) -> Result<Value> {
+    let applied = trim_all_raw(s, delta)?;
+    let first = applied.first().and_then(Value::as_i64).map(Tick).unwrap_or_default();
+    add_shift(s, first);
+    Ok(json!({"applied": applied}))
+}
+
+/// Add an applied movement of the primary edit point to the Trim Monitor's shift counters.
+fn add_shift(s: &mut Session, d: Tick) {
+    let Some(ep) = s.state.edit_points.first() else { return };
+    match (ep.kind, ep.out) {
+        (TrimKind::Roll, _) => {
+            s.state.trim_shift.out_shift += d;
+            s.state.trim_shift.in_shift += d;
+        }
+        (_, true) => s.state.trim_shift.out_shift += d,
+        (_, false) => s.state.trim_shift.in_shift += d,
+    }
+}
+
+/// Reset the Trim Monitor counters (a new edit point selection starts a new trim session).
+fn reset_shift(s: &mut Session) {
+    s.state.trim_shift = TrimShift::default();
+}
+
+fn trim_all_raw(s: &mut Session, delta: Tick) -> Result<Vec<Value>> {
     if s.state.edit_points.is_empty() {
         return Err(EngineError::Other("no edit points selected".into()));
     }
@@ -164,7 +213,7 @@ fn trim_all(s: &mut Session, delta: Tick) -> Result<Value> {
         };
         applied.push(r.get("delta").cloned().unwrap_or(Value::Null));
     }
-    Ok(json!({"applied": applied}))
+    Ok(applied)
 }
 
 /// `trim.nudge {frames}`: Trim Forward/Backward (±1), Many (±5 by default).
@@ -227,3 +276,326 @@ pub fn to_playhead(s: &mut Session, p: &Value) -> Result<Value> {
     }
     Ok(json!({"range": [range.start.0, range.end().0]}))
 }
+
+// ------------------------------------------------------------------ Trim Monitor
+
+/// One side of the Trim Monitor: the clip and the frame shown for it.
+fn side_json(s: &Session, seq: &Sequence, clip: ClipId, outgoing: bool) -> Option<Value> {
+    let (tid, it) = seq.find_item(clip)?;
+    let rate = seq.settings.frame_rate;
+    let fd = rate.frame_duration();
+    let t = if outgoing { it.end() - fd } else { it.start };
+    let media_time = it.source_time_at(t.clamp(it.start, it.end() - Tick(1)));
+    let track = seq.track(tid)?;
+    let tracks = seq.tracks(track.kind);
+    let idx = tracks.iter().position(|x| x.id == tid).unwrap_or(0) + 1;
+    let track_name = format!("{}{idx}", if track.kind == TrackKind::Video { "V" } else { "A" });
+    let item_rate = s.project.item(it.item).map(|i| i.frame_rate()).unwrap_or(rate);
+    Some(json!({
+        "clip": it.id.0, "item": it.item.0, "name": it.name, "track": track_name, "video": track.kind == TrackKind::Video,
+        "time": t.0, "mediaTime": media_time.0, "mediaFrame": item_rate.frame_at(media_time),
+        "sourceIn": it.source_in.0, "sourceOut": it.source_out().0,
+    }))
+}
+
+/// The (outgoing, incoming) clips at an edit point.
+pub fn sides(seq: &Sequence, ep: &EditPoint) -> (Option<ClipId>, Option<ClipId>) {
+    match roll_pair(seq, ep) {
+        Some((l, r)) => (Some(l), Some(r)),
+        None if ep.out => (Some(ep.clip), None),
+        None => (None, Some(ep.clip)),
+    }
+}
+
+/// `trim.monitor`: everything the Trim Monitor shows, for the primary (first) edit point.
+pub fn monitor_info(s: &Session) -> Value {
+    let Some(seq) = s.active_sequence() else { return Value::Null };
+    let Some(ep) = s.state.edit_points.first() else { return json!({"active": false}) };
+    let rate = seq.settings.frame_rate;
+    let (out_c, in_c) = sides(seq, ep);
+    let tp = &s.trim_play;
+    json!({
+        "active": true,
+        "kind": ep.kind,
+        "edge": if ep.out { "out" } else { "in" },
+        "editTime": edit_time(seq, ep).map(|t| t.0),
+        "editPoints": s.state.edit_points.len(),
+        "outgoing": out_c.and_then(|c| side_json(s, seq, c, true)),
+        "incoming": in_c.and_then(|c| side_json(s, seq, c, false)),
+        "outShift": rate.frame_at(s.state.trim_shift.out_shift),
+        "inShift": rate.frame_at(s.state.trim_shift.in_shift),
+        "largeTrimOffset": s.prefs.trim.large_trim_offset,
+        "dynamic": tp.dynamic.as_ref().map(|d| json!({"offsetFrames": rate.frame_at(d.offset), "offset": d.offset.0, "speed": d.speed, "atLimit": d.at_limit})),
+        "playAround": tp.around.as_ref().map(|a| json!({"start": a.start.0, "end": a.end.0, "loop": a.looping})),
+    })
+}
+
+/// `trim.applyDefaultTransition` (Apply Default Transitions to Selection, Trim Monitor button): the
+/// default video/audio transition at every selected edit point.
+pub fn apply_default_transitions(s: &mut Session) -> Result<Value> {
+    let pts = s.state.edit_points.clone();
+    let mut ids = Vec::new();
+    for ep in &pts {
+        let seq = s.active_sequence().ok_or(EngineError::NoSequence)?;
+        let Some((tid, _)) = seq.find_item(ep.clip) else { continue };
+        let video = seq.track(tid).is_some_and(|t| t.kind == TrackKind::Video);
+        let cmd = if video { "sequence.applyVideoTransition" } else { "sequence.applyAudioTransition" };
+        if let Ok(r) = s.execute(cmd, json!({"clip": ep.clip.0, "edge": if ep.out { "out" } else { "in" }})) {
+            ids.push(r["transition"].clone());
+        }
+    }
+    if ids.is_empty() {
+        return Err(EngineError::Other("no transition could be applied at the selected edit points".into()));
+    }
+    Ok(json!({"transitions": ids}))
+}
+
+// ------------------------------------------------------------------ dynamic trimming
+
+/// Trim-mode playback state (not project data; never saved).
+#[derive(Clone, Debug, Default)]
+pub struct TrimPlayback {
+    pub dynamic: Option<DynamicTrim>,
+    pub around: Option<PlayAround>,
+}
+
+impl TrimPlayback {
+    pub fn active(&self) -> bool {
+        self.dynamic.is_some() || self.around.is_some()
+    }
+}
+
+/// A J/K/L trim in progress.
+#[derive(Clone, Debug)]
+pub struct DynamicTrim {
+    /// The project before the trim: the one undo step pushed on commit, and the base every live
+    /// update re-applies the offset to (so updates never accumulate rounding or clamping).
+    before: Arc<Project>,
+    shift_before: TrimShift,
+    /// Edit point movement applied so far (whole frames).
+    pub offset: Tick,
+    /// Shuttle speed (× real time); negative = backward, 0 = held (stopped at a limit).
+    pub speed: f64,
+    anchor_clock: f64,
+    anchor_offset: Tick,
+    /// The trim ran into a limit (media handle, neighbour, sync) and stopped there.
+    pub at_limit: bool,
+}
+
+/// Loop (or one-shot) playback around the edit: preroll before it to postroll after it.
+#[derive(Clone, Debug)]
+pub struct PlayAround {
+    pub start: Tick,
+    pub end: Tick,
+    pub looping: bool,
+    clock0: f64,
+}
+
+fn clock_p(p: &Value) -> f64 {
+    p.get("clock").and_then(Value::as_f64).unwrap_or(0.0)
+}
+
+fn direction_p(p: &Value) -> f64 {
+    match p.get("direction") {
+        Some(Value::String(d)) if d.starts_with('r') || d.starts_with('b') || d.eq_ignore_ascii_case("j") => -1.0,
+        Some(v) if v.as_f64().is_some_and(|x| x < 0.0) => -1.0,
+        _ => 1.0,
+    }
+}
+
+/// Whole frames of movement for `secs` of edit point travel (truncated toward zero).
+fn frames_for(s: &Session, secs: f64) -> Tick {
+    let rate = s.sequence_rate();
+    let mag = rate.frame_at(Tick::from_seconds_f64(secs.abs()));
+    rate.tick_of(if secs < 0.0 { -mag } else { mag })
+}
+
+/// `trim.shuttle {direction: "forward"|"reverse", slow?, clock}` (L / J in trim mode): start a
+/// dynamic trim, speed it up (pressing the same direction again doubles the speed, up to 8×) or
+/// reverse it.
+pub fn shuttle(s: &mut Session, p: &Value) -> Result<Value> {
+    let clock = clock_p(p);
+    let dir = direction_p(p);
+    let slow = p.get("slow").and_then(Value::as_bool).unwrap_or(false);
+    s.trim_play.around = None;
+    if s.trim_play.dynamic.is_none() {
+        s.trim_play.dynamic = Some(DynamicTrim {
+            before: s.project.clone(),
+            shift_before: s.state.trim_shift,
+            offset: Tick::ZERO,
+            speed: 0.0,
+            anchor_clock: clock,
+            anchor_offset: Tick::ZERO,
+            at_limit: false,
+        });
+    } else {
+        // bring the offset up to date before changing speed
+        tick(s, clock)?;
+    }
+    let rate = s.sequence_rate();
+    let d = s.trim_play.dynamic.as_mut().expect("dynamic trim");
+    let speed = if slow {
+        0.25 * dir
+    } else if d.speed * dir > 0.0 && !d.at_limit {
+        (d.speed * 2.0).clamp(-8.0, 8.0)
+    } else {
+        dir
+    };
+    d.speed = speed;
+    d.anchor_clock = clock;
+    d.anchor_offset = d.offset;
+    d.at_limit = false;
+    Ok(json!({"speed": speed, "offsetFrames": rate.frame_at(d.offset)}))
+}
+
+/// `trim.tick {clock}`: advance dynamic trimming / loop playback to `clock` (call once per frame).
+pub fn tick(s: &mut Session, clock: f64) -> Result<Value> {
+    if let Some(d) = s.trim_play.dynamic.clone() {
+        let want = d.anchor_offset + frames_for(s, (clock - d.anchor_clock).max(0.0) * d.speed);
+        if want != d.offset {
+            let got = apply_dynamic(s, want)?;
+            if let Some(dd) = s.trim_play.dynamic.as_mut() {
+                dd.offset = got;
+                if got != want {
+                    // ran into a limit: hold there (K still commits)
+                    dd.at_limit = true;
+                    dd.speed = 0.0;
+                    dd.anchor_offset = got;
+                    dd.anchor_clock = clock;
+                }
+            }
+        }
+    } else if let Some(a) = s.trim_play.around.clone() {
+        let len = (a.end - a.start).seconds().max(1e-9);
+        let mut el = (clock - a.clock0).max(0.0);
+        if a.looping {
+            el %= len;
+        } else if el >= len {
+            s.trim_play.around = None;
+            s.set_playhead(a.end - s.sequence_rate().frame_duration());
+            return Ok(status(s));
+        }
+        s.set_playhead(a.start + Tick::from_seconds_f64(el));
+    }
+    Ok(status(s))
+}
+
+fn status(s: &Session) -> Value {
+    let rate = s.sequence_rate();
+    let tp = &s.trim_play;
+    json!({
+        "playing": tp.active(),
+        "dynamic": tp.dynamic.as_ref().map(|d| json!({"offsetFrames": rate.frame_at(d.offset), "speed": d.speed, "atLimit": d.at_limit})),
+        "playhead": s.playhead().0,
+    })
+}
+
+/// Re-apply `offset` to the project as it was before the dynamic trim, without touching the undo
+/// history or the journal. Returns the offset that could actually be applied.
+fn apply_dynamic(s: &mut Session, offset: Tick) -> Result<Tick> {
+    let Some(d) = s.trim_play.dynamic.clone() else { return Ok(Tick::ZERO) };
+    let (undo_len, journal_len, limit) = (s.history.undo.len(), s.journal.len(), s.history.limit);
+    let redo = std::mem::take(&mut s.history.redo);
+    s.history.limit = usize::MAX;
+    s.project = d.before.clone();
+    let r = if offset == Tick::ZERO { Ok(vec![json!(0)]) } else { trim_all_raw(s, offset) };
+    let applied = match r {
+        Ok(a) => a.first().and_then(Value::as_i64).map(Tick).unwrap_or_default(),
+        Err(_) => {
+            // refused outright (e.g. it would break sync): stay where we were
+            s.project = d.before.clone();
+            if d.offset != Tick::ZERO {
+                let _ = trim_all_raw(s, d.offset);
+            }
+            d.offset
+        }
+    };
+    s.history.undo.truncate(undo_len);
+    s.history.limit = limit;
+    s.history.redo = redo;
+    s.journal.truncate(journal_len);
+    s.state.trim_shift = d.shift_before;
+    add_shift(s, applied);
+    // the Program monitor follows the moving edit
+    if let Some(t) = s.active_sequence().and_then(|q| s.state.edit_points.first().and_then(|e| edit_time(q, e))) {
+        s.set_playhead(t);
+    }
+    Ok(applied)
+}
+
+/// `trim.shuttleStop {clock?}` (K in trim mode): stop dynamic trimming and commit it as one undo
+/// step, and stop loop playback.
+pub fn stop(s: &mut Session, p: &Value) -> Result<Value> {
+    if let Some(c) = p.get("clock").and_then(Value::as_f64)
+        && s.trim_play.dynamic.is_some()
+    {
+        tick(s, c)?;
+    }
+    s.trim_play.around = None;
+    Ok(commit(s))
+}
+
+/// Commit a dynamic trim in progress (one undo step labelled after the trim kind).
+pub fn commit(s: &mut Session) -> Value {
+    let Some(d) = s.trim_play.dynamic.take() else { return json!({"committed": false}) };
+    let rate = s.sequence_rate();
+    if d.offset == Tick::ZERO || Arc::ptr_eq(&d.before, &s.project) {
+        s.project = d.before;
+        s.state.trim_shift = d.shift_before;
+        return json!({"committed": false, "offsetFrames": 0});
+    }
+    let label = match s.state.edit_points.first().map(|e| e.kind) {
+        Some(TrimKind::Roll) => "Dynamic Rolling Edit",
+        Some(TrimKind::Ripple) => "Dynamic Ripple Trim",
+        _ => "Dynamic Trim",
+    };
+    s.history.undo.push((label.to_string(), d.before));
+    if s.history.undo.len() > s.history.limit {
+        s.history.undo.remove(0);
+    }
+    s.history.redo.clear();
+    json!({"committed": true, "label": label, "offsetFrames": rate.frame_at(d.offset), "offset": d.offset.0})
+}
+
+/// `trim.cancelDynamic` (Esc): drop a dynamic trim in progress, restoring the edit.
+pub fn cancel(s: &mut Session) -> Result<Value> {
+    s.trim_play.around = None;
+    if let Some(d) = s.trim_play.dynamic.take() {
+        s.project = d.before;
+        s.state.trim_shift = d.shift_before;
+        s.fix_state();
+        if let Some(t) = s.active_sequence().and_then(|q| s.state.edit_points.first().and_then(|e| edit_time(q, e))) {
+            s.set_playhead(t);
+        }
+        s.revision += 1;
+        s.events.push(crate::Event::ProjectChanged { revision: s.revision });
+    }
+    Ok(Value::Null)
+}
+
+/// `trim.playAround {clock, loop?: true, toggle?}` (Space / Shift+K in trim mode): play from
+/// preroll before the edit (or the playhead, per Preferences ▸ Trim) to postroll after it.
+pub fn play_around(s: &mut Session, p: &Value) -> Result<Value> {
+    if s.trim_play.dynamic.is_some() {
+        commit(s);
+    }
+    if s.trim_play.around.is_some() && p.get("toggle").and_then(Value::as_bool).unwrap_or(false) {
+        s.trim_play.around = None;
+        return Ok(status(s));
+    }
+    let seq = s.active_sequence().ok_or(EngineError::NoSequence)?;
+    let edit = s.state.edit_points.first().and_then(|e| edit_time(seq, e));
+    let center = match edit {
+        Some(e) if !s.prefs.trim.playhead_determines_loop => e,
+        _ => s.playhead(),
+    };
+    let rate = seq.settings.frame_rate;
+    let dur = seq.duration();
+    let start = rate.snap((center - Tick::from_seconds_f64(s.prefs.playback.preroll_seconds)).max(Tick::ZERO));
+    let end = rate.snap((center + Tick::from_seconds_f64(s.prefs.playback.postroll_seconds)).min(dur.max(center + rate.frame_duration())));
+    let end = end.max(start + rate.frame_duration());
+    let looping = p.get("loop").and_then(Value::as_bool).unwrap_or(true);
+    s.trim_play.around = Some(PlayAround { start, end, looping, clock0: clock_p(p) });
+    s.set_playhead(start);
+    Ok(json!({"start": start.0, "end": end.0, "loop": looping}))
+}
diff --git a/crates/engine/src/trim_tests.rs b/crates/engine/src/trim_tests.rs
new file mode 100644
index 000000000..bbeb147f1
--- /dev/null
+++ b/crates/engine/src/trim_tests.rs
@@ -0,0 +1,212 @@
+//! Trim Monitor + dynamic (J/K/L) trimming, driven by an exact simulated clock.
+
+use super::*;
+use serde_json::json;
+
+fn demo() -> Session {
+    let mut s = Session::default();
+    s.execute("file.openDemoProject", json!({})).unwrap();
+    for t in ["V2", "V3", "A2", "A3"] {
+        let _ = s.execute("timeline.setTrack", json!({"track": t, "syncLock": false}));
+    }
+    s
+}
+
+/// V1 clips as (id, start, end).
+fn v1(s: &Session) -> Vec<(u64, Tick, Tick)> {
+    s.active_sequence().unwrap().video_tracks[0].items.iter().map(|i| (i.id.0, i.start, i.end())).collect()
+}
+
+/// Whole frames covered by `secs` of real time at the sequence rate.
+fn frames(s: &Session, secs: f64) -> i64 {
+    s.sequence_rate().frame_at(Tick::from_seconds_f64(secs))
+}
+
+/// Select the cut between V1 clips 0 and 1 as `kind` (roll / ripple out of clip 0).
+fn select_first_cut(s: &mut Session, kind: &str) -> (u64, Tick) {
+    let c = v1(s);
+    s.execute("trim.selectEditPoint", json!({"clip": c[0].0, "edge": "out", "kind": kind})).unwrap();
+    (c[0].0, c[0].2)
+}
+
+#[test]
+fn dynamic_roll_forward_is_one_undo_step() {
+    let mut s = demo();
+    let (left, cut) = select_first_cut(&mut s, "roll");
+    let rate = s.sequence_rate();
+    let undo0 = s.history.undo.len();
+    let journal0 = s.journal.len();
+    let dur0 = s.active_sequence().unwrap().duration();
+    s.execute("trim.shuttle", json!({"direction": "forward", "clock": 10.0})).unwrap();
+    // live: the cut moves with the clock, no history yet
+    s.execute("trim.tick", json!({"clock": 10.5})).unwrap();
+    let mid = v1(&s).into_iter().find(|c| c.0 == left).unwrap();
+    assert_eq!(mid.2, cut + rate.tick_of(frames(&s, 0.5)), "half a second of roll");
+    assert_eq!(s.playhead(), mid.2, "the Program monitor follows the edit");
+    assert_eq!(s.history.undo.len(), undo0, "no undo step while trimming");
+    let info = s.execute("trim.monitor", json!({})).unwrap();
+    assert_eq!(info["dynamic"]["offsetFrames"], json!(frames(&s, 0.5)), "{info}");
+    assert_eq!(info["outShift"], json!(frames(&s, 0.5)));
+    assert_eq!(info["inShift"], json!(frames(&s, 0.5)), "roll moves both sides");
+    // K commits
+    let r = s.execute("trim.shuttleStop", json!({"clock": 11.0})).unwrap();
+    assert_eq!(r["committed"], json!(true), "{r}");
+    assert_eq!(r["offsetFrames"], json!(frames(&s, 1.0)));
+    let after = v1(&s).into_iter().find(|c| c.0 == left).unwrap();
+    assert_eq!(after.2, cut + rate.tick_of(frames(&s, 1.0)));
+    assert_eq!(s.active_sequence().unwrap().duration(), dur0, "roll keeps the duration");
+    assert_eq!(s.history.undo.len(), undo0 + 1, "exactly one undo step");
+    assert_eq!(s.history.undo.last().unwrap().0, "Dynamic Rolling Edit");
+    assert!(
+        s.journal[journal0..].iter().all(|(id, _)| id.starts_with("trim.")),
+        "live updates are not journaled as separate edits: {:?}",
+        &s.journal[journal0..]
+    );
+    assert!(s.trim_play.dynamic.is_none());
+    s.execute("edit.undo", json!({})).unwrap();
+    assert_eq!(v1(&s).into_iter().find(|c| c.0 == left).unwrap().2, cut, "undo restores the cut in one step");
+}
+
+#[test]
+fn pressing_l_again_doubles_speed_and_j_reverses() {
+    let mut s = demo();
+    let (left, cut) = select_first_cut(&mut s, "roll");
+    let rate = s.sequence_rate();
+    let r = s.execute("trim.shuttle", json!({"direction": "forward", "clock": 0.0})).unwrap();
+    assert_eq!(r["speed"], json!(1.0));
+    let r = s.execute("trim.shuttle", json!({"direction": "forward", "clock": 0.5})).unwrap();
+    assert_eq!(r["speed"], json!(2.0));
+    // 0.5 s at 1× + 0.5 s at 2×
+    let a = frames(&s, 0.5);
+    s.execute("trim.tick", json!({"clock": 1.0})).unwrap();
+    let expect = a + frames(&s, 1.0);
+    assert_eq!(v1(&s).into_iter().find(|c| c.0 == left).unwrap().2, cut + rate.tick_of(expect));
+    // J: reverse at 1×
+    let r = s.execute("trim.shuttle", json!({"direction": "reverse", "clock": 1.0})).unwrap();
+    assert_eq!(r["speed"], json!(-1.0));
+    s.execute("trim.tick", json!({"clock": 1.25})).unwrap();
+    let back = expect - frames(&s, 0.25);
+    assert_eq!(v1(&s).into_iter().find(|c| c.0 == left).unwrap().2, cut + rate.tick_of(back));
+    // slow (Shift+J / Shift+L) = quarter speed
+    let r = s.execute("trim.shuttle", json!({"direction": "forward", "slow": true, "clock": 1.25})).unwrap();
+    assert_eq!(r["speed"], json!(0.25));
+    let r = s.execute("trim.shuttleStop", json!({"clock": 2.25})).unwrap();
+    assert_eq!(r["offsetFrames"], json!(back + frames(&s, 0.25)));
+    assert_eq!(s.history.undo.last().unwrap().0, "Dynamic Rolling Edit");
+}
+
+#[test]
+fn dynamic_ripple_backward_shortens_and_stops_at_a_limit() {
+    let mut s = demo();
+    let (clip, end0) = select_first_cut(&mut s, "ripple");
+    let rate = s.sequence_rate();
+    let start0 = v1(&s)[0].1;
+    let v1_end = |s: &Session| v1(s).last().unwrap().2;
+    let dur0 = v1_end(&s);
+    s.execute("trim.shuttle", json!({"direction": "reverse", "clock": 0.0})).unwrap();
+    s.execute("trim.tick", json!({"clock": 0.25})).unwrap();
+    let n = frames(&s, 0.25);
+    assert_eq!(v1(&s)[0].2, end0 - rate.tick_of(n));
+    assert_eq!(v1_end(&s), dur0 - rate.tick_of(n), "ripple pulls later material in");
+    // keep going for a minute: the clip can't get shorter than one frame
+    s.execute("trim.tick", json!({"clock": 600.0})).unwrap();
+    let info = s.execute("trim.monitor", json!({})).unwrap();
+    assert_eq!(info["dynamic"]["atLimit"], json!(true), "{info}");
+    assert_eq!(info["dynamic"]["speed"], json!(0.0));
+    let c = v1(&s).into_iter().find(|c| c.0 == clip).unwrap();
+    assert_eq!(c.2 - c.1, rate.frame_duration(), "held at the one-frame limit");
+    assert_eq!(c.1, start0);
+    let r = s.execute("trim.shuttleStop", json!({})).unwrap();
+    assert_eq!(r["label"], json!("Dynamic Ripple Trim"));
+    s.execute("edit.undo", json!({})).unwrap();
+    assert_eq!(v1_end(&s), dur0);
+}
+
+#[test]
+fn another_command_commits_first_and_cancel_restores() {
+    let mut s = demo();
+    let (left, cut) = select_first_cut(&mut s, "roll");
+    let undo0 = s.history.undo.len();
+    s.execute("trim.shuttle", json!({"direction": "forward", "clock": 0.0})).unwrap();
+    s.execute("trim.tick", json!({"clock": 0.5})).unwrap();
+    // Undo mid-trim: the dynamic trim is committed, then undone as a single step
+    s.execute("edit.undo", json!({})).unwrap();
+    assert!(s.trim_play.dynamic.is_none());
+    assert_eq!(v1(&s).into_iter().find(|c| c.0 == left).unwrap().2, cut);
+    assert_eq!(s.history.undo.len(), undo0);
+    assert_eq!(s.history.redo.last().unwrap().0, "Dynamic Rolling Edit");
+    // Esc cancels without an undo step (and restores the counters)
+    let shift0 = s.execute("trim.monitor", json!({})).unwrap()["outShift"].clone();
+    s.execute("trim.shuttle", json!({"direction": "forward", "clock": 0.0})).unwrap();
+    s.execute("trim.tick", json!({"clock": 0.5})).unwrap();
+    assert_ne!(v1(&s).into_iter().find(|c| c.0 == left).unwrap().2, cut);
+    s.execute("trim.cancelDynamic", json!({})).unwrap();
+    assert_eq!(v1(&s).into_iter().find(|c| c.0 == left).unwrap().2, cut);
+    assert_eq!(s.history.undo.len(), undo0);
+    assert_eq!(s.execute("trim.monitor", json!({})).unwrap()["outShift"], shift0);
+    // K with nothing moved commits nothing
+    s.execute("trim.shuttle", json!({"direction": "forward", "clock": 0.0})).unwrap();
+    let r = s.execute("trim.shuttleStop", json!({"clock": 0.0})).unwrap();
+    assert_eq!(r["committed"], json!(false));
+    assert_eq!(s.history.undo.len(), undo0);
+}
+
+#[test]
+fn play_around_loops_preroll_to_postroll() {
+    let mut s = demo();
+    let (_, cut) = select_first_cut(&mut s, "roll");
+    let rate = s.sequence_rate();
+    s.execute("prefs.set", json!({"values": {"playback.prerollSeconds": 1.0, "playback.postrollSeconds": 0.5}})).unwrap();
+    let r = s.execute("trim.playAround", json!({"clock": 100.0})).unwrap();
+    let start = rate.snap(cut - Tick::from_seconds_f64(1.0));
+    let end = rate.snap(cut + Tick::from_seconds_f64(0.5));
+    assert_eq!(r["start"], json!(start.0));
+    assert_eq!(r["end"], json!(end.0));
+    assert_eq!(s.playhead(), start);
+    s.execute("trim.tick", json!({"clock": 101.0})).unwrap();
+    assert_eq!(s.playhead(), rate.snap(start + Tick::from_seconds_f64(1.0)));
+    // loops: 1.5 s later we're back at the start + (elapsed mod length)
+    let len = (end - start).seconds();
+    let el = 1.75 % len;
+    s.execute("trim.tick", json!({"clock": 101.75})).unwrap();
+    assert_eq!(s.playhead(), rate.snap(start + Tick::from_seconds_f64(el)));
+    // trim buttons keep the loop running; other commands stop it
+    s.execute("trim.forward", json!({})).unwrap();
+    assert!(s.trim_play.around.is_some());
+    s.execute("markers.add", json!({})).unwrap();
+    assert!(s.trim_play.around.is_none());
+    // playhead mode
+    s.execute("prefs.set", json!({"key": "trim.playheadDeterminesLoop", "value": true})).unwrap();
+    s.execute("playhead.set", json!({"time": (cut + rate.tick_of(48)).0})).unwrap();
+    let r = s.execute("trim.playAround", json!({"clock": 0.0, "loop": false})).unwrap();
+    assert_eq!(r["start"], json!(rate.snap(cut + rate.tick_of(48) - Tick::from_seconds_f64(1.0)).0));
+    s.execute("trim.tick", json!({"clock": 5.0})).unwrap();
+    assert!(s.trim_play.around.is_none(), "one-shot play-around stops at the postroll");
+}
+
+#[test]
+fn trim_monitor_sides_and_shift_counters() {
+    let mut s = demo();
+    let c = v1(&s);
+    s.execute("trim.selectEditPoint", json!({"clip": c[1].0, "edge": "in", "kind": "ripple"})).unwrap();
+    let info = s.execute("trim.monitor", json!({})).unwrap();
+    assert_eq!(info["outgoing"]["clip"], json!(c[0].0), "{info}");
+    assert_eq!(info["incoming"]["clip"], json!(c[1].0));
+    assert_eq!(info["outgoing"]["time"], json!((c[0].2 - s.sequence_rate().frame_duration()).0), "outgoing shows its last frame");
+    assert_eq!(info["incoming"]["time"], json!(c[1].1));
+    assert_eq!(info["edge"], json!("in"));
+    s.execute("prefs.set", json!({"key": "trim.largeTrimOffset", "value": 3})).unwrap();
+    s.execute("trim.forwardMany", json!({})).unwrap();
+    s.execute("trim.forward", json!({})).unwrap();
+    let info = s.execute("trim.monitor", json!({})).unwrap();
+    assert_eq!(info["inShift"], json!(4), "large offset 3 + 1: {info}");
+    assert_eq!(info["outShift"], json!(0), "a ripple In trim leaves the outgoing side alone");
+    // a new selection starts new counters
+    s.execute("trim.selectEditPoint", json!({"clip": c[1].0, "edge": "in", "kind": "roll"})).unwrap();
+    assert_eq!(s.execute("trim.monitor", json!({})).unwrap()["inShift"], json!(0));
+    // Apply Default Transitions to Selection at the edit point
+    let r = s.execute("trim.applyDefaultTransition", json!({})).unwrap();
+    assert_eq!(r["transitions"].as_array().unwrap().len(), 1, "{r}");
+    let seq = s.execute("sequence.inspect", json!({})).unwrap();
+    assert!(!seq["video"][0]["transitions"].as_array().unwrap().is_empty());
+}
diff --git a/crates/export/Cargo.toml b/crates/export/Cargo.toml
index 998b0829e..23e6e0d32 100644
--- a/crates/export/Cargo.toml
+++ b/crates/export/Cargo.toml
@@ -26,4 +26,5 @@ rayon = { workspace = true }
 image = { version = "0.25", default-features = false, features = ["png", "jpeg", "gif"] }
 
 [dev-dependencies]
+filmcraft-testkit = { workspace = true }
 filmcraft-codecs = { workspace = true }
diff --git a/crates/export/src/tests.rs b/crates/export/src/tests.rs
index 5ef76d183..a77111249 100644
--- a/crates/export/src/tests.rs
+++ b/crates/export/src/tests.rs
@@ -65,7 +65,7 @@ fn mjpeg_mov_roundtrip() {
     let a = src.audio(0, 24_000, 48_000).unwrap();
     let pk = a.peaks()[0];
     assert!((pk - 0.5).abs() < 0.05, "tone at -6 dB: {pk}");
-    if let Some(ffprobe) = ["/opt/homebrew/bin/ffprobe", "/usr/bin/ffprobe"].into_iter().find(|p| std::path::Path::new(p).exists()) {
+    if let Some(ffprobe) = filmcraft_testkit::ffprobe_or_skip("export mjpeg frame count") {
         let out = std::process::Command::new(ffprobe)
             .args(["-v", "error", "-count_frames", "-select_streams", "v:0", "-show_entries", "stream=nb_read_frames", "-of", "csv=p=0", &path])
             .output()
diff --git a/crates/format/src/lib.rs b/crates/format/src/lib.rs
index 29a955473..d81da80e6 100644
--- a/crates/format/src/lib.rs
+++ b/crates/format/src/lib.rs
@@ -19,6 +19,9 @@
 //! Schema history:
 //! - **v1** (M0–M11): the bare serialized `Project` object with a `"version": 1` field.
 //! - **v2** (M11.1): the envelope above; `Project.version` dropped (the envelope carries it).
+//! - **v3** (M10.2): graphic clips (`ItemKind::Graphic`, text/shape layers). The shape of older
+//!   data is unchanged (no-op step); the bump makes builds without graphics refuse such files
+//!   cleanly instead of failing to parse them.
 
 pub mod atomic;
 pub mod autosave;
@@ -37,7 +40,7 @@ pub type Migration = fn(Value) -> Result<Value, String>;
 
 /// `MIGRATIONS[i]` upgrades schema `i + 1` to `i + 2`. Append one function per schema bump; never
 /// edit a shipped one.
-pub const MIGRATIONS: &[Migration] = &[v1_to_v2];
+pub const MIGRATIONS: &[Migration] = &[v1_to_v2, v2_to_v3];
 
 /// The schema version this build writes (and the newest it reads).
 pub const SCHEMA_VERSION: u32 = MIGRATIONS.len() as u32 + 1;
@@ -211,13 +214,18 @@ fn v1_to_v2(doc: Value) -> Result<Value, String> {
     }))
 }
 
+/// v2 → v3: graphic clips added; existing data needs no change.
+fn v2_to_v3(doc: Value) -> Result<Value, String> {
+    Ok(doc)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
     fn schema_version_matches_table() {
-        assert_eq!(SCHEMA_VERSION, 2);
+        assert_eq!(SCHEMA_VERSION, 3);
     }
 
     #[test]
diff --git a/crates/golden/Cargo.toml b/crates/golden/Cargo.toml
new file mode 100644
index 000000000..8ed401cb5
--- /dev/null
+++ b/crates/golden/Cargo.toml
@@ -0,0 +1,26 @@
+[package]
+name = "filmcraft-golden"
+description = "Golden-image tests for the CPU renderer/compositor and GPU-vs-CPU parity (test-only crate)"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+rust-version.workspace = true
+publish = false
+
+[lints]
+workspace = true
+
+# Test-only: the library is empty and everything is a dev-dependency, so the crate adds no edges
+# to the layer graph. Goldens live in `goldens/` (see docs/testing.md §3).
+[dependencies]
+
+[dev-dependencies]
+filmcraft-testkit = { workspace = true }
+filmcraft-time = { workspace = true }
+filmcraft-geom = { workspace = true }
+filmcraft-media = { workspace = true }
+filmcraft-project = { workspace = true }
+filmcraft-render = { workspace = true }
+filmcraft-gpu = { workspace = true }
+pollster = "0.4"
+wgpu = { version = "30", features = ["wgsl", "metal", "vulkan", "dx12", "gles"] }
diff --git a/crates/golden/goldens/blend_modes.png b/crates/golden/goldens/blend_modes.png
new file mode 100644
index 000000000..97ec12057
Binary files /dev/null and b/crates/golden/goldens/blend_modes.png differ
diff --git a/crates/golden/goldens/blend_modes.png.attribution b/crates/golden/goldens/blend_modes.png.attribution
new file mode 100644
index 000000000..89c40f8e0
--- /dev/null
+++ b/crates/golden/goldens/blend_modes.png.attribution
@@ -0,0 +1,8 @@
+asset:        blend_modes.png
+title:        Blend modes (Multiply, Screen, Overlay, Difference)
+author:       FilmCraft contributors
+source:       original work (rendered by FilmCraft's own renderer from a procedurally generated project; no external media)
+license:      MIT OR Apache-2.0
+license-file:
+added:        2026-10-01 by FilmCraft contributors (FILMCRAFT_BLESS=1)
+notes:        Golden reference image generated by crates/golden/tests/golden.rs (blend_modes). Regenerate with FILMCRAFT_BLESS=1. Contains no Adobe artwork.
diff --git a/crates/golden/goldens/crop.png b/crates/golden/goldens/crop.png
new file mode 100644
index 000000000..cdc7b10ab
Binary files /dev/null and b/crates/golden/goldens/crop.png differ
diff --git a/crates/golden/goldens/crop.png.attribution b/crates/golden/goldens/crop.png.attribution
new file mode 100644
index 000000000..811cf9951
--- /dev/null
+++ b/crates/golden/goldens/crop.png.attribution
@@ -0,0 +1,8 @@
+asset:        crop.png
+title:        Crop effect
+author:       FilmCraft contributors
+source:       original work (rendered by FilmCraft's own renderer from a procedurally generated project; no external media)
+license:      MIT OR Apache-2.0
+license-file:
+added:        2026-10-01 by FilmCraft contributors (FILMCRAFT_BLESS=1)
+notes:        Golden reference image generated by crates/golden/tests/golden.rs (crop). Regenerate with FILMCRAFT_BLESS=1. Contains no Adobe artwork.
diff --git a/crates/golden/goldens/gaussian_blur.png b/crates/golden/goldens/gaussian_blur.png
new file mode 100644
index 000000000..ecf3fdfdd
Binary files /dev/null and b/crates/golden/goldens/gaussian_blur.png differ
diff --git a/crates/golden/goldens/gaussian_blur.png.attribution b/crates/golden/goldens/gaussian_blur.png.attribution
new file mode 100644
index 000000000..1e0c7bf7c
--- /dev/null
+++ b/crates/golden/goldens/gaussian_blur.png.attribution
@@ -0,0 +1,8 @@
+asset:        gaussian_blur.png
+title:        Gaussian Blur effect
+author:       FilmCraft contributors
+source:       original work (rendered by FilmCraft's own renderer from a procedurally generated project; no external media)
+license:      MIT OR Apache-2.0
+license-file:
+added:        2026-10-01 by FilmCraft contributors (FILMCRAFT_BLESS=1)
+notes:        Golden reference image generated by crates/golden/tests/golden.rs (gaussian_blur). Regenerate with FILMCRAFT_BLESS=1. Contains no Adobe artwork.
diff --git a/crates/golden/goldens/graphic_shapes.png b/crates/golden/goldens/graphic_shapes.png
new file mode 100644
index 000000000..15a1e13a5
Binary files /dev/null and b/crates/golden/goldens/graphic_shapes.png differ
diff --git a/crates/golden/goldens/graphic_shapes.png.attribution b/crates/golden/goldens/graphic_shapes.png.attribution
new file mode 100644
index 000000000..d4f0d1cbe
--- /dev/null
+++ b/crates/golden/goldens/graphic_shapes.png.attribution
@@ -0,0 +1,8 @@
+asset:        graphic_shapes.png
+title:        Graphic clip: ellipse, polygon, path and rotated text with background
+author:       FilmCraft contributors
+source:       original work (rendered by FilmCraft's own renderer from a procedurally generated project; no external media)
+license:      MIT OR Apache-2.0
+license-file:
+added:        2026-10-01 by FilmCraft contributors (FILMCRAFT_BLESS=1)
+notes:        Golden reference image generated by crates/golden/tests/golden.rs (graphic_shapes). Regenerate with FILMCRAFT_BLESS=1. Contains no Adobe artwork.
diff --git a/crates/golden/goldens/graphic_title.png b/crates/golden/goldens/graphic_title.png
new file mode 100644
index 000000000..6d76efb6e
Binary files /dev/null and b/crates/golden/goldens/graphic_title.png differ
diff --git a/crates/golden/goldens/graphic_title.png.attribution b/crates/golden/goldens/graphic_title.png.attribution
new file mode 100644
index 000000000..2cafc6a9c
--- /dev/null
+++ b/crates/golden/goldens/graphic_title.png.attribution
@@ -0,0 +1,8 @@
+asset:        graphic_title.png
+title:        Graphic clip: title text with stroke and shadow, lower-third bar
+author:       FilmCraft contributors
+source:       original work (rendered by FilmCraft's own renderer from a procedurally generated project; no external media)
+license:      MIT OR Apache-2.0
+license-file:
+added:        2026-10-01 by FilmCraft contributors (FILMCRAFT_BLESS=1)
+notes:        Golden reference image generated by crates/golden/tests/golden.rs (graphic_title). Regenerate with FILMCRAFT_BLESS=1. Contains no Adobe artwork.
diff --git a/crates/golden/goldens/lumetri_basic.png b/crates/golden/goldens/lumetri_basic.png
new file mode 100644
index 000000000..7ae95cb90
Binary files /dev/null and b/crates/golden/goldens/lumetri_basic.png differ
diff --git a/crates/golden/goldens/lumetri_basic.png.attribution b/crates/golden/goldens/lumetri_basic.png.attribution
new file mode 100644
index 000000000..29d170f6e
--- /dev/null
+++ b/crates/golden/goldens/lumetri_basic.png.attribution
@@ -0,0 +1,8 @@
+asset:        lumetri_basic.png
+title:        Lumetri Color basic correction
+author:       FilmCraft contributors
+source:       original work (rendered by FilmCraft's own renderer from a procedurally generated project; no external media)
+license:      MIT OR Apache-2.0
+license-file:
+added:        2026-10-01 by FilmCraft contributors (FILMCRAFT_BLESS=1)
+notes:        Golden reference image generated by crates/golden/tests/golden.rs (lumetri_basic). Regenerate with FILMCRAFT_BLESS=1. Contains no Adobe artwork.
diff --git a/crates/golden/goldens/text_burnin.png b/crates/golden/goldens/text_burnin.png
new file mode 100644
index 000000000..105c26abf
Binary files /dev/null and b/crates/golden/goldens/text_burnin.png differ
diff --git a/crates/golden/goldens/text_burnin.png.attribution b/crates/golden/goldens/text_burnin.png.attribution
new file mode 100644
index 000000000..b15c28c36
--- /dev/null
+++ b/crates/golden/goldens/text_burnin.png.attribution
@@ -0,0 +1,8 @@
+asset:        text_burnin.png
+title:        Timecode and Clip Name burn-in text
+author:       FilmCraft contributors
+source:       original work (rendered by FilmCraft's own renderer from a procedurally generated project; no external media)
+license:      MIT OR Apache-2.0
+license-file:
+added:        2026-10-01 by FilmCraft contributors (FILMCRAFT_BLESS=1)
+notes:        Golden reference image generated by crates/golden/tests/golden.rs (text_burnin). Regenerate with FILMCRAFT_BLESS=1. Contains no Adobe artwork.
diff --git a/crates/golden/goldens/transform_opacity.png b/crates/golden/goldens/transform_opacity.png
new file mode 100644
index 000000000..f59dff28a
Binary files /dev/null and b/crates/golden/goldens/transform_opacity.png differ
diff --git a/crates/golden/goldens/transform_opacity.png.attribution b/crates/golden/goldens/transform_opacity.png.attribution
new file mode 100644
index 000000000..7d0e12b74
--- /dev/null
+++ b/crates/golden/goldens/transform_opacity.png.attribution
@@ -0,0 +1,8 @@
+asset:        transform_opacity.png
+title:        Motion transform and opacity
+author:       FilmCraft contributors
+source:       original work (rendered by FilmCraft's own renderer from a procedurally generated project; no external media)
+license:      MIT OR Apache-2.0
+license-file:
+added:        2026-10-01 by FilmCraft contributors (FILMCRAFT_BLESS=1)
+notes:        Golden reference image generated by crates/golden/tests/golden.rs (transform_opacity). Regenerate with FILMCRAFT_BLESS=1. Contains no Adobe artwork.
diff --git a/crates/golden/goldens/transition_cross_dissolve.png b/crates/golden/goldens/transition_cross_dissolve.png
new file mode 100644
index 000000000..2ef34ac41
Binary files /dev/null and b/crates/golden/goldens/transition_cross_dissolve.png differ
diff --git a/crates/golden/goldens/transition_cross_dissolve.png.attribution b/crates/golden/goldens/transition_cross_dissolve.png.attribution
new file mode 100644
index 000000000..f8d4c0254
--- /dev/null
+++ b/crates/golden/goldens/transition_cross_dissolve.png.attribution
@@ -0,0 +1,8 @@
+asset:        transition_cross_dissolve.png
+title:        Cross Dissolve at 50%
+author:       FilmCraft contributors
+source:       original work (rendered by FilmCraft's own renderer from a procedurally generated project; no external media)
+license:      MIT OR Apache-2.0
+license-file:
+added:        2026-10-01 by FilmCraft contributors (FILMCRAFT_BLESS=1)
+notes:        Golden reference image generated by crates/golden/tests/golden.rs (transition_cross_dissolve). Regenerate with FILMCRAFT_BLESS=1. Contains no Adobe artwork.
diff --git a/crates/golden/goldens/transition_dip_to_black.png b/crates/golden/goldens/transition_dip_to_black.png
new file mode 100644
index 000000000..0a40896b8
Binary files /dev/null and b/crates/golden/goldens/transition_dip_to_black.png differ
diff --git a/crates/golden/goldens/transition_dip_to_black.png.attribution b/crates/golden/goldens/transition_dip_to_black.png.attribution
new file mode 100644
index 000000000..57ff8d19a
--- /dev/null
+++ b/crates/golden/goldens/transition_dip_to_black.png.attribution
@@ -0,0 +1,8 @@
+asset:        transition_dip_to_black.png
+title:        Dip to Black at 25%
+author:       FilmCraft contributors
+source:       original work (rendered by FilmCraft's own renderer from a procedurally generated project; no external media)
+license:      MIT OR Apache-2.0
+license-file:
+added:        2026-10-01 by FilmCraft contributors (FILMCRAFT_BLESS=1)
+notes:        Golden reference image generated by crates/golden/tests/golden.rs (transition_dip_to_black). Regenerate with FILMCRAFT_BLESS=1. Contains no Adobe artwork.
diff --git a/crates/golden/goldens/transition_wipe.png b/crates/golden/goldens/transition_wipe.png
new file mode 100644
index 000000000..2548e9ce9
Binary files /dev/null and b/crates/golden/goldens/transition_wipe.png differ
diff --git a/crates/golden/goldens/transition_wipe.png.attribution b/crates/golden/goldens/transition_wipe.png.attribution
new file mode 100644
index 000000000..8ea1f4dff
--- /dev/null
+++ b/crates/golden/goldens/transition_wipe.png.attribution
@@ -0,0 +1,8 @@
+asset:        transition_wipe.png
+title:        Wipe at 50%
+author:       FilmCraft contributors
+source:       original work (rendered by FilmCraft's own renderer from a procedurally generated project; no external media)
+license:      MIT OR Apache-2.0
+license-file:
+added:        2026-10-01 by FilmCraft contributors (FILMCRAFT_BLESS=1)
+notes:        Golden reference image generated by crates/golden/tests/golden.rs (transition_wipe). Regenerate with FILMCRAFT_BLESS=1. Contains no Adobe artwork.
diff --git a/crates/golden/src/lib.rs b/crates/golden/src/lib.rs
new file mode 100644
index 000000000..71c8cad0e
--- /dev/null
+++ b/crates/golden/src/lib.rs
@@ -0,0 +1,8 @@
+//! Golden-image tests for FilmCraft's renderer (test-only crate; the library is empty).
+//!
+//! `tests/golden.rs` builds small procedural projects (no media files), renders one frame of each
+//! through the CPU reference compositor (`filmcraft-render`) and compares it with a committed PNG
+//! in `goldens/` using `filmcraft_testkit::golden`. The same scenes are composited on the GPU
+//! (`filmcraft-gpu`) when an adapter is available and compared with the CPU result.
+//!
+//! Regenerate references with `FILMCRAFT_BLESS=1 cargo test -p filmcraft-golden`.
diff --git a/crates/golden/tests/golden.rs b/crates/golden/tests/golden.rs
new file mode 100644
index 000000000..d007c69c6
--- /dev/null
+++ b/crates/golden/tests/golden.rs
@@ -0,0 +1,453 @@
+//! Golden-image tests: procedural projects rendered through the CPU compositor and compared with
+//! committed reference PNGs (`goldens/*.png`, made by this test with `FILMCRAFT_BLESS=1`), plus
+//! GPU-vs-CPU parity on the same scenes when a GPU adapter is available.
+//!
+//! Tolerances (8-bit sRGB levels, see `filmcraft_testkit::golden`):
+//! - CPU vs golden: `Tolerance::RENDER` — PSNR ≥ 45 dB, max abs ≤ 12, 99th percentile ≤ 2.
+//! - GPU vs CPU: 99th percentile of the per-pixel max channel difference ≤ 6 and mean < 1.5
+//!   (antialiased edges and half-float textures differ slightly; the CPU is the reference).
+
+use std::path::PathBuf;
+use std::sync::Arc;
+
+use filmcraft_geom::Vec2;
+use filmcraft_media::generators::GeneratorSource;
+use filmcraft_media::{DemoScene, Generator, MediaSource, SharedSource};
+use filmcraft_project::{
+    ClipId, EffectInstance, ItemId, ItemKind, Label, MediaClip, MediaRef, ParamValue, Project, SequenceSettings, TrackItem, TrackKind, Transition,
+    TransitionId, find_effect,
+};
+use filmcraft_render::{RenderOptions, SourceMap, render_sequence};
+use filmcraft_testkit::golden::{Rgba8, Tolerance, assert_golden, diff};
+use filmcraft_time::{FrameRate, TICKS_PER_SECOND, Tick, TimeRange};
+
+const W: u32 = 320;
+const H: u32 = 180;
+const RATE: FrameRate = FrameRate::FPS_24;
+
+/// A procedurally generated project and the frame to render.
+struct Scene {
+    project: Project,
+    seq: ItemId,
+    sources: SourceMap,
+    frame: i64,
+}
+
+struct Builder {
+    p: Project,
+    map: SourceMap,
+    seq: ItemId,
+    next_transition: u64,
+}
+
+impl Builder {
+    fn new(video_tracks: usize) -> Self {
+        let mut p = Project::new("golden");
+        let seq = p.new_sequence("golden", SequenceSettings { width: W, height: H, frame_rate: RATE, ..Default::default() }, video_tracks, 0, None);
+        Builder { p, map: SourceMap::default(), seq, next_transition: 1 }
+    }
+
+    /// A generated media item (640×360, 24 fps, 10 s).
+    fn media(&mut self, g: Generator) -> ItemId {
+        let src = GeneratorSource::new(g, 640, 360, RATE, Tick(10 * TICKS_PER_SECOND));
+        let info = src.info().clone();
+        let id = self.p.add_item(
+            &info.name.clone(),
+            Label::Iris,
+            ItemKind::Media(MediaClip {
+                media: MediaRef::Generator(src.generator.clone()),
+                info,
+                interpret: Default::default(),
+                mark_in: None,
+                mark_out: None,
+                markers: vec![],
+                offline: false,
+                proxy: None,
+            }),
+            None,
+        );
+        self.map.0.insert(id, Arc::new(src) as SharedSource);
+        id
+    }
+
+    fn demo(&mut self, scene: DemoScene) -> ItemId {
+        self.media(Generator::Demo(scene))
+    }
+
+    /// Place `item` on video track `track` (frames), scaled to the frame size.
+    fn place(&mut self, track: usize, item: ItemId, start: i64, dur: i64) -> ClipId {
+        let mut ti = self.p.make_track_item(item, TrackKind::Video, RATE.tick_of(start), TimeRange::new(Tick::ZERO, RATE.tick_of(dur)), RATE).unwrap();
+        ti.scale_to_frame = true;
+        let id = ti.id;
+        let s = self.p.sequence_mut(self.seq).unwrap();
+        s.video_tracks[track].items.push(ti);
+        s.video_tracks[track].sort();
+        id
+    }
+
+    fn clip(&mut self, id: ClipId) -> &mut TrackItem {
+        self.p.sequence_mut(self.seq).unwrap().find_item_mut(id).unwrap().1
+    }
+
+    /// Set intrinsic-effect parameters (`motion`, `opacity`).
+    fn fixed(&mut self, id: ClipId, effect: &str, params: &[(&str, ParamValue)]) {
+        let e = self.clip(id).effect_mut(effect).unwrap();
+        set(e, params);
+    }
+
+    /// Append a standard effect with parameters.
+    fn effect(&mut self, id: ClipId, effect: &str, params: &[(&str, ParamValue)]) {
+        let mut e = find_effect(effect).unwrap_or_else(|| panic!("no effect {effect}")).instance();
+        set(&mut e, params);
+        self.clip(id).effects.push(e);
+    }
+
+    /// A transition of `dur` frames centred on the cut at `cut` between `a` and `b` on `track`.
+    fn transition(&mut self, track: usize, effect: &str, a: ClipId, b: ClipId, cut: i64, dur: i64) {
+        let id = TransitionId(self.next_transition);
+        self.next_transition += 1;
+        let tr = Transition {
+            id,
+            effect: find_effect(effect).unwrap_or_else(|| panic!("no transition {effect}")).instance(),
+            start: RATE.tick_of(cut - dur / 2),
+            duration: RATE.tick_of(dur),
+            from: Some(a),
+            to: Some(b),
+            align: Default::default(),
+            reverse: false,
+        };
+        self.p.sequence_mut(self.seq).unwrap().video_tracks[track].transitions.push(tr);
+    }
+
+    fn at(self, frame: i64) -> Scene {
+        Scene { project: self.p, seq: self.seq, sources: self.map, frame }
+    }
+}
+
+fn set(e: &mut EffectInstance, params: &[(&str, ParamValue)]) {
+    let id = e.effect.clone();
+    for (k, v) in params {
+        e.param_mut(k).unwrap_or_else(|| panic!("{id}: no param {k}")).value = v.clone();
+    }
+}
+
+fn fl(v: f64) -> ParamValue {
+    ParamValue::Float(v)
+}
+
+fn pt(x: f64, y: f64) -> ParamValue {
+    ParamValue::Vec2(Vec2::new(x, y))
+}
+
+fn blend(name: &str) -> ParamValue {
+    ParamValue::Choice(filmcraft_project::effect::BLEND_MODES.iter().position(|b| *b == name).unwrap_or_else(|| panic!("blend {name}")) as u32)
+}
+
+// ---- scenes ----
+
+/// Motion (scale, rotation, position) and 70 % opacity over a full-frame background.
+fn transform_opacity() -> Scene {
+    let mut b = Builder::new(2);
+    let bg = b.demo(DemoScene::OceanSunset);
+    let fg = b.demo(DemoScene::Aurora);
+    b.place(0, bg, 0, 48);
+    let top = b.place(1, fg, 0, 48);
+    b.fixed(top, "motion", &[("scale", fl(45.0)), ("rotation", fl(20.0)), ("position", pt(215.0, 70.0))]);
+    b.fixed(top, "opacity", &[("opacity", fl(70.0))]);
+    b.at(12)
+}
+
+/// Four quadrant layers over a background in Multiply, Screen, Overlay and Difference.
+fn blend_modes() -> Scene {
+    let mut b = Builder::new(5);
+    let bg = b.demo(DemoScene::OceanSunset);
+    let fg = b.demo(DemoScene::Dunes);
+    b.place(0, bg, 0, 48);
+    for (i, (mode, x, y)) in [("Multiply", 80.0, 45.0), ("Screen", 240.0, 45.0), ("Overlay", 80.0, 135.0), ("Difference", 240.0, 135.0)].into_iter().enumerate()
+    {
+        let c = b.place(i + 1, fg, 0, 48);
+        b.fixed(c, "motion", &[("scale", fl(50.0)), ("position", pt(x, y))]);
+        b.fixed(c, "opacity", &[("blend", blend(mode))]);
+    }
+    b.at(12)
+}
+
+/// Gaussian Blur on colour bars (sharp edges show the kernel).
+fn gaussian_blur() -> Scene {
+    let mut b = Builder::new(1);
+    let bars = b.media(Generator::BarsAndTone);
+    let c = b.place(0, bars, 0, 48);
+    b.effect(c, "gaussian_blur", &[("blurriness", fl(12.0))]);
+    b.at(12)
+}
+
+/// Lumetri Color basic correction: temperature, exposure, contrast, highlights/shadows, saturation.
+fn lumetri_basic() -> Scene {
+    let mut b = Builder::new(1);
+    let bg = b.demo(DemoScene::OceanSunset);
+    let c = b.place(0, bg, 0, 48);
+    b.effect(
+        c,
+        "lumetri",
+        &[
+            ("temperature", fl(25.0)),
+            ("exposure", fl(0.6)),
+            ("contrast", fl(30.0)),
+            ("highlights", fl(-30.0)),
+            ("shadows", fl(25.0)),
+            ("saturation", fl(135.0)),
+        ],
+    );
+    b.at(12)
+}
+
+/// Crop (left/top/right/bottom) of a top layer revealing the background.
+fn crop() -> Scene {
+    let mut b = Builder::new(2);
+    let bg = b.demo(DemoScene::OceanSunset);
+    let bars = b.media(Generator::BarsAndTone);
+    b.place(0, bg, 0, 48);
+    let c = b.place(1, bars, 0, 48);
+    b.effect(c, "crop", &[("left", fl(15.0)), ("top", fl(10.0)), ("right", fl(25.0)), ("bottom", fl(20.0))]);
+    b.at(12)
+}
+
+/// Two clips with a 12-frame transition centred on the cut at frame 24, rendered at `frame`.
+fn transition(effect: &str, frame: i64) -> Scene {
+    let mut b = Builder::new(1);
+    let a = b.demo(DemoScene::OceanSunset);
+    let c = b.demo(DemoScene::Aurora);
+    let ca = b.place(0, a, 0, 24);
+    let cb = b.place(0, c, 24, 24);
+    b.transition(0, effect, ca, cb, 24, 12);
+    b.at(frame)
+}
+
+/// Timecode and Clip Name burn-ins (text engine: JetBrains Mono / Inter).
+fn text_burnin() -> Scene {
+    let mut b = Builder::new(1);
+    let bg = b.demo(DemoScene::CityNight);
+    let c = b.place(0, bg, 0, 48);
+    b.effect(c, "timecode", &[("position", pt(160.0, 40.0)), ("size", fl(20.0))]);
+    b.effect(c, "clip_name", &[("position", pt(160.0, 145.0)), ("size", fl(12.0))]);
+    b.at(30)
+}
+
+/// A graphic clip on V2 over `bg` on V1, with `layers` (graphic layer effect instances).
+fn graphic_scene(bg: DemoScene, layers: Vec<EffectInstance>) -> Scene {
+    let mut b = Builder::new(2);
+    let bgi = b.demo(bg);
+    b.place(0, bgi, 0, 48);
+    let g = b.p.add_item("Graphic", Label::Rose, ItemKind::Graphic { width: W, height: H, rate: RATE }, None);
+    let c = b.place(1, g, 0, 48);
+    for mut l in layers {
+        filmcraft_project::resolve_auto_points(&mut l, (W, H), (W, H));
+        b.clip(c).effects.push(l);
+    }
+    b.at(12)
+}
+
+/// A title: bold centred text with an outer stroke and a soft drop shadow, a lower-third bar with
+/// rounded corners and a background-boxed caption line.
+fn graphic_title() -> Scene {
+    use filmcraft_project::graphic::{new_shape_layer, new_text_layer};
+    let mut bar = new_shape_layer(0, Vec2::new(160.0, 150.0), Vec2::new(280.0, 34.0), vec![]);
+    set(&mut bar, &[("corner_radius", fl(8.0)), ("fill_color", ParamValue::Color([0.12, 0.35, 0.8, 1.0])), ("opacity", fl(85.0))]);
+    let mut title = new_text_layer("Night Drive", Vec2::new(160.0, 80.0), 44.0);
+    set(
+        &mut title,
+        &[
+            ("font_style", ParamValue::Text("Bold".into())),
+            ("align", ParamValue::Choice(1)),
+            ("stroke", ParamValue::Bool(true)),
+            ("stroke_width", fl(2.5)),
+            ("stroke_color", ParamValue::Color([0.05, 0.05, 0.1, 1.0])),
+            ("shadow", ParamValue::Bool(true)),
+            ("shadow_distance", fl(5.0)),
+            ("shadow_blur", fl(8.0)),
+            ("tracking", fl(40.0)),
+        ],
+    );
+    let mut sub = new_text_layer("Directed by Nobody", Vec2::new(160.0, 156.0), 16.0);
+    set(
+        &mut sub,
+        &[
+            ("align", ParamValue::Choice(1)),
+            ("font", ParamValue::Text("Noto Serif".into())),
+            ("faux_italic", ParamValue::Bool(true)),
+            ("caps", ParamValue::Choice(2)),
+            ("fill_color", ParamValue::Color([1.0, 0.92, 0.6, 1.0])),
+        ],
+    );
+    graphic_scene(DemoScene::CityNight, vec![bar, title, sub])
+}
+
+/// Shapes: ellipse with centre stroke, rotated polygon with inner stroke, a pen path, rotated
+/// boxed text with a background and 2 strokes.
+fn graphic_shapes() -> Scene {
+    use filmcraft_project::graphic::{new_shape_layer, new_text_layer};
+    let mut ell = new_shape_layer(1, Vec2::new(70.0, 60.0), Vec2::new(100.0, 70.0), vec![]);
+    set(
+        &mut ell,
+        &[
+            ("stroke", ParamValue::Bool(true)),
+            ("stroke_width", fl(6.0)),
+            ("stroke_type", ParamValue::Choice(1)),
+            ("stroke_color", ParamValue::Color([1.0, 1.0, 1.0, 1.0])),
+        ],
+    );
+    let mut poly = new_shape_layer(2, Vec2::new(250.0, 60.0), Vec2::new(80.0, 80.0), vec![]);
+    set(
+        &mut poly,
+        &[
+            ("sides", fl(5.0)),
+            ("rotation", fl(18.0)),
+            ("fill_color", ParamValue::Color([0.2, 0.8, 0.4, 1.0])),
+            ("stroke", ParamValue::Bool(true)),
+            ("stroke_type", ParamValue::Choice(2)),
+            ("stroke_width", fl(5.0)),
+        ],
+    );
+    let path = new_shape_layer(3, Vec2::new(70.0, 140.0), Vec2::new(0.0, 0.0), vec![[-40.0, 20.0], [0.0, -25.0], [40.0, 20.0], [0.0, 5.0]]);
+    let mut txt = new_text_layer("Rotated\nTwo lines", Vec2::new(215.0, 140.0), 20.0);
+    set(
+        &mut txt,
+        &[
+            ("rotation", fl(-12.0)),
+            ("align", ParamValue::Choice(1)),
+            ("background", ParamValue::Bool(true)),
+            ("background_radius", fl(6.0)),
+            ("background_size", fl(6.0)),
+            ("stroke", ParamValue::Bool(true)),
+            ("stroke_width", fl(1.5)),
+            ("stroke2", ParamValue::Bool(true)),
+            ("stroke2_width", fl(3.5)),
+        ],
+    );
+    graphic_scene(DemoScene::Aurora, vec![ell, poly, path, txt])
+}
+
+/// (name, title, scene).
+fn scenes() -> Vec<(&'static str, &'static str, fn() -> Scene)> {
+    vec![
+        ("transform_opacity", "Motion transform and opacity", transform_opacity),
+        ("blend_modes", "Blend modes (Multiply, Screen, Overlay, Difference)", blend_modes),
+        ("gaussian_blur", "Gaussian Blur effect", gaussian_blur),
+        ("lumetri_basic", "Lumetri Color basic correction", lumetri_basic),
+        ("crop", "Crop effect", crop),
+        ("transition_cross_dissolve", "Cross Dissolve at 50%", || transition("cross_dissolve", 24)),
+        ("transition_dip_to_black", "Dip to Black at 25%", || transition("dip_to_black", 21)),
+        ("transition_wipe", "Wipe at 50%", || transition("wipe", 24)),
+        ("text_burnin", "Timecode and Clip Name burn-in text", text_burnin),
+        ("graphic_title", "Graphic clip: title text with stroke and shadow, lower-third bar", graphic_title),
+        ("graphic_shapes", "Graphic clip: ellipse, polygon, path and rotated text with background", graphic_shapes),
+    ]
+}
+
+fn render_cpu(s: &Scene) -> Rgba8 {
+    let img = render_sequence(&s.project, s.seq, RATE.tick_of(s.frame), RenderOptions::default(), &s.sources);
+    Rgba8::new(img.w as u32, img.h as u32, img.over_black_rgba8())
+}
+
+fn golden_path(name: &str) -> PathBuf {
+    PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("goldens").join(format!("{name}.png"))
+}
+
+fn check(name: &str) {
+    let (_, title, make) = scenes().into_iter().find(|(n, _, _)| *n == name).unwrap();
+    let img = render_cpu(&make());
+    assert_eq!((img.w, img.h), (W, H));
+    let d = assert_golden(&golden_path(name), &img, Tolerance::RENDER, title, &format!("crates/golden/tests/golden.rs ({name})"));
+    eprintln!("{name}: {d}");
+}
+
+macro_rules! goldens {
+    ($($name:ident),* $(,)?) => {
+        mod cpu {
+            $(
+                #[test]
+                fn $name() {
+                    super::check(stringify!($name));
+                }
+            )*
+        }
+
+        #[test]
+        fn every_scene_has_a_test() {
+            let tested = [$(stringify!($name)),*];
+            for (n, _, _) in scenes() {
+                assert!(tested.contains(&n), "scene {n} has no golden test");
+            }
+        }
+    };
+}
+
+goldens!(
+    transform_opacity,
+    blend_modes,
+    gaussian_blur,
+    lumetri_basic,
+    crop,
+    transition_cross_dissolve,
+    transition_dip_to_black,
+    transition_wipe,
+    text_burnin,
+    graphic_title,
+    graphic_shapes
+);
+
+/// Sanity: the scenes are not trivially empty or identical to each other.
+#[test]
+fn scenes_are_distinct() {
+    let imgs: Vec<(&str, Rgba8)> = scenes().into_iter().map(|(n, _, f)| (n, render_cpu(&f()))).collect();
+    for (n, img) in &imgs {
+        let lit = img.px.chunks_exact(4).filter(|p| p[0] as u32 + p[1] as u32 + p[2] as u32 > 30).count();
+        assert!(lit > img.px.len() / 4 / 4, "{n}: mostly black");
+    }
+    for i in 0..imgs.len() {
+        for j in i + 1..imgs.len() {
+            let d = diff(&imgs[i].1, &imgs[j].1).unwrap();
+            assert!(d.psnr < 30.0, "{} and {} are near-identical ({d})", imgs[i].0, imgs[j].0);
+        }
+    }
+}
+
+// ---- GPU parity ----
+
+fn device() -> Option<(wgpu::Device, wgpu::Queue)> {
+    let instance = wgpu::Instance::default();
+    let adapter = pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions::default())).ok()?;
+    pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor::default())).ok()
+}
+
+#[test]
+fn gpu_matches_cpu_on_golden_scenes() {
+    let Some((dev, q)) = device() else {
+        eprintln!("SKIPPED (gpu parity): no GPU adapter");
+        return;
+    };
+    let mut c = filmcraft_gpu::GpuCompositor::new(&dev, &q);
+    let mut failures = Vec::new();
+    for (name, _, make) in scenes() {
+        let s = make();
+        let t = RATE.tick_of(s.frame);
+        let cpu = render_cpu(&s);
+        let plan = filmcraft_render::plan::plan_frame(&s.project, s.seq, t, RenderOptions::default(), &s.sources);
+        let kind = if matches!(plan, filmcraft_render::plan::FramePlan::Layers { .. }) { "layers" } else { "cpu image" };
+        c.composite(&plan);
+        let (gw, gh, mut px) = c.read_output().expect("GPU readback");
+        px.chunks_exact_mut(4).for_each(|p| p[3] = 255);
+        let gpu = Rgba8::new(gw, gh, px);
+        let d = diff(&cpu, &gpu).unwrap();
+        // mean over RGB only (alpha is equal by construction)
+        let mean_rgb = d.mean_abs * 4.0 / 3.0;
+        eprintln!("{name} ({kind}): GPU vs CPU {d}");
+        if d.p99 > 6 || mean_rgb >= 1.5 {
+            let dir = filmcraft_testkit::golden::failures_dir();
+            let _ = filmcraft_testkit::golden::write_png(&dir.join(format!("{name}.gpu.png")), &gpu);
+            let _ = filmcraft_testkit::golden::write_png(&dir.join(format!("{name}.cpu.png")), &cpu);
+            failures.push(format!("{name} ({kind}): {d}; images in {}", dir.display()));
+        }
+    }
+    assert!(failures.is_empty(), "GPU differs from the CPU reference:\n{}", failures.join("\n"));
+}
diff --git a/crates/gpu/src/lib.rs b/crates/gpu/src/lib.rs
index 792f8d471..3dfe56699 100644
--- a/crates/gpu/src/lib.rs
+++ b/crates/gpu/src/lib.rs
@@ -33,6 +33,9 @@ struct Uploaded {
     code_scale: f32,
     chroma: (u32, u32),
     last_used: u64,
+    /// The uploaded pixel buffers, kept alive while cached: the cache key is the buffer address,
+    /// and a freed buffer's address can be reused by a different frame (stale texture).
+    _pixels: PixelData,
 }
 
 pub struct GpuCompositor {
@@ -330,7 +333,7 @@ impl GpuCompositor {
         let up = match &f.data {
             PixelData::Rgba8(d) => {
                 let v = self.plane_texture(w, h, wgpu::TextureFormat::Rgba8UnormSrgb, d, 4);
-                Uploaded { views: [v, dummy(), dummy()], kind: 0, code_scale: 1.0, chroma: (w, h), last_used: self.clock }
+                Uploaded { views: [v, dummy(), dummy()], kind: 0, code_scale: 1.0, chroma: (w, h), last_used: self.clock, _pixels: f.data.clone() }
             }
             PixelData::RgbaF32(d) => {
                 let owned;
@@ -342,7 +345,7 @@ impl GpuCompositor {
                     }
                 };
                 let v = self.plane_texture(w, h, wgpu::TextureFormat::Rgba16Float, half, 8);
-                Uploaded { views: [v, dummy(), dummy()], kind: 1, code_scale: 1.0, chroma: (w, h), last_used: self.clock }
+                Uploaded { views: [v, dummy(), dummy()], kind: 1, code_scale: 1.0, chroma: (w, h), last_used: self.clock, _pixels: f.data.clone() }
             }
             PixelData::Yuv8 { planes, chroma, .. } => {
                 let (sx, sy) = chroma.shifts();
@@ -350,7 +353,7 @@ impl GpuCompositor {
                 let y = self.plane_texture(w, h, wgpu::TextureFormat::R8Unorm, &planes[0], 1);
                 let u = self.plane_texture(cw, ch, wgpu::TextureFormat::R8Unorm, &planes[1], 1);
                 let v = self.plane_texture(cw, ch, wgpu::TextureFormat::R8Unorm, &planes[2], 1);
-                Uploaded { views: [y, u, v], kind: 2, code_scale: 255.0, chroma: (cw, ch), last_used: self.clock }
+                Uploaded { views: [y, u, v], kind: 2, code_scale: 255.0, chroma: (cw, ch), last_used: self.clock, _pixels: f.data.clone() }
             }
             PixelData::Yuv16 { planes, chroma, bits, .. } => {
                 let (sx, sy) = chroma.shifts();
@@ -368,7 +371,7 @@ impl GpuCompositor {
                 let u = self.plane_texture(cw, ch, wgpu::TextureFormat::R16Float, &p.planes[1], 2);
                 let v = self.plane_texture(cw, ch, wgpu::TextureFormat::R16Float, &p.planes[2], 2);
                 let _ = Chroma::C420;
-                Uploaded { views: [y, u, v], kind: 2, code_scale: scale, chroma: (cw, ch), last_used: self.clock }
+                Uploaded { views: [y, u, v], kind: 2, code_scale: scale, chroma: (cw, ch), last_used: self.clock, _pixels: f.data.clone() }
             }
         };
         self.uploads.insert(key, up);
diff --git a/crates/gpu/src/tests.rs b/crates/gpu/src/tests.rs
index f0013da4a..479d49e29 100644
--- a/crates/gpu/src/tests.rs
+++ b/crates/gpu/src/tests.rs
@@ -125,3 +125,21 @@ fn prepared_upload_matches_inline_conversion() {
         assert!(inline == prepared, "prepared upload differs");
     }
 }
+
+/// The upload cache is keyed by pixel-buffer address, so it must keep the buffer alive: otherwise
+/// a new frame allocated at a freed frame's address is drawn with the stale texture (seen as
+/// whole frames from a previous composite in `crates/golden` GPU parity).
+#[test]
+fn upload_cache_keeps_buffers_alive() {
+    let Some((dev, q)) = device() else {
+        eprintln!("no GPU adapter; skipping");
+        return;
+    };
+    let mut c = GpuCompositor::new(&dev, &q);
+    let px = Arc::new(vec![200u8; 16 * 8 * 4]);
+    let frame = Arc::new(VideoFrame { width: 16, height: 8, data: PixelData::Rgba8(px.clone()), ..(*yuv_frame(16, 8)).clone() });
+    let plan = FramePlan::Layers { width: 16, height: 8, layers: vec![PlanLayer { frame, matrix: Affine::IDENTITY, opacity: 1.0 }] };
+    c.composite(&plan);
+    drop(plan);
+    assert!(Arc::strong_count(&px) > 1, "cached upload must own its pixel buffer");
+}
diff --git a/crates/h264/Cargo.toml b/crates/h264/Cargo.toml
index c33f682c2..f2a1eb8f3 100644
--- a/crates/h264/Cargo.toml
+++ b/crates/h264/Cargo.toml
@@ -19,3 +19,4 @@ thiserror = { workspace = true }
 rayon = { workspace = true, optional = true }
 
 [dev-dependencies]
+filmcraft-testkit = { workspace = true }
diff --git a/crates/h264/src/synth_tests.rs b/crates/h264/src/synth_tests.rs
index dacde84ea..69c887390 100644
--- a/crates/h264/src/synth_tests.rs
+++ b/crates/h264/src/synth_tests.rs
@@ -437,17 +437,12 @@ type Planes3 = (Vec<u8>, Vec<u8>, Vec<u8>);
 
 /// Validate the hand-built stream and its expected output with ffmpeg when available.
 fn cross_check_ffmpeg(stream: &[u8], expected: &[Planes3], name: &str) {
-    let ff = std::path::Path::new("/opt/homebrew/bin/ffmpeg");
-    if !ff.exists() {
-        eprintln!("ffmpeg not found; skipping oracle check of {name}");
-        return;
-    }
-    let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../target/fixtures/h264");
-    std::fs::create_dir_all(&dir).unwrap();
-    let src = dir.join(format!("{name}.{}.h264", std::process::id()));
-    let dst = dir.join(format!("{name}.{}.yuv", std::process::id()));
+    let Some(ff) = filmcraft_testkit::ffmpeg_or_skip(name) else { return };
+    let dir = filmcraft_testkit::fixtures_dir("h264");
+    let src = filmcraft_testkit::temp_path(&dir.join(format!("{name}.h264")));
+    let dst = filmcraft_testkit::temp_path(&dir.join(format!("{name}.yuv")));
     std::fs::write(&src, stream).unwrap();
-    let ok = std::process::Command::new(ff)
+    let ok = std::process::Command::new(&ff)
         .args(["-hide_banner", "-loglevel", "error", "-y", "-i"])
         .arg(&src)
         .args(["-fps_mode", "passthrough", "-f", "rawvideo", "-pix_fmt", "yuv420p"])
diff --git a/crates/h264/tests/common/mod.rs b/crates/h264/tests/common/mod.rs
index dc7263000..78466ff50 100644
--- a/crates/h264/tests/common/mod.rs
+++ b/crates/h264/tests/common/mod.rs
@@ -307,19 +307,13 @@ pub fn fixture(name: &str) -> &'static Fixture {
     FIXTURES.iter().find(|f| f.name == name).unwrap_or_else(|| panic!("unknown fixture {name}"))
 }
 
+/// ffmpeg (see `filmcraft_testkit::oracle`).
 pub fn ffmpeg() -> Option<PathBuf> {
-    for p in ["/opt/homebrew/bin/ffmpeg", "/usr/local/bin/ffmpeg", "/usr/bin/ffmpeg"] {
-        if Path::new(p).exists() {
-            return Some(PathBuf::from(p));
-        }
-    }
-    None
+    filmcraft_testkit::ffmpeg()
 }
 
 pub fn fixtures_dir() -> PathBuf {
-    let d = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../target/fixtures/h264");
-    std::fs::create_dir_all(&d).expect("create fixtures dir");
-    d
+    filmcraft_testkit::fixtures_dir("h264")
 }
 
 fn run(cmd: &mut Command) -> bool {
@@ -339,15 +333,12 @@ fn run(cmd: &mut Command) -> bool {
 /// Generate (if needed) the fixture stream and its ffmpeg reference decode.
 /// Returns None (with a message) when ffmpeg is unavailable.
 pub fn ensure(f: &Fixture) -> Option<(PathBuf, PathBuf)> {
-    let Some(ff) = ffmpeg() else {
-        eprintln!("SKIP {}: ffmpeg not found", f.name);
-        return None;
-    };
+    let ff = filmcraft_testkit::ffmpeg_or_skip(f.name)?;
     let dir = fixtures_dir();
     let h264 = dir.join(format!("{}.h264", f.name));
     let yuv = dir.join(format!("{}.yuv", f.name));
     if !h264.exists() {
-        let tmp = dir.join(format!("{}.tmp.{}.h264", f.name, std::process::id()));
+        let tmp = filmcraft_testkit::temp_path(&h264);
         let mut vf = format!("{}=size={}x{}:rate=25,format=yuv420p", f.source, f.width, f.height);
         if !f.filter.is_empty() {
             vf.push(',');
@@ -364,13 +355,13 @@ pub fn ensure(f: &Fixture) -> Option<(PathBuf, PathBuf)> {
         if !run(&mut c) {
             // Platform encoders (VideoToolbox) are optional; libx264 fixtures must generate.
             assert!(f.args.contains(&"-c:v"), "fixture generation failed for {}", f.name);
-            eprintln!("SKIP {}: encoder unavailable", f.name);
+            eprintln!("SKIPPED ({}): encoder unavailable", f.name);
             return None;
         }
         std::fs::rename(&tmp, &h264).unwrap();
     }
     if !yuv.exists() {
-        let tmp = dir.join(format!("{}.tmp.{}.yuv", f.name, std::process::id()));
+        let tmp = filmcraft_testkit::temp_path(&yuv);
         let mut c = Command::new(&ff);
         c.args(["-hide_banner", "-loglevel", "error", "-y", "-i"]).arg(&h264);
         c.args(["-fps_mode", "passthrough", "-f", "rawvideo", "-pix_fmt", "yuv420p"]).arg(&tmp);
diff --git a/crates/h264/tests/conformance.rs b/crates/h264/tests/conformance.rs
index dc4ddaea5..a2654c9cd 100644
--- a/crates/h264/tests/conformance.rs
+++ b/crates/h264/tests/conformance.rs
@@ -95,3 +95,14 @@ fn coverage_report() {
         );
     }
 }
+
+/// Pre-generate every fixture and its reference decode (`cargo xtask fixtures`).
+#[test]
+#[ignore]
+fn generate_fixtures() {
+    let dir = common::fixtures_dir();
+    for f in common::FIXTURES {
+        let outs = [dir.join(format!("{}.h264", f.name)), dir.join(format!("{}.yuv", f.name))];
+        filmcraft_testkit::fixtures::generate_and_report(&format!("h264/{}", f.name), &outs, || common::ensure(f));
+    }
+}
diff --git a/crates/h264enc/Cargo.toml b/crates/h264enc/Cargo.toml
index 988eed7fd..8385ba913 100644
--- a/crates/h264enc/Cargo.toml
+++ b/crates/h264enc/Cargo.toml
@@ -17,3 +17,6 @@ threads = ["dep:rayon"]
 filmcraft-bitstream = { workspace = true }
 thiserror = { workspace = true }
 rayon = { workspace = true, optional = true }
+
+[dev-dependencies]
+filmcraft-testkit = { workspace = true }
diff --git a/crates/h264enc/tests/common/mod.rs b/crates/h264enc/tests/common/mod.rs
index 18ddc360e..409175fe0 100644
--- a/crates/h264enc/tests/common/mod.rs
+++ b/crates/h264enc/tests/common/mod.rs
@@ -95,29 +95,19 @@ pub fn synth(w: usize, h: usize, t: usize) -> Yuv {
     Yuv { w, h, y, u, v }
 }
 
+/// ffmpeg (see `filmcraft_testkit::oracle`); `None` after printing `SKIPPED`.
 pub fn ffmpeg() -> Option<PathBuf> {
-    for p in ["/opt/homebrew/bin/ffmpeg", "/usr/local/bin/ffmpeg", "/usr/bin/ffmpeg"] {
-        if Path::new(p).exists() {
-            return Some(p.into());
-        }
-    }
-    None
+    filmcraft_testkit::ffmpeg_or_skip("h264enc oracle")
 }
 
+/// ffprobe (see `filmcraft_testkit::oracle`); `None` after printing `SKIPPED`.
 pub fn ffprobe() -> Option<PathBuf> {
-    for p in ["/opt/homebrew/bin/ffprobe", "/usr/local/bin/ffprobe", "/usr/bin/ffprobe"] {
-        if Path::new(p).exists() {
-            return Some(p.into());
-        }
-    }
-    None
+    filmcraft_testkit::ffprobe_or_skip("h264enc oracle")
 }
 
+/// Per-test output directory under `<workspace>/target/fixtures/h264enc/`.
 pub fn out_dir(name: &str) -> PathBuf {
-    let base = std::env::var("CARGO_TARGET_DIR").map(PathBuf::from).unwrap_or_else(|_| PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../target"));
-    let d = base.join("fixtures").join("h264enc").join(name);
-    std::fs::create_dir_all(&d).unwrap();
-    d
+    filmcraft_testkit::fixtures_dir(&format!("h264enc/{name}"))
 }
 
 /// Decode an Annex-B file with ffmpeg; returns (stderr, raw yuv420p bytes).
diff --git a/crates/hevc/Cargo.toml b/crates/hevc/Cargo.toml
index 7e963a21c..b401435cd 100644
--- a/crates/hevc/Cargo.toml
+++ b/crates/hevc/Cargo.toml
@@ -19,3 +19,4 @@ thiserror = { workspace = true }
 rayon = { workspace = true, optional = true }
 
 [dev-dependencies]
+filmcraft-testkit = { workspace = true }
diff --git a/crates/hevc/src/synth_tests.rs b/crates/hevc/src/synth_tests.rs
index 291a2ad05..44b8a828a 100644
--- a/crates/hevc/src/synth_tests.rs
+++ b/crates/hevc/src/synth_tests.rs
@@ -546,14 +546,10 @@ fn as_u8(p: &crate::Plane) -> &[u8] {
 
 /// Compare with ffmpeg's decode of the same stream (skipped when ffmpeg is absent).
 fn check_ffmpeg(name: &str, stream: &[u8], pics: &[crate::Picture]) {
-    let Some(ff) = ["/opt/homebrew/bin/ffmpeg", "/usr/local/bin/ffmpeg", "/usr/bin/ffmpeg"].iter().find(|p| std::path::Path::new(p).exists()) else {
-        eprintln!("SKIP ffmpeg check for {name}");
-        return;
-    };
-    let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../target/fixtures/hevc");
-    std::fs::create_dir_all(&dir).unwrap();
-    let src = dir.join(format!("synth_{name}.hevc"));
-    let yuv = dir.join(format!("synth_{name}.yuv"));
+    let Some(ff) = filmcraft_testkit::ffmpeg_or_skip(name) else { return };
+    let dir = filmcraft_testkit::fixtures_dir("hevc");
+    let src = filmcraft_testkit::temp_path(&dir.join(format!("synth_{name}.hevc")));
+    let yuv = filmcraft_testkit::temp_path(&dir.join(format!("synth_{name}.yuv")));
     std::fs::write(&src, stream).unwrap();
     let st = std::process::Command::new(ff)
         .args(["-hide_banner", "-loglevel", "error", "-y", "-i"])
@@ -577,6 +573,7 @@ fn check_ffmpeg(name: &str, stream: &[u8], pics: &[crate::Picture]) {
         }
     }
     let _ = std::fs::remove_file(&yuv);
+    let _ = std::fs::remove_file(&src);
 }
 
 fn run(name: &str, tiles: Tiles, pcm_lf_disabled: bool, segments: Vec<Segment>) {
diff --git a/crates/hevc/tests/common/mod.rs b/crates/hevc/tests/common/mod.rs
index 2da4dabed..56d368294 100644
--- a/crates/hevc/tests/common/mod.rs
+++ b/crates/hevc/tests/common/mod.rs
@@ -85,19 +85,13 @@ pub fn fixture(name: &str) -> &'static Fixture {
     FIXTURES.iter().find(|f| f.name == name).unwrap_or_else(|| panic!("unknown fixture {name}"))
 }
 
+/// ffmpeg (see `filmcraft_testkit::oracle`).
 pub fn ffmpeg() -> Option<PathBuf> {
-    for p in ["/opt/homebrew/bin/ffmpeg", "/usr/local/bin/ffmpeg", "/usr/bin/ffmpeg"] {
-        if Path::new(p).exists() {
-            return Some(PathBuf::from(p));
-        }
-    }
-    None
+    filmcraft_testkit::ffmpeg()
 }
 
 pub fn fixtures_dir() -> PathBuf {
-    let d = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../target/fixtures/hevc");
-    std::fs::create_dir_all(&d).expect("create fixtures dir");
-    d
+    filmcraft_testkit::fixtures_dir("hevc")
 }
 
 fn run(cmd: &mut Command) -> bool {
@@ -121,15 +115,12 @@ pub fn pix_fmt(bd: u32) -> &'static str {
 /// Generate (if needed) the fixture stream and its ffmpeg reference decode.
 /// Returns None (with a message) when ffmpeg or the encoder is unavailable.
 pub fn ensure(f: &Fixture) -> Option<(PathBuf, PathBuf)> {
-    let Some(ff) = ffmpeg() else {
-        eprintln!("SKIP {}: ffmpeg not found", f.name);
-        return None;
-    };
+    let ff = filmcraft_testkit::ffmpeg_or_skip(f.name)?;
     let dir = fixtures_dir();
     let hevc = dir.join(format!("{}.hevc", f.name));
     let yuv = dir.join(format!("{}.yuv", f.name));
     if !hevc.exists() {
-        let tmp = dir.join(format!("{}.tmp.{}.hevc", f.name, unique()));
+        let tmp = filmcraft_testkit::temp_path(&hevc);
         let mut vf = format!("{}=size={}x{}:rate=25,format={}", f.source, f.width, f.height, pix_fmt(f.bit_depth));
         if !f.filter.is_empty() {
             vf.push(',');
@@ -148,13 +139,13 @@ pub fn ensure(f: &Fixture) -> Option<(PathBuf, PathBuf)> {
             // Platform encoders (VideoToolbox) are optional; libx265 fixtures must generate.
             assert!(f.args.contains(&"-c:v"), "fixture generation failed for {}", f.name);
             let _ = std::fs::remove_file(&tmp);
-            eprintln!("SKIP {}: encoder unavailable", f.name);
+            eprintln!("SKIPPED ({}): encoder unavailable", f.name);
             return None;
         }
         std::fs::rename(&tmp, &hevc).unwrap();
     }
     if !yuv.exists() {
-        let tmp = dir.join(format!("{}.tmp.{}.yuv", f.name, unique()));
+        let tmp = filmcraft_testkit::temp_path(&yuv);
         let mut c = Command::new(&ff);
         c.args(["-hide_banner", "-loglevel", "error", "-y", "-i"]).arg(&hevc);
         c.args(["-fps_mode", "passthrough", "-f", "rawvideo", "-pix_fmt", pix_fmt(f.bit_depth)]).arg(&tmp);
@@ -316,9 +307,3 @@ pub fn check_pts(pics: &[Picture]) -> Result<(), String> {
     }
     Ok(())
 }
-
-/// Unique temp-file suffix: process id plus a per-process counter (tests run on parallel threads).
-fn unique() -> String {
-    static N: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
-    format!("{}-{}", std::process::id(), N.fetch_add(1, std::sync::atomic::Ordering::Relaxed))
-}
diff --git a/crates/hevc/tests/conformance.rs b/crates/hevc/tests/conformance.rs
index 0dfd0d8cd..a6109ddfe 100644
--- a/crates/hevc/tests/conformance.rs
+++ b/crates/hevc/tests/conformance.rs
@@ -91,3 +91,14 @@ fn compare_detects_mismatch() {
     let err = common::compare(&pics, &reference, f.width as usize, f.height as usize, f.bit_depth).unwrap_err();
     assert!(err.contains("plane V"), "{err}");
 }
+
+/// Pre-generate every fixture and its reference decode (`cargo xtask fixtures`).
+#[test]
+#[ignore]
+fn generate_fixtures() {
+    let dir = common::fixtures_dir();
+    for f in common::FIXTURES {
+        let outs = [dir.join(format!("{}.hevc", f.name)), dir.join(format!("{}.yuv", f.name))];
+        filmcraft_testkit::fixtures::generate_and_report(&format!("hevc/{}", f.name), &outs, || common::ensure(f));
+    }
+}
diff --git a/crates/interchange/src/common.rs b/crates/interchange/src/common.rs
index a8b63526d..d2adb920c 100644
--- a/crates/interchange/src/common.rs
+++ b/crates/interchange/src/common.rs
@@ -469,6 +469,8 @@ pub(crate) fn empty_sequence(settings: SequenceSettings) -> Sequence {
         start_timecode: 0,
         master_volume_db: 0.0,
         master_effects: Vec::new(),
+        master_mixer: Default::default(),
+        submix_tracks: Vec::new(),
         caption_tracks: Vec::new(),
     }
 }
@@ -594,6 +596,7 @@ pub(crate) fn transition_effect(name: &str, audio: bool, report: &mut Report) ->
         enabled: true,
         params: Default::default(),
         masks: vec![],
+        post_fader: false,
     })
 }
 
diff --git a/crates/interchange/src/lib.rs b/crates/interchange/src/lib.rs
index 6e57d825a..b29f5723e 100644
--- a/crates/interchange/src/lib.rs
+++ b/crates/interchange/src/lib.rs
@@ -427,7 +427,7 @@ pub fn merge_into(target: &mut Project, fragment: Imported, bin: Option<BinId>)
                     mk.id = MarkerId(target.alloc_id());
                 }
             }
-            ItemKind::AdjustmentLayer { .. } => {}
+            ItemKind::AdjustmentLayer { .. } | ItemKind::Graphic { .. } => {}
         }
         new_items.insert(it.id, it);
     }
diff --git a/crates/isobmff/Cargo.toml b/crates/isobmff/Cargo.toml
index 620051ad1..c9b848fa0 100644
--- a/crates/isobmff/Cargo.toml
+++ b/crates/isobmff/Cargo.toml
@@ -14,5 +14,6 @@ filmcraft-bitstream = { workspace = true }
 thiserror = { workspace = true }
 
 [dev-dependencies]
+filmcraft-testkit = { workspace = true }
 proptest = { workspace = true }
 serde_json = { workspace = true }
diff --git a/crates/isobmff/src/mux.rs b/crates/isobmff/src/mux.rs
index 83a4dc100..900353685 100644
--- a/crates/isobmff/src/mux.rs
+++ b/crates/isobmff/src/mux.rs
@@ -423,7 +423,9 @@ fn write_trak(b: &mut BoxBuf, t: &WTrack, movie_ts: u32, qt: bool, shift: u64, f
         }
         None => {
             let first = tb.sizes.first().copied().unwrap_or(0);
-            if !tb.sizes.is_empty() && tb.sizes.iter().all(|&s| s == first) {
+            // A uniform size of 0 would mean "table follows" (ISO/IEC 14496-12 §8.7.3), so
+            // all-empty samples must still be written as a table.
+            if first != 0 && !tb.sizes.is_empty() && tb.sizes.iter().all(|&s| s == first) {
                 b.u32(first);
                 b.u32(tb.sizes.len() as u32);
             } else {
diff --git a/crates/isobmff/tests/common/mod.rs b/crates/isobmff/tests/common/mod.rs
index 209f148e0..895c217d4 100644
--- a/crates/isobmff/tests/common/mod.rs
+++ b/crates/isobmff/tests/common/mod.rs
@@ -6,37 +6,27 @@ use serde_json::Value;
 use std::path::{Path, PathBuf};
 use std::process::Command;
 
+/// Find a tool silently (see `filmcraft_testkit::oracle`).
 pub fn tool(name: &str) -> Option<PathBuf> {
-    for dir in ["/opt/homebrew/bin", "/usr/local/bin", "/usr/bin"] {
-        let p = Path::new(dir).join(name);
-        if p.exists() {
-            return Some(p);
-        }
+    match name {
+        "ffmpeg" => filmcraft_testkit::ffmpeg(),
+        "ffprobe" => filmcraft_testkit::ffprobe(),
+        _ => filmcraft_testkit::oracle::find_tool(name),
     }
-    let ok = Command::new(name).arg("-version").output().map(|o| o.status.success()).unwrap_or(false);
-    ok.then(|| PathBuf::from(name))
 }
 
+/// ffmpeg, or `None` after printing `SKIPPED` (a failure with `FILMCRAFT_REQUIRE_ORACLES=1`).
 pub fn ffmpeg() -> Option<PathBuf> {
-    let f = tool("ffmpeg");
-    if f.is_none() {
-        eprintln!("ffmpeg not found; skipping oracle test");
-    }
-    f
+    filmcraft_testkit::ffmpeg_or_skip("isobmff oracle")
 }
 
+/// ffprobe, or `None` after printing `SKIPPED` (a failure with `FILMCRAFT_REQUIRE_ORACLES=1`).
 pub fn ffprobe() -> Option<PathBuf> {
-    let f = tool("ffprobe");
-    if f.is_none() {
-        eprintln!("ffprobe not found; skipping oracle test");
-    }
-    f
+    filmcraft_testkit::ffprobe_or_skip("isobmff oracle")
 }
 
 pub fn fixture_dir() -> PathBuf {
-    let d = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../target/fixtures/isobmff");
-    std::fs::create_dir_all(&d).unwrap();
-    d
+    filmcraft_testkit::fixtures_dir("isobmff")
 }
 
 pub fn out_dir() -> PathBuf {
@@ -120,10 +110,7 @@ pub fn fixture_specs() -> Vec<(&'static str, Vec<&'static str>)> {
 }
 
 fn run_ffmpeg(ff: &Path, args: &[&str], out: &Path) -> bool {
-    static COUNTER: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
-    let n = COUNTER.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
-    let ext = out.extension().unwrap().to_str().unwrap();
-    let tmp = out.with_extension(format!("tmp{}_{n}.{ext}", std::process::id()));
+    let tmp = filmcraft_testkit::temp_path(out);
     let st = Command::new(ff).args(["-v", "error", "-y", "-nostdin"]).args(args).arg(&tmp).output();
     match st {
         Ok(o) if o.status.success() => std::fs::rename(&tmp, out).is_ok(),
@@ -139,7 +126,7 @@ fn run_ffmpeg(ff: &Path, args: &[&str], out: &Path) -> bool {
 /// Path to a fixture, generating it with ffmpeg if needed. `None` if ffmpeg is missing or the
 /// encoder isn't available.
 pub fn fixture(name: &str) -> Option<PathBuf> {
-    let ff = tool("ffmpeg")?;
+    let ff = ffmpeg()?;
     let path = fixture_dir().join(name);
     if path.exists() {
         return Some(path);
diff --git a/crates/isobmff/tests/oracle_demux.rs b/crates/isobmff/tests/oracle_demux.rs
index ee621ee7d..45ffe3b58 100644
--- a/crates/isobmff/tests/oracle_demux.rs
+++ b/crates/isobmff/tests/oracle_demux.rs
@@ -271,3 +271,13 @@ fn specific_properties() {
     let v = &f.tracks[f.track_of_kind(TrackKind::Video).unwrap()];
     assert!(v.references.iter().any(|(k, ids)| k.to_string() == "tmcd" && ids == &vec![t.id]));
 }
+
+/// Pre-generate every fixture (`cargo xtask fixtures`).
+#[test]
+#[ignore]
+fn generate_fixtures() {
+    for name in all_fixture_names() {
+        let out = [fixture_dir().join(name)];
+        filmcraft_testkit::fixtures::generate_and_report(&format!("isobmff/{name}"), &out, || fixture(name));
+    }
+}
diff --git a/crates/isobmff/tests/roundtrip.proptest-regressions b/crates/isobmff/tests/roundtrip.proptest-regressions
new file mode 100644
index 000000000..645fba077
--- /dev/null
+++ b/crates/isobmff/tests/roundtrip.proptest-regressions
@@ -0,0 +1,7 @@
+# Seeds for failure cases proptest has generated in the past. It is
+# automatically read and these particular cases re-run before any
+# novel cases are generated.
+#
+# It is recommended to check this file in to source control so that
+# everyone who runs the test benefits from these saved cases.
+cc 2f1e39c31dcb71e2f413c6f8046cb8976a8d51bab762a3d6cecce91feeda3a96 # shrinks to tracks = [(0, [S { size: 0, duration: 1, cto: 0, sync: false }])], order = [], mov = false, fast = false, with_pcm = false, start = None
diff --git a/crates/isobmff/tests/roundtrip.rs b/crates/isobmff/tests/roundtrip.rs
index 584b767ad..277aa66e2 100644
--- a/crates/isobmff/tests/roundtrip.rs
+++ b/crates/isobmff/tests/roundtrip.rs
@@ -204,3 +204,20 @@ fn large_offsets_use_co64_and_largesize_mdat() {
     z.extend_from_slice(&[0, 0, 0, 0, b'f', b'r', b'e', b'e', 1, 2, 3]);
     assert!(open(z.as_slice()).is_ok());
 }
+
+/// Found by `progressive_roundtrip`: only zero-byte samples must not be written as uniform
+/// `stsz` size 0, which readers take to mean "a size table follows".
+#[test]
+fn all_empty_samples_roundtrip() {
+    for n in [1usize, 3] {
+        let mut w = Mp4Writer::new(Cursor::new(Vec::new()), WriterOptions::new(Brand::Mp4)).unwrap();
+        w.add_track(TrackConfig::new(entry(0), 1000)).unwrap();
+        for _ in 0..n {
+            w.write_sample(0, WriteSample { data: &[], duration: 1, composition_offset: 0, is_sync: false }).unwrap();
+        }
+        let out = w.finish().unwrap().into_inner();
+        let f = open(out.as_slice()).unwrap();
+        assert_eq!(f.tracks[0].samples.len(), n);
+        assert!(f.tracks[0].samples.iter().all(|s| s.size == 0));
+    }
+}
diff --git a/crates/matroska/Cargo.toml b/crates/matroska/Cargo.toml
index 9b74dad0b..9f64162fb 100644
--- a/crates/matroska/Cargo.toml
+++ b/crates/matroska/Cargo.toml
@@ -12,4 +12,5 @@ workspace = true
 [dependencies]
 
 [dev-dependencies]
+filmcraft-testkit = { workspace = true }
 serde_json = { workspace = true }
diff --git a/crates/matroska/tests/common/mod.rs b/crates/matroska/tests/common/mod.rs
index 2e0fd8722..ad82697dd 100644
--- a/crates/matroska/tests/common/mod.rs
+++ b/crates/matroska/tests/common/mod.rs
@@ -6,32 +6,13 @@ use serde_json::Value;
 use std::path::{Path, PathBuf};
 use std::process::{Command, Stdio};
 
-pub fn tool(name: &str) -> Option<PathBuf> {
-    for dir in ["/opt/homebrew/bin", "/usr/local/bin", "/usr/bin"] {
-        let p = Path::new(dir).join(name);
-        if p.exists() {
-            return Some(p);
-        }
-    }
-    let ok = Command::new(name).arg("-version").output().map(|o| o.status.success()).unwrap_or(false);
-    ok.then(|| PathBuf::from(name))
-}
-
-/// (ffmpeg, ffprobe), or `None` (test skipped) if either is missing.
+/// (ffmpeg, ffprobe), or `None` after printing `SKIPPED` (see `filmcraft_testkit::oracle`).
 pub fn tools() -> Option<(PathBuf, PathBuf)> {
-    match (tool("ffmpeg"), tool("ffprobe")) {
-        (Some(a), Some(b)) => Some((a, b)),
-        _ => {
-            eprintln!("ffmpeg/ffprobe not found; skipping oracle test");
-            None
-        }
-    }
+    Some((filmcraft_testkit::ffmpeg_or_skip("matroska oracle")?, filmcraft_testkit::ffprobe_or_skip("matroska oracle")?))
 }
 
 pub fn fixture_dir() -> PathBuf {
-    let d = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../target/fixtures/matroska");
-    std::fs::create_dir_all(&d).unwrap();
-    d
+    filmcraft_testkit::fixtures_dir("matroska")
 }
 
 const V: &[&str] = &["-f", "lavfi", "-i", "testsrc2=size=160x120:rate=25"];
@@ -44,6 +25,22 @@ fn write_subs(dir: &Path) {
     std::fs::write(dir.join("in.vtt"), vtt).unwrap();
 }
 
+/// Every fixture `spec`/`fixture` knows (for `cargo xtask fixtures`).
+pub const ALL_FIXTURES: &[&str] = &[
+    "h264_aac.mkv",
+    "vp9_opus.webm",
+    "flac.mkv",
+    "vorbis.mkv",
+    "subs.mkv",
+    "webvtt.webm",
+    "cues_front.mkv",
+    "hevc_hdr.mkv",
+    "prores_pcm.mkv",
+    "mjpeg_ac3.mkv",
+    "av1.mkv",
+    "live.mkv",
+];
+
 /// Fixture name → ffmpeg arguments (after `-y -v error`, before the output path).
 /// `None` for fixtures written through a pipe (no Cues, unknown sizes).
 pub fn spec(name: &str) -> Option<Vec<String>> {
@@ -93,8 +90,7 @@ pub fn fixture(ffmpeg: &Path, name: &str) -> Option<PathBuf> {
         return Some(out);
     }
     write_subs(&dir);
-    let tid = format!("{:?}", std::thread::current().id()).replace(|c: char| !c.is_ascii_alphanumeric(), "");
-    let tmp = dir.join(format!("{name}.{}.{tid}.tmp", std::process::id()));
+    let tmp = filmcraft_testkit::temp_path(&out);
     let ok = match spec(name) {
         Some(args) => {
             let mut c = Command::new(ffmpeg);
diff --git a/crates/matroska/tests/oracle.rs b/crates/matroska/tests/oracle.rs
index bc278ac87..5eaae0a03 100644
--- a/crates/matroska/tests/oracle.rs
+++ b/crates/matroska/tests/oracle.rs
@@ -360,3 +360,14 @@ fn not_matroska() {
     assert!(matches!(open(&ebml[..]), Err(Error::NotMatroska(_))));
     let _ = Value::Null;
 }
+
+/// Pre-generate every fixture (`cargo xtask fixtures`).
+#[test]
+#[ignore]
+fn generate_fixtures() {
+    let Some((ffmpeg, _)) = tools() else { return };
+    for name in ALL_FIXTURES {
+        let out = [fixture_dir().join(name)];
+        filmcraft_testkit::fixtures::generate_and_report(&format!("matroska/{name}"), &out, || fixture(&ffmpeg, name));
+    }
+}
diff --git a/crates/opus/Cargo.toml b/crates/opus/Cargo.toml
index 463a94081..1ae2c8258 100644
--- a/crates/opus/Cargo.toml
+++ b/crates/opus/Cargo.toml
@@ -10,3 +10,6 @@ rust-version.workspace = true
 workspace = true
 
 [dependencies]
+
+[dev-dependencies]
+filmcraft-testkit = { workspace = true }
diff --git a/crates/opus/tests/common/mod.rs b/crates/opus/tests/common/mod.rs
index 712edd620..6c6ec2754 100644
--- a/crates/opus/tests/common/mod.rs
+++ b/crates/opus/tests/common/mod.rs
@@ -1,6 +1,6 @@
 #![allow(dead_code)]
 
-use std::path::{Path, PathBuf};
+use std::path::PathBuf;
 
 /// Plain SNR (dB) of `test` against `reference` over the common length.
 pub fn snr_db(reference: &[f32], test: &[f32]) -> f64 {
@@ -138,19 +138,13 @@ pub fn opus_quality(reference: &[f32], test: &[f32], channels: usize, rate: u32)
     100.0 * (1.0 - 0.5 * (1.0 + err).ln() / 1.13f64.ln())
 }
 
+/// ffmpeg (see `filmcraft_testkit::oracle`); `None` after printing `SKIPPED`.
 pub fn ffmpeg() -> Option<PathBuf> {
-    for p in ["/opt/homebrew/bin/ffmpeg", "/usr/local/bin/ffmpeg", "/usr/bin/ffmpeg"] {
-        if Path::new(p).exists() {
-            return Some(PathBuf::from(p));
-        }
-    }
-    None
+    filmcraft_testkit::ffmpeg_or_skip("opus oracle")
 }
 
 pub fn fixtures() -> PathBuf {
-    let d = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../target/fixtures/opus/oracle");
-    std::fs::create_dir_all(&d).unwrap();
-    d
+    filmcraft_testkit::fixtures_dir("opus/oracle")
 }
 
 /// Minimal Ogg demuxer: returns (packets, last granule position).
diff --git a/crates/project/src/effect.rs b/crates/project/src/effect.rs
index 80f69e005..9d0378bd6 100644
--- a/crates/project/src/effect.rs
+++ b/crates/project/src/effect.rs
@@ -85,6 +85,7 @@ impl EffectDef {
             enabled: true,
             params: self.params.iter().map(|p| (p.id.to_string(), Param::new(p.default.clone()))).collect(),
             masks: Vec::new(),
+            post_fader: false,
         }
     }
 }
@@ -113,6 +114,9 @@ pub struct EffectInstance {
     pub params: BTreeMap<String, Param>,
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub masks: Vec<Mask>,
+    /// Track/Mix inserts only: process after the fader instead of before it.
+    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
+    pub post_fader: bool,
 }
 
 impl EffectInstance {
@@ -935,6 +939,7 @@ fn build_effects() -> Vec<EffectDef> {
             yuv: false,
         },
     ];
+    v.extend(crate::graphic::layer_defs());
     // YUV badge for the colour/intrinsic set
     for e in &mut v {
         if matches!(e.id, "brightness_contrast" | "proc_amp" | "crop" | "gaussian_blur" | "tint" | "lumetri") {
diff --git a/crates/project/src/graphic.rs b/crates/project/src/graphic.rs
new file mode 100644
index 000000000..14c2a776f
--- /dev/null
+++ b/crates/project/src/graphic.rs
@@ -0,0 +1,419 @@
+//! Graphic clips: text and shape layers.
+//!
+//! A graphic clip is a track item whose project item is an [`ItemKind::Graphic`](crate::ItemKind)
+//! source (a transparent canvas the size of the sequence frame). Its **layers** are effect
+//! instances of the hidden effects [`TEXT_LAYER`] and [`SHAPE_LAYER`] in the clip's effect list,
+//! in paint order (first = back). Being effect instances, layers serialize with the project, get
+//! keyframes for every animatable property (Source Text holds), show in Effect Controls, and copy
+//! with the clip — like Premiere's Text / Shape components. Standard effects on the clip apply to
+//! the composed graphic; Motion and Opacity apply last.
+//!
+//! [`eval_layer`] evaluates a layer at a clip time into a plain [`LayerSpec`] that renderers and
+//! editors use.
+
+use filmcraft_geom::Vec2;
+use filmcraft_time::Tick;
+
+use crate::effect::{EffectDef, EffectInstance, EffectKind, ParamDef, ParamKind};
+use crate::keyframe::{Param, ParamValue};
+
+pub const TEXT_LAYER: &str = "graphic_text";
+pub const SHAPE_LAYER: &str = "graphic_shape";
+
+pub const ALIGN_OPTS: &[&str] = &["Left", "Center", "Right", "Justify"];
+pub const CAPS_OPTS: &[&str] = &["Normal", "All Caps", "Small Caps"];
+pub const STROKE_OPTS: &[&str] = &["Outer", "Center", "Inner"];
+pub const SHAPE_OPTS: &[&str] = &["Rectangle", "Ellipse", "Polygon", "Path"];
+
+/// Whether an effect instance is a graphic layer.
+pub fn is_layer_id(id: &str) -> bool {
+    id == TEXT_LAYER || id == SHAPE_LAYER
+}
+
+pub fn is_layer(e: &EffectInstance) -> bool {
+    is_layer_id(&e.effect)
+}
+
+fn p(id: &'static str, label: &'static str, kind: ParamKind, default: ParamValue, animatable: bool, group: &'static str) -> ParamDef {
+    ParamDef { id, label, kind, default, animatable, group: if group.is_empty() { None } else { Some(group) } }
+}
+fn fl(id: &'static str, label: &'static str, def: f64, (min, max): (f64, f64), (smin, smax): (f64, f64), unit: &'static str, group: &'static str) -> ParamDef {
+    p(id, label, ParamKind::Float { min, max, soft_min: smin, soft_max: smax, unit, decimals: 1 }, ParamValue::Float(def), true, group)
+}
+fn bo(id: &'static str, label: &'static str, v: bool, group: &'static str) -> ParamDef {
+    p(id, label, ParamKind::Bool, ParamValue::Bool(v), false, group)
+}
+fn co(id: &'static str, label: &'static str, c: [f32; 4], group: &'static str) -> ParamDef {
+    p(id, label, ParamKind::Color, ParamValue::Color(c), true, group)
+}
+fn chc(id: &'static str, label: &'static str, opts: &'static [&'static str], def: u32, group: &'static str) -> ParamDef {
+    p(id, label, ParamKind::Choice(opts), ParamValue::Choice(def), false, group)
+}
+fn tx(id: &'static str, label: &'static str, def: &str, animatable: bool, group: &'static str) -> ParamDef {
+    p(id, label, ParamKind::Text, ParamValue::Text(def.into()), animatable, group)
+}
+
+fn appearance() -> Vec<ParamDef> {
+    const A: &str = "Appearance";
+    vec![
+        bo("fill", "Fill", true, A),
+        co("fill_color", "Fill Color", [1.0, 1.0, 1.0, 1.0], A),
+        bo("stroke", "Stroke", false, A),
+        co("stroke_color", "Stroke Color", [0.0, 0.0, 0.0, 1.0], A),
+        fl("stroke_width", "Stroke Width", 4.0, (0.0, 1000.0), (0.0, 100.0), "", A),
+        chc("stroke_type", "Stroke Type", STROKE_OPTS, 0, A),
+        bo("stroke2", "Stroke 2", false, A),
+        co("stroke2_color", "Stroke 2 Color", [1.0, 0.85, 0.2, 1.0], A),
+        fl("stroke2_width", "Stroke 2 Width", 10.0, (0.0, 1000.0), (0.0, 100.0), "", A),
+        chc("stroke2_type", "Stroke 2 Type", STROKE_OPTS, 0, A),
+        bo("background", "Background", false, A),
+        co("background_color", "Background Color", [0.0, 0.0, 0.0, 1.0], A),
+        fl("background_opacity", "Background Opacity", 75.0, (0.0, 100.0), (0.0, 100.0), "%", A),
+        fl("background_size", "Background Size", 12.0, (0.0, 1000.0), (0.0, 100.0), "", A),
+        fl("background_radius", "Background Corner Radius", 0.0, (0.0, 1000.0), (0.0, 100.0), "", A),
+        bo("shadow", "Shadow", false, A),
+        co("shadow_color", "Shadow Color", [0.0, 0.0, 0.0, 1.0], A),
+        fl("shadow_opacity", "Shadow Opacity", 75.0, (0.0, 100.0), (0.0, 100.0), "%", A),
+        p("shadow_angle", "Shadow Angle", ParamKind::Angle, ParamValue::Float(135.0), true, A),
+        fl("shadow_distance", "Shadow Distance", 10.0, (0.0, 1000.0), (0.0, 100.0), "", A),
+        fl("shadow_size", "Shadow Size", 0.0, (0.0, 1000.0), (0.0, 100.0), "", A),
+        fl("shadow_blur", "Shadow Blur", 40.0, (0.0, 1000.0), (0.0, 200.0), "", A),
+    ]
+}
+
+fn transform() -> Vec<ParamDef> {
+    const T: &str = "Transform";
+    vec![
+        p("position", "Position", ParamKind::Point, ParamValue::Vec2(Vec2::new(f64::NAN, f64::NAN)), true, T),
+        p("anchor", "Anchor Point", ParamKind::Point, ParamValue::Vec2(Vec2::new(0.0, 0.0)), true, T),
+        fl("scale", "Scale", 100.0, (0.0, 100_000.0), (0.0, 400.0), "%", T),
+        fl("scale_width", "Scale Width", 100.0, (0.0, 100_000.0), (0.0, 400.0), "%", T),
+        bo("uniform_scale", "Uniform Scale", true, T),
+        p("rotation", "Rotation", ParamKind::Angle, ParamValue::Float(0.0), true, T),
+        fl("opacity", "Opacity", 100.0, (0.0, 100.0), (0.0, 100.0), "%", T),
+    ]
+}
+
+fn layer_def(id: &'static str, name: &'static str, mut params: Vec<ParamDef>) -> EffectDef {
+    params.extend(appearance());
+    params.extend(transform());
+    EffectDef { id, name, kind: EffectKind::Video, category: &[], params, intrinsic: false, accelerated: true, float32: true, yuv: false }
+}
+
+/// Definitions of the two layer kinds (appended to the effect registry; not in the Effects panel).
+pub(crate) fn layer_defs() -> Vec<EffectDef> {
+    const X: &str = "Text";
+    const S: &str = "Shape";
+    vec![
+        layer_def(
+            TEXT_LAYER,
+            "Text",
+            vec![
+                tx("name", "Layer Name", "", false, ""),
+                tx("text", "Source Text", "", true, ""),
+                tx("font", "Font", "Inter", false, X),
+                tx("font_style", "Font Style", "Regular", false, X),
+                fl("size", "Font Size", 100.0, (1.0, 2000.0), (6.0, 400.0), "", X),
+                chc("align", "Alignment", ALIGN_OPTS, 0, X),
+                fl("tracking", "Tracking", 0.0, (-1000.0, 10_000.0), (-200.0, 1000.0), "", X),
+                bo("kerning", "Metrics Kerning", true, X),
+                bo("ligatures", "Ligatures", true, X),
+                fl("leading", "Leading", 0.0, (-5000.0, 5000.0), (-100.0, 400.0), "", X),
+                fl("baseline_shift", "Baseline Shift", 0.0, (-5000.0, 5000.0), (-100.0, 100.0), "", X),
+                bo("faux_bold", "Faux Bold", false, X),
+                bo("faux_italic", "Faux Italic", false, X),
+                chc("caps", "Capitalisation", CAPS_OPTS, 0, X),
+                bo("underline", "Underline", false, X),
+                fl("box_width", "Text Box Width", 0.0, (0.0, 100_000.0), (0.0, 3840.0), "", X),
+            ],
+        ),
+        layer_def(
+            SHAPE_LAYER,
+            "Shape",
+            vec![
+                tx("name", "Layer Name", "", false, ""),
+                chc("shape", "Shape", SHAPE_OPTS, 0, S),
+                p("size", "Size", ParamKind::Point, ParamValue::Vec2(Vec2::new(400.0, 200.0)), true, S),
+                fl("sides", "Polygon Sides", 6.0, (3.0, 64.0), (3.0, 16.0), "", S),
+                fl("corner_radius", "Corner Radius", 0.0, (0.0, 10_000.0), (0.0, 200.0), "", S),
+                p("points", "Path Points", ParamKind::Curve { hue: false }, ParamValue::Curve(vec![]), false, S),
+            ],
+        ),
+    ]
+}
+
+/// Fill / strokes / background / shadow of a layer (colours are sRGB-encoded straight RGBA).
+#[derive(Clone, Debug, PartialEq)]
+pub struct Appearance {
+    pub fill: Option<[f32; 4]>,
+    /// (colour, width px, type: 0 outer, 1 centre, 2 inner), outermost last.
+    pub strokes: Vec<([f32; 4], f32, u32)>,
+    /// (colour with opacity in alpha, padding px, corner radius px).
+    pub background: Option<([f32; 4], f32, f32)>,
+    pub shadow: Option<Shadow>,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Shadow {
+    /// Colour with opacity in alpha.
+    pub color: [f32; 4],
+    /// Offset in layer pixels (from angle and distance; 135° casts down-right).
+    pub offset: (f32, f32),
+    pub size: f32,
+    pub blur: f32,
+}
+
+/// Layer → graphic-source transform parameters.
+#[derive(Clone, Debug, PartialEq)]
+pub struct LayerTransform {
+    pub position: Vec2,
+    pub anchor: Vec2,
+    pub scale: Vec2,
+    pub rotation: f64,
+    pub opacity: f32,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct TextProps {
+    pub text: String,
+    pub font: String,
+    pub style: String,
+    pub size: f32,
+    /// 0 left, 1 centre, 2 right, 3 justify.
+    pub align: u32,
+    pub tracking: f32,
+    pub kerning: bool,
+    pub ligatures: bool,
+    pub leading: f32,
+    pub baseline_shift: f32,
+    pub faux_bold: bool,
+    pub faux_italic: bool,
+    /// 0 normal, 1 all caps, 2 small caps.
+    pub caps: u32,
+    pub underline: bool,
+    /// Area-text width (0 = point text).
+    pub box_width: f32,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct ShapeProps {
+    /// 0 rectangle, 1 ellipse, 2 polygon, 3 path.
+    pub shape: u32,
+    pub size: (f32, f32),
+    pub sides: u32,
+    pub corner_radius: f32,
+    /// Path vertices in layer pixels (shape 3), closed.
+    pub points: Vec<[f32; 2]>,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum LayerContent {
+    Text(TextProps),
+    Shape(ShapeProps),
+}
+
+/// A layer evaluated at one time.
+#[derive(Clone, Debug, PartialEq)]
+pub struct LayerSpec {
+    pub name: String,
+    pub enabled: bool,
+    pub content: LayerContent,
+    pub appearance: Appearance,
+    pub transform: LayerTransform,
+}
+
+fn val(e: &EffectInstance, id: &str, t: Tick) -> ParamValue {
+    match e.params.get(id) {
+        Some(p) => p.value_at(t),
+        None => crate::effect::find_effect(&e.effect).and_then(|d| d.param(id)).map(|d| d.default.clone()).unwrap_or(ParamValue::Float(0.0)),
+    }
+}
+fn ff(e: &EffectInstance, id: &str, t: Tick) -> f32 {
+    val(e, id, t).as_f64().unwrap_or(0.0) as f32
+}
+fn bb(e: &EffectInstance, id: &str, t: Tick) -> bool {
+    val(e, id, t).as_bool().unwrap_or(false)
+}
+fn cc(e: &EffectInstance, id: &str, t: Tick) -> [f32; 4] {
+    val(e, id, t).as_color().unwrap_or([1.0, 1.0, 1.0, 1.0])
+}
+fn ch(e: &EffectInstance, id: &str, t: Tick) -> u32 {
+    match val(e, id, t) {
+        ParamValue::Choice(c) => c,
+        v => v.as_f64().unwrap_or(0.0) as u32,
+    }
+}
+fn ss(e: &EffectInstance, id: &str, t: Tick) -> String {
+    match val(e, id, t) {
+        ParamValue::Text(s) => s,
+        _ => String::new(),
+    }
+}
+fn vv(e: &EffectInstance, id: &str, t: Tick) -> Vec2 {
+    val(e, id, t).as_vec2().unwrap_or_default()
+}
+
+/// Evaluate a layer at clip (media) time `t`. `frame` is the graphic's canvas size; a NaN position
+/// means the canvas centre.
+pub fn eval_layer(e: &EffectInstance, t: Tick, frame: (u32, u32)) -> Option<LayerSpec> {
+    let content = match e.effect.as_str() {
+        TEXT_LAYER => LayerContent::Text(TextProps {
+            text: ss(e, "text", t),
+            font: ss(e, "font", t),
+            style: ss(e, "font_style", t),
+            size: ff(e, "size", t).max(0.1),
+            align: ch(e, "align", t),
+            tracking: ff(e, "tracking", t),
+            kerning: bb(e, "kerning", t),
+            ligatures: bb(e, "ligatures", t),
+            leading: ff(e, "leading", t),
+            baseline_shift: ff(e, "baseline_shift", t),
+            faux_bold: bb(e, "faux_bold", t),
+            faux_italic: bb(e, "faux_italic", t),
+            caps: ch(e, "caps", t),
+            underline: bb(e, "underline", t),
+            box_width: ff(e, "box_width", t).max(0.0),
+        }),
+        SHAPE_LAYER => {
+            let sz = vv(e, "size", t);
+            LayerContent::Shape(ShapeProps {
+                shape: ch(e, "shape", t),
+                size: (sz.x.max(0.0) as f32, sz.y.max(0.0) as f32),
+                sides: ff(e, "sides", t).round().clamp(3.0, 64.0) as u32,
+                corner_radius: ff(e, "corner_radius", t).max(0.0),
+                points: val(e, "points", t).as_curve().map(<[_]>::to_vec).unwrap_or_default(),
+            })
+        }
+        _ => return None,
+    };
+    let mut strokes = Vec::new();
+    for (on, c, w, k) in [("stroke", "stroke_color", "stroke_width", "stroke_type"), ("stroke2", "stroke2_color", "stroke2_width", "stroke2_type")] {
+        if bb(e, on, t) && ff(e, w, t) > 0.0 {
+            strokes.push((cc(e, c, t), ff(e, w, t), ch(e, k, t)));
+        }
+    }
+    let background = bb(e, "background", t).then(|| {
+        let mut c = cc(e, "background_color", t);
+        c[3] *= (ff(e, "background_opacity", t) / 100.0).clamp(0.0, 1.0);
+        (c, ff(e, "background_size", t).max(0.0), ff(e, "background_radius", t).max(0.0))
+    });
+    let shadow = bb(e, "shadow", t).then(|| {
+        let mut c = cc(e, "shadow_color", t);
+        c[3] *= (ff(e, "shadow_opacity", t) / 100.0).clamp(0.0, 1.0);
+        // Premiere: 135° casts the shadow down and to the right.
+        let a = (ff(e, "shadow_angle", t) - 90.0).to_radians();
+        let d = ff(e, "shadow_distance", t);
+        Shadow { color: c, offset: (a.cos() * d, a.sin() * d), size: ff(e, "shadow_size", t).max(0.0), blur: ff(e, "shadow_blur", t).max(0.0) }
+    });
+    let pos = vv(e, "position", t);
+    let position = if pos.x.is_nan() || pos.y.is_nan() { Vec2::new(frame.0 as f64 / 2.0, frame.1 as f64 / 2.0) } else { pos };
+    let s = ff(e, "scale", t) as f64 / 100.0;
+    let sw = if bb(e, "uniform_scale", t) { s } else { ff(e, "scale_width", t) as f64 / 100.0 };
+    Some(LayerSpec {
+        name: ss(e, "name", t),
+        enabled: e.enabled,
+        content,
+        appearance: Appearance { fill: bb(e, "fill", t).then(|| cc(e, "fill_color", t)), strokes, background, shadow },
+        transform: LayerTransform {
+            position,
+            anchor: vv(e, "anchor", t),
+            scale: Vec2::new(sw, s),
+            rotation: ff(e, "rotation", t) as f64,
+            opacity: (ff(e, "opacity", t) / 100.0).clamp(0.0, 1.0),
+        },
+    })
+}
+
+fn set(e: &mut EffectInstance, id: &str, v: ParamValue) {
+    e.params.insert(id.to_string(), Param::new(v));
+}
+
+/// A new text layer at `position` (graphic canvas pixels).
+pub fn new_text_layer(text: &str, position: Vec2, size: f64) -> EffectInstance {
+    let mut e = crate::effect::find_effect(TEXT_LAYER).expect("registered").instance();
+    set(&mut e, "text", ParamValue::Text(text.into()));
+    set(&mut e, "position", ParamValue::Vec2(position));
+    set(&mut e, "size", ParamValue::Float(size));
+    e
+}
+
+/// A new shape layer centred at `position`.
+pub fn new_shape_layer(shape: u32, position: Vec2, size: Vec2, points: Vec<[f32; 2]>) -> EffectInstance {
+    let mut e = crate::effect::find_effect(SHAPE_LAYER).expect("registered").instance();
+    set(&mut e, "shape", ParamValue::Choice(shape.min(3)));
+    set(&mut e, "position", ParamValue::Vec2(position));
+    set(&mut e, "size", ParamValue::Vec2(size));
+    set(&mut e, "points", ParamValue::Curve(points));
+    // shapes default to a red fill (Premiere's new-shape default is a coloured fill)
+    set(&mut e, "fill_color", ParamValue::Color([0.85, 0.2, 0.25, 1.0]));
+    e
+}
+
+/// Display name of a layer: its name, else the text (first line), else "Shape 01"-style.
+pub fn layer_display_name(e: &EffectInstance, index: usize) -> String {
+    let name = ss(e, "name", Tick::ZERO);
+    if !name.is_empty() {
+        return name;
+    }
+    if e.effect == TEXT_LAYER {
+        let t = ss(e, "text", Tick::ZERO);
+        let first = t.lines().next().unwrap_or("").trim().to_string();
+        if first.is_empty() { "Text".into() } else { first.chars().take(40).collect() }
+    } else {
+        format!("Shape {:02}", index + 1)
+    }
+}
+
+/// Indices (into `effects`) of the graphic layers, in paint order.
+pub fn layer_indices(effects: &[EffectInstance]) -> Vec<usize> {
+    effects.iter().enumerate().filter(|(_, e)| is_layer(e)).map(|(i, _)| i).collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn layers_round_trip_and_evaluate() {
+        let mut e = new_text_layer("Hello", Vec2::new(100.0, 200.0), 72.0);
+        e.params.get_mut("fill_color").unwrap().value = ParamValue::Color([1.0, 0.0, 0.0, 1.0]);
+        let json = serde_json::to_string(&e).unwrap();
+        let back: EffectInstance = serde_json::from_str(&json).unwrap();
+        assert_eq!(back, e);
+        let s = eval_layer(&back, Tick::ZERO, (1920, 1080)).unwrap();
+        let LayerContent::Text(t) = &s.content else { panic!() };
+        assert_eq!(t.text, "Hello");
+        assert_eq!(t.size, 72.0);
+        assert_eq!(t.font, "Inter");
+        assert_eq!(s.appearance.fill, Some([1.0, 0.0, 0.0, 1.0]));
+        assert_eq!(s.transform.position, Vec2::new(100.0, 200.0));
+        assert!(s.appearance.strokes.is_empty() && s.appearance.shadow.is_none());
+        assert!(is_layer(&e));
+        assert_eq!(layer_display_name(&e, 0), "Hello");
+    }
+
+    #[test]
+    fn defaults_centre_and_shadow_direction() {
+        let mut e = crate::effect::find_effect(SHAPE_LAYER).unwrap().instance();
+        e.params.get_mut("shadow").unwrap().value = ParamValue::Bool(true);
+        let s = eval_layer(&e, Tick::ZERO, (1920, 1080)).unwrap();
+        assert_eq!(s.transform.position, Vec2::new(960.0, 540.0));
+        let sh = s.appearance.shadow.unwrap();
+        assert!(sh.offset.0 > 5.0 && sh.offset.1 > 5.0, "135° casts down-right: {:?}", sh.offset);
+        assert_eq!(layer_display_name(&e, 2), "Shape 03");
+    }
+
+    #[test]
+    fn source_text_keyframes_hold() {
+        let mut e = new_text_layer("A", Vec2::new(0.0, 0.0), 50.0);
+        let p = e.params.get_mut("text").unwrap();
+        p.toggle_animation(Tick(0));
+        p.set_at(Tick(100), ParamValue::Text("B".into()));
+        let at = |t| match eval_layer(&e, Tick(t), (10, 10)).unwrap().content {
+            LayerContent::Text(x) => x.text,
+            _ => unreachable!(),
+        };
+        assert_eq!(at(50), "A");
+        assert_eq!(at(150), "B");
+    }
+}
diff --git a/crates/project/src/keyframe.rs b/crates/project/src/keyframe.rs
index 3e1029f00..693e79262 100644
--- a/crates/project/src/keyframe.rs
+++ b/crates/project/src/keyframe.rs
@@ -186,6 +186,11 @@ impl Param {
         self.set_at_force(t, v);
     }
 
+    /// Add or replace a keyframe at `t` (the parameter becomes animated).
+    pub fn put_keyframe(&mut self, t: Tick, value: ParamValue) {
+        self.set_at_force(t, value);
+    }
+
     fn set_at_force(&mut self, t: Tick, value: ParamValue) {
         match self.keyframes.binary_search_by_key(&t, |k| k.time) {
             Ok(i) => self.keyframes[i].value = value,
@@ -238,6 +243,35 @@ impl Param {
     pub fn f64_at(&self, t: Tick) -> f64 {
         self.value_at(t).as_f64().unwrap_or(0.0)
     }
+
+    /// Allocation-free [`Param::f64_at`] for scalar parameters (Float / Choice / Bool), for
+    /// per-sample evaluation in the audio mixer. Non-scalar values evaluate to 0.
+    pub fn scalar_at(&self, t: Tick) -> f64 {
+        let k = &self.keyframes;
+        let s = |v: &ParamValue| v.as_f64().unwrap_or(0.0);
+        if k.is_empty() {
+            return s(&self.value);
+        }
+        if t <= k[0].time {
+            return s(&k[0].value);
+        }
+        let last = &k[k.len() - 1];
+        if t >= last.time {
+            return s(&last.value);
+        }
+        let i = match k.binary_search_by_key(&t, |kf| kf.time) {
+            Ok(i) => return s(&k[i].value),
+            Err(i) => i - 1,
+        };
+        let (a, b) = (&k[i], &k[i + 1]);
+        let (va, vb) = (s(&a.value), s(&b.value));
+        if a.interp == Interpolation::Hold || !matches!(a.value, ParamValue::Float(_)) {
+            return va;
+        }
+        let u = (t - a.time).0 as f64 / (b.time - a.time).0 as f64;
+        va + (vb - va) * ease(a, b, u)
+    }
+
     pub fn vec2_at(&self, t: Tick) -> Vec2 {
         self.value_at(t).as_vec2().unwrap_or_default()
     }
diff --git a/crates/project/src/lib.rs b/crates/project/src/lib.rs
index 20d7ac5e8..b502794fd 100644
--- a/crates/project/src/lib.rs
+++ b/crates/project/src/lib.rs
@@ -9,7 +9,9 @@
 
 pub mod caption;
 pub mod effect;
+pub mod graphic;
 pub mod keyframe;
+pub mod mixer;
 
 use std::collections::BTreeMap;
 
@@ -21,6 +23,7 @@ use serde::{Deserialize, Serialize};
 pub use caption::{Caption, CaptionAlign, CaptionAnchor, CaptionFormat, CaptionStyle, CaptionTrack, plain_text};
 pub use effect::{EffectDef, EffectInstance, EffectKind, ParamDef, ParamKind, effect_defs, find_effect};
 pub use keyframe::{Interpolation, Keyframe, Param, ParamValue};
+pub use mixer::{AutomationMode, InputMap, MixerStrip, TrackSend};
 
 macro_rules! id_type {
     ($name:ident) => {
@@ -191,6 +194,14 @@ pub enum ItemKind {
         rate: FrameRate,
         duration: Tick,
     },
+    /// The source of graphic clips: a transparent canvas of the sequence frame size. The clip's
+    /// text and shape layers are effect instances on the track item (see [`graphic`]). Not shown
+    /// in the Project panel; unlimited duration.
+    Graphic {
+        width: u32,
+        height: u32,
+        rate: FrameRate,
+    },
 }
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
@@ -235,7 +246,7 @@ impl ProjectItem {
     pub fn has_video(&self) -> bool {
         match &self.kind {
             ItemKind::Media(m) => m.info.has_video(),
-            ItemKind::Sequence(_) | ItemKind::AdjustmentLayer { .. } => true,
+            ItemKind::Sequence(_) | ItemKind::AdjustmentLayer { .. } | ItemKind::Graphic { .. } => true,
             ItemKind::Subclip { .. } => true,
         }
     }
@@ -252,13 +263,14 @@ impl ProjectItem {
             ItemKind::Sequence(s) => s.duration(),
             ItemKind::Subclip { range, .. } => range.duration,
             ItemKind::AdjustmentLayer { duration, .. } => *duration,
+            ItemKind::Graphic { .. } => Tick(3600 * TICKS_PER_SECOND),
         }
     }
     pub fn frame_rate(&self) -> FrameRate {
         match &self.kind {
             ItemKind::Media(m) => m.frame_rate(),
             ItemKind::Sequence(s) => s.settings.frame_rate,
-            ItemKind::AdjustmentLayer { rate, .. } => *rate,
+            ItemKind::AdjustmentLayer { rate, .. } | ItemKind::Graphic { rate, .. } => *rate,
             ItemKind::Subclip { .. } => FrameRate::default(),
         }
     }
@@ -275,6 +287,7 @@ impl ProjectItem {
             ItemKind::Sequence(_) => "Sequence",
             ItemKind::Subclip { .. } => "Subclip",
             ItemKind::AdjustmentLayer { .. } => "Adjustment Layer",
+            ItemKind::Graphic { .. } => "Graphic",
         }
     }
 }
@@ -452,7 +465,11 @@ impl TrackItem {
     }
     /// Standard (non-intrinsic) effects applied, for the fx badge.
     pub fn has_standard_effects(&self) -> bool {
-        self.effects.iter().any(|e| e.def().is_some_and(|d| !d.intrinsic))
+        self.effects.iter().any(|e| e.def().is_some_and(|d| !d.intrinsic) && !graphic::is_layer(e))
+    }
+    /// The graphic layers (text / shape) of a graphic clip, in paint order (first = back).
+    pub fn graphic_layers(&self) -> impl Iterator<Item = &EffectInstance> {
+        self.effects.iter().filter(|e| graphic::is_layer(e))
     }
     pub fn has_modified_intrinsics(&self) -> bool {
         self.effects.iter().any(|e| {
@@ -528,9 +545,12 @@ pub struct Track {
     /// Audio track volume (dB) and pan (-100..100) for the Track Mixer.
     pub volume_db: f64,
     pub pan: f64,
-    /// Track-level audio effects (mixer inserts).
+    /// Track-level audio effects (mixer inserts, slots 1–5; `EffectInstance::post_fader` picks the side).
     #[serde(default)]
     pub effects: Vec<EffectInstance>,
+    /// Audio Track Mixer state: automation mode and lanes, sends, output, record arm.
+    #[serde(default)]
+    pub mixer: MixerStrip,
 }
 
 impl Track {
@@ -550,6 +570,7 @@ impl Track {
             volume_db: 0.0,
             pan: 0.0,
             effects: Vec::new(),
+            mixer: MixerStrip::default(),
         }
     }
     pub fn end(&self) -> Tick {
@@ -640,8 +661,16 @@ pub struct Sequence {
     /// Master audio volume (dB).
     #[serde(default)]
     pub master_volume_db: f64,
+    /// Mix track inserts (`EffectInstance::post_fader` picks the side).
     #[serde(default)]
     pub master_effects: Vec<EffectInstance>,
+    /// Mix track automation (`volume` lane) and mode.
+    #[serde(default)]
+    pub master_mixer: MixerStrip,
+    /// Audio submix tracks (no clips); tracks and sends route into them, they route to the Mix
+    /// or to a submix after them.
+    #[serde(default)]
+    pub submix_tracks: Vec<Track>,
     /// Caption tracks (drawn above the video tracks; first = top). Older files have none (serde default).
     #[serde(default)]
     pub caption_tracks: Vec<CaptionTrack>,
@@ -826,6 +855,8 @@ impl Project {
             start_timecode: 0,
             master_volume_db: 0.0,
             master_effects: Vec::new(),
+            master_mixer: MixerStrip::default(),
+            submix_tracks: Vec::new(),
             caption_tracks: Vec::new(),
         };
         for i in 0..v {
diff --git a/crates/project/src/mixer.rs b/crates/project/src/mixer.rs
new file mode 100644
index 000000000..14388a4b0
--- /dev/null
+++ b/crates/project/src/mixer.rs
@@ -0,0 +1,548 @@
+//! Audio Track Mixer model: automation modes and lanes, sends, submix routing, channel mapping.
+//!
+//! Every audio track, every submix track ([`crate::Sequence::submix_tracks`]) and the Mix (master)
+//! track has a [`MixerStrip`]. Static values stay where they always were (`Track::volume_db`,
+//! `Track::pan`, `Track::muted`, `TrackSend::level_db`, effect parameter values); automation is
+//! keyframes in **sequence time** on top of them:
+//!
+//! | lane key | value | stored in |
+//! |---|---|---|
+//! | `volume` | fader level, dB | `MixerStrip::lanes` |
+//! | `pan` | pan / balance, −100 … 100 | `MixerStrip::lanes` |
+//! | `mute` | 0 / 1 (hold) | `MixerStrip::lanes` |
+//! | `send.<i>.level` | send `i` level, dB | `MixerStrip::lanes` |
+//! | `fx.<slot>.<param>` | insert effect parameter | the effect's own `Param` keyframes |
+//!
+//! [`AutomationMode`] decides whether playback reads the lanes (anything but Off) and how the
+//! mixer writes them while recording (Latch / Touch / Write; see the engine's recorder).
+
+use std::collections::BTreeMap;
+
+use filmcraft_time::Tick;
+use serde::{Deserialize, Serialize};
+
+use crate::keyframe::{Interpolation, Keyframe, Param, ParamValue};
+use crate::{Track, TrackId};
+
+pub const LANE_VOLUME: &str = "volume";
+pub const LANE_PAN: &str = "pan";
+pub const LANE_MUTE: &str = "mute";
+
+/// At most this many insert effects per strip (Premiere's effect slots 1–5).
+pub const MAX_INSERTS: usize = 5;
+/// At most this many sends per strip (Premiere's send slots 1–5).
+pub const MAX_SENDS: usize = 5;
+/// Fader range (dB): the Track Mixer's scale runs from −∞ to +15 dB (Clip Mixer and Mix too).
+pub const FADER_MAX_DB: f64 = 15.0;
+/// Values at or below this are −∞ (silence).
+pub const FADER_MIN_DB: f64 = -96.0;
+
+pub fn send_lane(i: usize) -> String {
+    format!("send.{i}.level")
+}
+
+pub fn fx_lane(slot: usize, param: &str) -> String {
+    format!("fx.{slot}.{param}")
+}
+
+/// Track automation mode (the dropdown above the M/S/R buttons).
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub enum AutomationMode {
+    /// Ignore stored automation; play the static values.
+    Off,
+    /// Play automation; touching a control during playback does not record.
+    #[default]
+    Read,
+    /// Record from the first touch; after release keep writing the last value until playback stops.
+    Latch,
+    /// Record while touched; after release return to the previous automation over the automatch time.
+    Touch,
+    /// Record every automatable control from the start of playback until it stops.
+    Write,
+}
+
+impl AutomationMode {
+    pub const ALL: [AutomationMode; 5] = [AutomationMode::Off, AutomationMode::Read, AutomationMode::Latch, AutomationMode::Touch, AutomationMode::Write];
+    pub fn label(self) -> &'static str {
+        match self {
+            AutomationMode::Off => "Off",
+            AutomationMode::Read => "Read",
+            AutomationMode::Latch => "Latch",
+            AutomationMode::Touch => "Touch",
+            AutomationMode::Write => "Write",
+        }
+    }
+    pub fn from_name(s: &str) -> Option<Self> {
+        Self::ALL.into_iter().find(|m| m.label().eq_ignore_ascii_case(s))
+    }
+    /// Plays stored automation.
+    pub fn reads(self) -> bool {
+        self != AutomationMode::Off
+    }
+    /// Records automation during playback.
+    pub fn writes(self) -> bool {
+        matches!(self, AutomationMode::Latch | AutomationMode::Touch | AutomationMode::Write)
+    }
+}
+
+/// How the clips' (stereo) audio feeds the track input: basic channel mapping.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub enum InputMap {
+    /// L → L, R → R.
+    #[default]
+    Stereo,
+    /// Left channel to both sides.
+    Left,
+    /// Right channel to both sides.
+    Right,
+    /// L ↔ R.
+    Swap,
+    /// (L + R) / 2 to both sides.
+    Mono,
+}
+
+impl InputMap {
+    pub const ALL: [InputMap; 5] = [InputMap::Stereo, InputMap::Left, InputMap::Right, InputMap::Swap, InputMap::Mono];
+    pub fn label(self) -> &'static str {
+        match self {
+            InputMap::Stereo => "Stereo",
+            InputMap::Left => "Left",
+            InputMap::Right => "Right",
+            InputMap::Swap => "Swap",
+            InputMap::Mono => "Mono",
+        }
+    }
+    pub fn from_name(s: &str) -> Option<Self> {
+        Self::ALL.into_iter().find(|m| m.label().eq_ignore_ascii_case(s))
+    }
+}
+
+/// A send from a strip to a submix.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TrackSend {
+    /// Destination submix track.
+    pub target: TrackId,
+    /// Send level (dB); automatable as lane `send.<i>.level`.
+    pub level_db: f64,
+    /// Send pan / balance (−100 … 100).
+    #[serde(default)]
+    pub pan: f64,
+    /// Tap before the fader (after the pre-fader inserts) instead of after the post-fader inserts.
+    #[serde(default)]
+    pub pre_fader: bool,
+    #[serde(default)]
+    pub muted: bool,
+}
+
+impl TrackSend {
+    pub fn new(target: TrackId) -> Self {
+        TrackSend { target, level_db: 0.0, pan: 0.0, pre_fader: false, muted: false }
+    }
+}
+
+/// Mixer-only state of a channel strip (audio track, submix or Mix).
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+#[serde(default)]
+pub struct MixerStrip {
+    pub mode: AutomationMode,
+    /// Automation lanes (`volume`, `pan`, `mute`, `send.<i>.level`), keyframes in sequence time.
+    #[serde(skip_serializing_if = "BTreeMap::is_empty")]
+    pub lanes: BTreeMap<String, Param>,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    pub sends: Vec<TrackSend>,
+    /// Output assignment: a submix track, or `None` for the Mix track.
+    pub output: Option<TrackId>,
+    /// Record-arm (R): the track records voice-over input.
+    pub record_arm: bool,
+    /// Solo safe: never solo-muted, and keeps its sources audible while other strips are soloed.
+    pub solo_safe: bool,
+    /// How clip audio feeds the track.
+    pub input_map: InputMap,
+}
+
+/// Description of an automation lane for display and value ranges.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct LaneInfo {
+    pub min: f64,
+    pub max: f64,
+    /// Values hold between keyframes (switches such as mute).
+    pub hold: bool,
+    pub unit: &'static str,
+}
+
+/// Range and behaviour of a non-effect lane (`volume`, `pan`, `mute`, `send.<i>.level`).
+pub fn lane_info(key: &str) -> Option<LaneInfo> {
+    match key {
+        LANE_VOLUME => Some(LaneInfo { min: FADER_MIN_DB, max: FADER_MAX_DB, hold: false, unit: "dB" }),
+        LANE_PAN => Some(LaneInfo { min: -100.0, max: 100.0, hold: false, unit: "" }),
+        LANE_MUTE => Some(LaneInfo { min: 0.0, max: 1.0, hold: true, unit: "" }),
+        k if parse_send_lane(k).is_some() => Some(LaneInfo { min: FADER_MIN_DB, max: FADER_MAX_DB, hold: false, unit: "dB" }),
+        _ => None,
+    }
+}
+
+pub fn parse_send_lane(key: &str) -> Option<usize> {
+    key.strip_prefix("send.")?.strip_suffix(".level")?.parse().ok()
+}
+
+pub fn parse_fx_lane(key: &str) -> Option<(usize, &str)> {
+    let rest = key.strip_prefix("fx.")?;
+    let (slot, param) = rest.split_once('.')?;
+    Some((slot.parse().ok()?, param))
+}
+
+impl Track {
+    /// Static (un-automated) value of a lane.
+    pub fn lane_static(&self, key: &str) -> Option<f64> {
+        match key {
+            LANE_VOLUME => Some(self.volume_db),
+            LANE_PAN => Some(self.pan),
+            LANE_MUTE => Some(if self.muted { 1.0 } else { 0.0 }),
+            k => {
+                if let Some(i) = parse_send_lane(k) {
+                    return self.mixer.sends.get(i).map(|s| s.level_db);
+                }
+                let (slot, p) = parse_fx_lane(k)?;
+                self.effects.get(slot)?.param(p)?.value.as_f64()
+            }
+        }
+    }
+
+    /// The keyframed parameter behind a lane, if any.
+    pub fn lane(&self, key: &str) -> Option<&Param> {
+        match parse_fx_lane(key) {
+            Some((slot, p)) => self.effects.get(slot)?.param(p),
+            None => self.mixer.lanes.get(key),
+        }
+    }
+
+    /// The parameter behind a lane, created (static, from the current value) if missing.
+    pub fn lane_mut(&mut self, key: &str) -> Option<&mut Param> {
+        if let Some((slot, p)) = parse_fx_lane(key) {
+            return self.effects.get_mut(slot)?.param_mut(p);
+        }
+        let stat = self.lane_static(key)?;
+        lane_info(key)?;
+        Some(self.mixer.lanes.entry(key.to_string()).or_insert_with(|| Param::new(ParamValue::Float(stat))))
+    }
+
+    /// Lane keyframes (empty when the lane is not automated).
+    pub fn lane_keyframes(&self, key: &str) -> &[Keyframe] {
+        self.lane(key).map(|p| p.keyframes.as_slice()).unwrap_or(&[])
+    }
+
+    /// Value of a lane at sequence time `t` as playback hears it (automation unless the mode is Off).
+    pub fn lane_value(&self, key: &str, t: Tick) -> f64 {
+        let stat = self.lane_static(key).unwrap_or(0.0);
+        if !self.mixer.mode.reads() {
+            return stat;
+        }
+        match self.lane(key) {
+            Some(p) if p.is_animated() => p.scalar_at(t),
+            _ => stat,
+        }
+    }
+
+    /// All automated lane keys of this strip.
+    pub fn automated_lanes(&self) -> Vec<String> {
+        let mut v: Vec<String> = self.mixer.lanes.iter().filter(|(_, p)| p.is_animated()).map(|(k, _)| k.clone()).collect();
+        for (slot, e) in self.effects.iter().enumerate() {
+            for (pid, p) in &e.params {
+                if p.is_animated() {
+                    v.push(fx_lane(slot, pid));
+                }
+            }
+        }
+        v
+    }
+
+    /// Set a lane's static value (fader moves in Off/Read mode, or no automation yet).
+    pub fn set_lane_static(&mut self, key: &str, v: f64) -> bool {
+        match key {
+            LANE_VOLUME => self.volume_db = v.clamp(FADER_MIN_DB, FADER_MAX_DB),
+            LANE_PAN => self.pan = v.clamp(-100.0, 100.0),
+            LANE_MUTE => self.muted = v >= 0.5,
+            k => {
+                if let Some(i) = parse_send_lane(k) {
+                    match self.mixer.sends.get_mut(i) {
+                        Some(s) => s.level_db = v.clamp(FADER_MIN_DB, FADER_MAX_DB),
+                        None => return false,
+                    }
+                } else if let Some((slot, p)) = parse_fx_lane(k) {
+                    match self.effects.get_mut(slot).and_then(|e| e.param_mut(p)) {
+                        Some(par) => par.value = ParamValue::Float(v),
+                        None => return false,
+                    }
+                } else {
+                    return false;
+                }
+            }
+        }
+        true
+    }
+
+    /// Remove insert `slot` (its automation goes with it: effect lanes live inside the effect).
+    pub fn remove_insert(&mut self, slot: usize) -> bool {
+        if slot < self.effects.len() {
+            self.effects.remove(slot);
+            true
+        } else {
+            false
+        }
+    }
+
+    /// Remove send `i` and shift the automation lanes of the sends above it down.
+    pub fn remove_send(&mut self, i: usize) -> bool {
+        if i >= self.mixer.sends.len() {
+            return false;
+        }
+        self.mixer.sends.remove(i);
+        let mut lanes = std::mem::take(&mut self.mixer.lanes);
+        let moved: Vec<(String, Param)> = lanes.iter().filter_map(|(k, p)| parse_send_lane(k).filter(|&j| j >= i).map(|_| (k.clone(), p.clone()))).collect();
+        for (k, _) in &moved {
+            lanes.remove(k);
+        }
+        for (k, p) in moved {
+            let j = parse_send_lane(&k).unwrap_or(0);
+            if j > i {
+                lanes.insert(send_lane(j - 1), p);
+            }
+        }
+        self.mixer.lanes = lanes;
+        true
+    }
+}
+
+/// Strip id of the Mix (master) track.
+pub const MASTER_STRIP: TrackId = TrackId(u64::MAX);
+
+impl crate::Sequence {
+    /// The Mix track as a [`Track`] (volume, inserts and mixer state; no clips).
+    pub fn master_strip(&self) -> Track {
+        let mut m = Track::new(MASTER_STRIP, crate::TrackKind::Audio, "Mix".into());
+        m.volume_db = self.master_volume_db;
+        m.effects = self.master_effects.clone();
+        m.mixer = self.master_mixer.clone();
+        m.channels = self.settings.audio_master;
+        m
+    }
+
+    /// Any mixer strip (audio track, submix or [`MASTER_STRIP`]).
+    pub fn strip(&self, id: TrackId) -> Option<std::borrow::Cow<'_, Track>> {
+        if id == MASTER_STRIP {
+            return Some(std::borrow::Cow::Owned(self.master_strip()));
+        }
+        self.mix_track(id).map(std::borrow::Cow::Borrowed)
+    }
+
+    /// Edit any mixer strip; edits to the Mix are written back to the sequence's master fields.
+    pub fn with_strip_mut<R>(&mut self, id: TrackId, f: impl FnOnce(&mut Track) -> R) -> Option<R> {
+        if id == MASTER_STRIP {
+            let mut m = self.master_strip();
+            let r = f(&mut m);
+            self.master_volume_db = m.volume_db;
+            self.master_effects = m.effects;
+            self.master_mixer = m.mixer;
+            return Some(r);
+        }
+        self.mix_track_mut(id).map(f)
+    }
+
+    /// Ids of all strips in mixer order: audio tracks, submixes, Mix.
+    pub fn strip_ids(&self) -> Vec<TrackId> {
+        self.audio_tracks.iter().chain(&self.submix_tracks).map(|t| t.id).chain(std::iter::once(MASTER_STRIP)).collect()
+    }
+
+    /// An audio or submix track (the strips that have a fader besides the Mix).
+    pub fn mix_track(&self, id: TrackId) -> Option<&Track> {
+        self.audio_tracks.iter().chain(&self.submix_tracks).find(|t| t.id == id)
+    }
+    pub fn mix_track_mut(&mut self, id: TrackId) -> Option<&mut Track> {
+        self.audio_tracks.iter_mut().chain(self.submix_tracks.iter_mut()).find(|t| t.id == id)
+    }
+    /// Mix track volume (dB) at sequence time `t` (automation unless the Mix is in Off mode).
+    pub fn master_volume_at(&self, t: Tick) -> f64 {
+        match self.master_mixer.lanes.get(LANE_VOLUME) {
+            Some(p) if p.is_animated() && self.master_mixer.mode.reads() => p.scalar_at(t),
+            _ => self.master_volume_db,
+        }
+    }
+}
+
+/// Thin a recorded gesture (time, value) into keyframes: Ramer–Douglas–Peucker on the value axis
+/// (every dropped point lies within `tolerance` of the line between the kept neighbours), then drop
+/// points closer than `min_interval` to the previous kept one (except the last). `hold` lanes keep
+/// only the points where the value changes.
+pub fn thin_points(points: &[(Tick, f64)], tolerance: f64, min_interval: Tick, hold: bool) -> Vec<(Tick, f64)> {
+    let mut pts: Vec<(Tick, f64)> = Vec::with_capacity(points.len());
+    for &(t, v) in points {
+        match pts.last_mut() {
+            Some(last) if last.0 == t => last.1 = v,
+            Some(last) if last.0 > t => {}
+            _ => pts.push((t, v)),
+        }
+    }
+    if pts.len() <= 2 {
+        return pts;
+    }
+    if hold {
+        let mut out = vec![pts[0]];
+        for w in pts.windows(2) {
+            if (w[1].1 - w[0].1).abs() > tolerance.max(1e-9) {
+                out.push(w[1]);
+            }
+        }
+        return out;
+    }
+    let mut keep = vec![false; pts.len()];
+    keep[0] = true;
+    keep[pts.len() - 1] = true;
+    let mut stack = vec![(0usize, pts.len() - 1)];
+    while let Some((a, b)) = stack.pop() {
+        if b <= a + 1 {
+            continue;
+        }
+        let (ta, va) = (pts[a].0.0 as f64, pts[a].1);
+        let (tb, vb) = (pts[b].0.0 as f64, pts[b].1);
+        let mut worst = (0.0f64, 0usize);
+        for (i, p) in pts.iter().enumerate().take(b).skip(a + 1) {
+            let u = (p.0.0 as f64 - ta) / (tb - ta);
+            let d = (p.1 - (va + (vb - va) * u)).abs();
+            if d > worst.0 {
+                worst = (d, i);
+            }
+        }
+        if worst.0 > tolerance {
+            keep[worst.1] = true;
+            stack.push((a, worst.1));
+            stack.push((worst.1, b));
+        }
+    }
+    let mut out: Vec<(Tick, f64)> = Vec::new();
+    let n = pts.len();
+    for (i, p) in pts.into_iter().enumerate() {
+        if !keep[i] {
+            continue;
+        }
+        if i + 1 < n && min_interval.0 > 0 && out.last().is_some_and(|l: &(Tick, f64)| p.0 - l.0 < min_interval) {
+            continue;
+        }
+        out.push(p);
+    }
+    out
+}
+
+/// Replace the keyframes of `param` within `[t0, t1]` by `points` (already thinned).
+///
+/// `before`/`after` are the lane values just outside the written range: when given, a keyframe is
+/// placed one `eps` outside the range so the automation outside `[t0, t1]` is unchanged.
+pub fn write_lane(param: &mut Param, t0: Tick, t1: Tick, points: &[(Tick, f64)], before: Option<f64>, after: Option<f64>, eps: Tick, hold: bool) {
+    let interp = if hold { Interpolation::Hold } else { Interpolation::Linear };
+    param.keyframes.retain(|k| k.time < t0 || k.time > t1);
+    let mut add = |t: Tick, v: f64| {
+        let mut k = Keyframe::new(t, ParamValue::Float(v));
+        k.interp = interp;
+        match param.keyframes.binary_search_by_key(&t, |k| k.time) {
+            Ok(i) => param.keyframes[i] = k,
+            Err(i) => param.keyframes.insert(i, k),
+        }
+    };
+    if let Some(b) = before {
+        let tb = t0 - eps;
+        if tb.0 >= 0 {
+            add(tb, b);
+        }
+    }
+    for &(t, v) in points.iter().filter(|p| p.0 >= t0 && p.0 <= t1) {
+        add(t, v);
+    }
+    if let Some(a) = after {
+        add(t1 + eps, a);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::TrackKind;
+
+    fn tr() -> Track {
+        Track::new(TrackId(1), TrackKind::Audio, "Audio 1".into())
+    }
+
+    #[test]
+    fn mode_names_roundtrip() {
+        for m in AutomationMode::ALL {
+            assert_eq!(AutomationMode::from_name(m.label()), Some(m));
+        }
+        assert_eq!(AutomationMode::default(), AutomationMode::Read);
+        assert!(!AutomationMode::Off.reads() && AutomationMode::Touch.writes() && !AutomationMode::Read.writes());
+    }
+
+    #[test]
+    fn lanes_read_static_and_keyframes() {
+        let mut t = tr();
+        t.volume_db = -6.0;
+        assert_eq!(t.lane_value(LANE_VOLUME, Tick(0)), -6.0);
+        let p = t.lane_mut(LANE_VOLUME).unwrap();
+        p.keyframes.push(Keyframe::new(Tick(0), ParamValue::Float(0.0)));
+        p.keyframes.push(Keyframe::new(Tick(100), ParamValue::Float(-20.0)));
+        assert_eq!(t.lane_value(LANE_VOLUME, Tick(50)), -10.0);
+        t.mixer.mode = AutomationMode::Off;
+        assert_eq!(t.lane_value(LANE_VOLUME, Tick(50)), -6.0);
+        assert_eq!(t.automated_lanes(), vec!["volume".to_string()]);
+    }
+
+    #[test]
+    fn thinning_keeps_shape_within_tolerance() {
+        // a ramp sampled densely collapses to its end points; a corner survives
+        let pts: Vec<(Tick, f64)> = (0..=100).map(|i| (Tick(i * 10), if i <= 50 { i as f64 * 0.2 } else { 10.0 - (i - 50) as f64 * 0.2 })).collect();
+        let th = thin_points(&pts, 0.01, Tick(0), false);
+        assert_eq!(th, vec![(Tick(0), 0.0), (Tick(500), 10.0), (Tick(1000), 0.0)]);
+        // every original point within tolerance of the thinned curve
+        let mut p = Param::new(ParamValue::Float(0.0));
+        write_lane(&mut p, Tick(0), Tick(1000), &th, None, None, Tick(1), false);
+        for (t, v) in pts {
+            assert!((p.scalar_at(t) - v).abs() <= 0.01 + 1e-9);
+        }
+        // hold lanes keep change points only
+        let m = [(Tick(0), 0.0), (Tick(10), 0.0), (Tick(20), 1.0), (Tick(30), 1.0), (Tick(40), 0.0)];
+        assert_eq!(thin_points(&m, 0.0, Tick(0), true), vec![(Tick(0), 0.0), (Tick(20), 1.0), (Tick(40), 0.0)]);
+    }
+
+    #[test]
+    fn write_lane_preserves_outside() {
+        let mut p = Param::new(ParamValue::Float(0.0));
+        write_lane(&mut p, Tick(0), Tick(1000), &[(Tick(0), -3.0), (Tick(1000), -3.0)], None, None, Tick(1), false);
+        write_lane(&mut p, Tick(400), Tick(600), &[(Tick(400), -20.0), (Tick(600), -20.0)], Some(-3.0), Some(-3.0), Tick(1), false);
+        assert_eq!(p.scalar_at(Tick(200)), -3.0);
+        assert_eq!(p.scalar_at(Tick(500)), -20.0);
+        assert_eq!(p.scalar_at(Tick(800)), -3.0);
+        assert_eq!(p.keyframes.len(), 6);
+    }
+
+    #[test]
+    fn send_removal_shifts_lanes() {
+        let mut t = tr();
+        for k in 0..3 {
+            t.mixer.sends.push(TrackSend::new(TrackId(10 + k)));
+            t.mixer.sends[k as usize].level_db = -(k as f64);
+            t.lane_mut(&send_lane(k as usize)).unwrap().keyframes.push(Keyframe::new(Tick(0), ParamValue::Float(-(k as f64))));
+        }
+        assert!(t.remove_send(1));
+        assert_eq!(t.mixer.sends.len(), 2);
+        assert_eq!(t.lane_keyframes(&send_lane(1))[0].value, ParamValue::Float(-2.0));
+        assert!(t.lane(&send_lane(2)).is_none());
+    }
+
+    #[test]
+    fn serde_defaults() {
+        let s: MixerStrip = serde_json::from_str("{}").unwrap();
+        assert_eq!(s, MixerStrip::default());
+        let mut t = tr();
+        t.mixer.mode = AutomationMode::Touch;
+        let j = serde_json::to_string(&t).unwrap();
+        let back: Track = serde_json::from_str(&j).unwrap();
+        assert_eq!(back, t);
+    }
+}
diff --git a/crates/prores/Cargo.toml b/crates/prores/Cargo.toml
index aa3f2f117..67c2002d1 100644
--- a/crates/prores/Cargo.toml
+++ b/crates/prores/Cargo.toml
@@ -17,3 +17,6 @@ threads = ["dep:rayon"]
 filmcraft-bitstream = { workspace = true }
 thiserror = { workspace = true }
 rayon = { workspace = true, optional = true }
+
+[dev-dependencies]
+filmcraft-testkit = { workspace = true }
diff --git a/crates/prores/tests/common/mod.rs b/crates/prores/tests/common/mod.rs
index d567dac6a..9b3192aa0 100644
--- a/crates/prores/tests/common/mod.rs
+++ b/crates/prores/tests/common/mod.rs
@@ -6,24 +6,13 @@ use filmcraft_prores::{ChromaFormat, Frame};
 use std::path::{Path, PathBuf};
 use std::process::Command;
 
+/// ffmpeg, or `None` after printing `SKIPPED` (see `filmcraft_testkit::oracle`).
 pub fn ffmpeg() -> Option<PathBuf> {
-    for dir in ["/opt/homebrew/bin", "/usr/local/bin", "/usr/bin"] {
-        let p = Path::new(dir).join("ffmpeg");
-        if p.exists() {
-            return Some(p);
-        }
-    }
-    let ok = Command::new("ffmpeg").arg("-version").output().map(|o| o.status.success()).unwrap_or(false);
-    if !ok {
-        eprintln!("ffmpeg not found; skipping oracle test");
-    }
-    ok.then(|| PathBuf::from("ffmpeg"))
+    filmcraft_testkit::ffmpeg_or_skip("prores oracle")
 }
 
 pub fn fixture_dir() -> PathBuf {
-    let d = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../target/fixtures/prores");
-    std::fs::create_dir_all(&d).unwrap();
-    d
+    filmcraft_testkit::fixtures_dir("prores")
 }
 
 fn run(ff: &Path, args: &[&str]) {
@@ -51,7 +40,7 @@ impl Spec {
 pub fn make(ff: &Path, spec: &Spec) -> PathBuf {
     let path = fixture_dir().join(format!("{}.mov", spec.name));
     if !path.exists() {
-        let tmp = fixture_dir().join(format!("{}.tmp.mov", spec.name));
+        let tmp = filmcraft_testkit::temp_path(&path);
         let frames = spec.frames.to_string();
         let mut args = vec!["-f", "lavfi", "-i", spec.lavfi.as_str(), "-frames:v", frames.as_str()];
         args.extend(spec.enc.iter().copied());
diff --git a/crates/prores/tests/oracle_decode.rs b/crates/prores/tests/oracle_decode.rs
index 23387807b..1b93eda97 100644
--- a/crates/prores/tests/oracle_decode.rs
+++ b/crates/prores/tests/oracle_decode.rs
@@ -140,3 +140,14 @@ fn color_metadata_is_reported() {
     let f = decode_frame(&packets(&ff, &mov)[0]).unwrap();
     assert_eq!((f.color.primaries, f.color.transfer, f.color.matrix), (9, 16, 9));
 }
+
+/// Pre-generate every decode fixture (`cargo xtask fixtures`).
+#[test]
+#[ignore]
+fn generate_fixtures() {
+    let Some(ff) = ffmpeg() else { return };
+    for spec in specs() {
+        let out = [fixture_dir().join(format!("{}.mov", spec.name))];
+        filmcraft_testkit::fixtures::generate_and_report(&format!("prores/{}", spec.name), &out, || Some(make(&ff, &spec)));
+    }
+}
diff --git a/crates/render/Cargo.toml b/crates/render/Cargo.toml
index 7c9b9c9e0..315bd48c4 100644
--- a/crates/render/Cargo.toml
+++ b/crates/render/Cargo.toml
@@ -18,6 +18,7 @@ filmcraft-media = { workspace = true }
 filmcraft-project = { workspace = true }
 filmcraft-audio-dsp = { workspace = true }
 filmcraft-captions = { workspace = true }
+filmcraft-text = { workspace = true }
 rayon = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
diff --git a/crates/render/src/audio.rs b/crates/render/src/audio.rs
index 01cb5643c..1f051593b 100644
--- a/crates/render/src/audio.rs
+++ b/crates/render/src/audio.rs
@@ -1,11 +1,9 @@
-//! Sequence audio mixdown (clip gain → Volume/Channel Volume/Panner → track volume/pan →
-//! master), with audio transitions, mute/solo, speed changes (varispeed resampling).
-//!
-//! The dedicated `audio` crate (M7) adds the effect DSP, submixes and meters; this module is the
-//! reference mixer used by playback and export.
+//! Clip-level audio: clip gain → clip effects → Volume / Channel Volume / Panner, audio transitions
+//! and speed changes (varispeed resampling), summed per track. The track/submix/Mix graph that
+//! consumes it is [`crate::mixer`].
 
 use filmcraft_frame::AudioBuffer;
-use filmcraft_project::{Project, Sequence, TrackItem};
+use filmcraft_project::{Project, Sequence, Track, TrackItem};
 use filmcraft_time::{Tick, TimeRange};
 
 use crate::{SourceProvider, transitions};
@@ -14,74 +12,63 @@ pub fn db_to_gain(db: f64) -> f32 {
     if db <= -96.0 { 0.0 } else { 10f64.powf(db / 20.0) as f32 }
 }
 
-/// Mix `frames` stereo samples of sequence audio starting at sample `start` (sequence rate).
+/// Mix `frames` stereo samples of sequence audio starting at sample `start` (sequence rate), through
+/// the full mixer graph ([`crate::mixer`]). Export and playback both use this.
 pub fn mix_sequence(project: &Project, seq: &Sequence, start: i64, frames: usize, sources: &dyn SourceProvider) -> AudioBuffer {
-    let sr = seq.settings.sample_rate;
-    let mut out = AudioBuffer::silence(sr, 2, frames);
-    let range = TimeRange::from_bounds(Tick::from_units(start, sr as i64), Tick::from_units(start + frames as i64, sr as i64));
-    let any_solo = seq.audio_tracks.iter().any(|t| t.solo);
-    for track in &seq.audio_tracks {
-        if track.muted || (any_solo && !track.solo) {
-            continue;
-        }
-        let mut tbuf = AudioBuffer::silence(sr, 2, frames);
-        for item in track.items.iter().filter(|i| i.enabled && i.range().overlaps(&range)) {
-            mix_item(project, item, start, frames, sr, sources, &mut tbuf, 1.0);
-        }
-        // audio transitions: attenuate the covered region of each side
-        for tr in &track.transitions {
-            if !tr.range().overlaps(&range) {
-                continue;
-            }
-            // Re-mix: recompute the covered samples with crossfade gains.
-            let from = tr.from.and_then(|id| track.item(id));
-            let to = tr.to.and_then(|id| track.item(id));
-            let s0 = tr.start.to_units_floor(sr as i64).max(start);
-            let s1 = tr.end().to_units_floor(sr as i64).min(start + frames as i64);
-            if s1 <= s0 {
-                continue;
-            }
-            let n = (s1 - s0) as usize;
-            let off = (s0 - start) as usize;
-            for ch in tbuf.channels.iter_mut() {
-                ch[off..off + n].fill(0.0);
-            }
-            let mut a = AudioBuffer::silence(sr, 2, n);
-            let mut b = AudioBuffer::silence(sr, 2, n);
-            if let Some(f) = from {
-                mix_item(project, f, s0, n, sr, sources, &mut a, 1.0);
-            }
-            if let Some(tt) = to {
-                mix_item(project, tt, s0, n, sr, sources, &mut b, 1.0);
-            }
-            let dur = (tr.end() - tr.start).to_units_floor(sr as i64).max(1) as f32;
-            let base = (s0 - tr.start.to_units_floor(sr as i64)) as f32;
-            for i in 0..n {
-                let p = (base + i as f32) / dur;
-                let (ga, gb) = transitions::audio_gains(&tr.effect.effect, p);
-                for c in 0..2 {
-                    tbuf.channels[c][off + i] += a.channels[c][i] * ga + b.channels[c][i] * gb;
-                }
-            }
-        }
-        let g = db_to_gain(track.volume_db);
-        let pan = (track.pan / 100.0).clamp(-1.0, 1.0) as f32;
-        let (gl, gr) = pan_gains(pan);
-        out.mix_from(&tbuf, &[g * gl, g * gr]);
-    }
-    let mg = db_to_gain(seq.master_volume_db);
-    if (mg - 1.0).abs() > 1e-6 {
-        for ch in &mut out.channels {
-            for s in ch.iter_mut() {
-                *s *= mg;
-            }
-        }
-    }
-    out
+    crate::mixer::mix_graph(project, seq, start, frames, sources, None)
 }
 
-/// -3 dB constant-power pan law, normalised so centre = unity.
-fn pan_gains(pan: f32) -> (f32, f32) {
+/// The summed clip audio of one track (clip gain, clip effects, Volume / Channel Volume / Panner,
+/// audio transitions) for sequence samples `[start, start + frames)`: the track's mixer input.
+pub fn track_input(project: &Project, track: &Track, start: i64, frames: usize, sr: u32, sources: &dyn SourceProvider) -> AudioBuffer {
+    let range = TimeRange::from_bounds(Tick::from_units(start, sr as i64), Tick::from_units(start + frames as i64, sr as i64));
+    let mut tbuf = AudioBuffer::silence(sr, 2, frames);
+    for item in track.items.iter().filter(|i| i.enabled && i.range().overlaps(&range)) {
+        mix_item(project, item, start, frames, sr, sources, &mut tbuf, 1.0);
+    }
+    // audio transitions: attenuate the covered region of each side
+    for tr in &track.transitions {
+        if !tr.range().overlaps(&range) {
+            continue;
+        }
+        // Re-mix: recompute the covered samples with crossfade gains.
+        let from = tr.from.and_then(|id| track.item(id));
+        let to = tr.to.and_then(|id| track.item(id));
+        let s0 = tr.start.to_units_floor(sr as i64).max(start);
+        let s1 = tr.end().to_units_floor(sr as i64).min(start + frames as i64);
+        if s1 <= s0 {
+            continue;
+        }
+        let n = (s1 - s0) as usize;
+        let off = (s0 - start) as usize;
+        for ch in tbuf.channels.iter_mut() {
+            ch[off..off + n].fill(0.0);
+        }
+        let mut a = AudioBuffer::silence(sr, 2, n);
+        let mut b = AudioBuffer::silence(sr, 2, n);
+        if let Some(f) = from {
+            mix_item(project, f, s0, n, sr, sources, &mut a, 1.0);
+        }
+        if let Some(tt) = to {
+            mix_item(project, tt, s0, n, sr, sources, &mut b, 1.0);
+        }
+        let dur = (tr.end() - tr.start).to_units_floor(sr as i64).max(1) as f32;
+        let base = (s0 - tr.start.to_units_floor(sr as i64)) as f32;
+        for i in 0..n {
+            let p = (base + i as f32) / dur;
+            let (ga, gb) = transitions::audio_gains(&tr.effect.effect, p);
+            for c in 0..2 {
+                tbuf.channels[c][off + i] += a.channels[c][i] * ga + b.channels[c][i] * gb;
+            }
+        }
+    }
+    tbuf
+}
+
+/// Balance for stereo signals (clip Panner, stereo track pan): centre = unity on both sides, turning
+/// one way attenuates the other side along the −3 dB constant-power curve (normalised so the
+/// centre is 0 dB); hard left/right silences the opposite side.
+pub fn pan_gains(pan: f32) -> (f32, f32) {
     let a = (pan + 1.0) * std::f32::consts::FRAC_PI_4;
     let k = std::f32::consts::SQRT_2;
     ((a.cos() * k).min(1.0), (a.sin() * k).min(1.0))
@@ -115,19 +102,23 @@ fn mix_item(project: &Project, item: &TrackItem, start: i64, frames: usize, sr:
     let chv = item.effect("channel_volume").filter(|e| e.enabled && !e.param("bypass").and_then(|p| p.value.as_bool()).unwrap_or(false));
     let pan = item.effect("panner").filter(|e| e.enabled);
     let off = (a0 - start) as usize;
-    for blk in (0..n).step_by(64) {
-        let t_tl = Tick::from_units(a0 + blk as i64, sr as i64);
+    // Gains change on an absolute 64-sample grid, so the output does not depend on how callers cut
+    // the timeline into requests.
+    let mut blk = 0usize;
+    while blk < n {
+        let t_tl = Tick::from_units((a0 + blk as i64).div_euclid(64) * 64, sr as i64);
         let mt = item.source_time_at(t_tl);
         let v = vol.map(|e| db_to_gain(e.f64_at("level", mt))).unwrap_or(1.0);
         let (cl, cr) = chv.map(|e| (db_to_gain(e.f64_at("left", mt)), db_to_gain(e.f64_at("right", mt)))).unwrap_or((1.0, 1.0));
         let (pl, pr) = pan.map(|e| pan_gains((e.f64_at("balance", mt) / 100.0) as f32)).unwrap_or((1.0, 1.0));
         let g = clip_gain * v * extra;
-        let end = (blk + 64).min(n);
+        let end = (((a0 + blk as i64).div_euclid(64) + 1) * 64 - a0).min(n as i64) as usize;
         for i in blk..end {
             let (l, r) = (buf[0][i], buf[1][i]);
             out.channels[0][off + i] += l * g * cl * pl;
             out.channels[1][off + i] += r * g * cr * pr;
         }
+        blk = end;
     }
 }
 
diff --git a/crates/render/src/audio_fx.rs b/crates/render/src/audio_fx.rs
index a6a10e8cd..28f335b4a 100644
--- a/crates/render/src/audio_fx.rs
+++ b/crates/render/src/audio_fx.rs
@@ -15,12 +15,12 @@ use filmcraft_project::{EffectInstance, TrackItem};
 use filmcraft_time::Tick;
 
 /// How a project effect maps onto a DSP effect.
-struct Mapping {
-    dsp: &'static str,
+pub(crate) struct Mapping {
+    pub(crate) dsp: &'static str,
     /// Pre-roll (seconds) for a fresh chain; closures get the effect instance at the start time.
-    preroll: fn(&EffectInstance, Tick) -> f64,
+    pub(crate) preroll: fn(&EffectInstance, Tick) -> f64,
     /// Set DSP parameters from the (keyframed) project parameters at media time `mt`.
-    apply: fn(&mut dyn AudioEffect, &EffectInstance, Tick),
+    pub(crate) apply: fn(&mut dyn AudioEffect, &EffectInstance, Tick),
 }
 
 fn ignore(_: bool) {}
@@ -29,7 +29,7 @@ fn f(e: &EffectInstance, id: &str, mt: Tick) -> f32 {
     e.f64_at(id, mt) as f32
 }
 
-fn mapping(id: &str) -> Option<Mapping> {
+pub(crate) fn mapping(id: &str) -> Option<Mapping> {
     Some(match id {
         "amplify" => Mapping { dsp: "amplify", preroll: |_, _| 0.0, apply: |d, e, t| ignore(d.set_param("gain", f(e, "gain", t))) },
         "dynamics" => Mapping {
@@ -110,6 +110,11 @@ fn mapping(id: &str) -> Option<Mapping> {
     })
 }
 
+/// Whether a project audio effect has a DSP implementation (clip effects and mixer inserts).
+pub fn supported(effect_id: &str) -> bool {
+    mapping(effect_id).is_some()
+}
+
 fn band(d: &mut dyn AudioEffect, kind: f32, freq: f32, q: f32) {
     d.set_param("b1.on", 1.0);
     d.set_param("b1.type", kind);
@@ -160,8 +165,10 @@ fn run(chain: &mut Chain, item: &TrackItem, in0: i64, input: &mut [Vec<f32>; 2],
     let n = input[0].len();
     let mut i = 0;
     while i < n {
-        let end = (i + BLOCK).min(n);
-        let mt = item.source_time_at(Tick::from_units(in0 + i as i64, sr as i64));
+        // absolute block grid: parameters update at the same samples however requests are cut
+        let pos = in0 + i as i64;
+        let end = (((pos.div_euclid(BLOCK as i64) + 1) * BLOCK as i64 - in0) as usize).min(n);
+        let mt = item.source_time_at(Tick::from_units(pos.div_euclid(BLOCK as i64) * BLOCK as i64, sr as i64));
         for ((e, m), d) in act.iter().zip(chain.fx.iter_mut()) {
             (m.apply)(d.as_mut(), e, mt);
         }
diff --git a/crates/render/src/effects.rs b/crates/render/src/effects.rs
index 2136fda7d..fe40bbd4d 100644
--- a/crates/render/src/effects.rs
+++ b/crates/render/src/effects.rs
@@ -716,40 +716,16 @@ pub fn apply(img: &mut Image, e: &EffectInstance, cx: &FxCtx) {
             });
         }
         "timecode" | "clip_name" => {
-            let text = if e.effect == "timecode" {
-                cx.timecode.to_string()
-            } else {
-                cx.clip_name.chars().filter(|c| c.is_ascii_digit() || *c == ':' || *c == '-').collect()
-            };
+            let (text, family) = if e.effect == "timecode" { (cx.timecode.to_string(), "JetBrains Mono") } else { (cx.clip_name.to_string(), "Inter") };
             let pos = point(e, "position", cx, img);
-            let size = (f(e, "size", cx) / 100.0 * img.h as f32 * 0.5).max(6.0) as i32;
-            burn_text(img, &text, pos, size);
+            let px = (f(e, "size", cx) / 100.0 * img.h as f32 * 0.5).max(6.0);
+            let box_alpha = if e.effect == "timecode" { (f(e, "opacity", cx) / 100.0).clamp(0.0, 1.0) * 0.8 } else { 0.8 };
+            crate::graphics::burn_text(img, &text, family, pos, px, box_alpha);
         }
         _ => {}
     }
 }
 
-fn burn_text(img: &mut Image, text: &str, pos: Vec2, size: i32) {
-    let tw = filmcraft_media::digits::text_width(size, text);
-    let (w, h) = (img.w, img.h);
-    let mut buf = vec![0u8; w * h * 4];
-    let x = pos.x as i32 - tw / 2;
-    let y = pos.y as i32 - size / 2;
-    filmcraft_media::digits::fill_rect(&mut buf, w, h, x - size / 4, y - size / 4, tw + size / 2, size + size / 2, [0, 0, 0, 200]);
-    filmcraft_media::digits::draw_text(&mut buf, w, h, x, y, size, text, [255, 255, 255, 255]);
-    img.px.par_chunks_mut(w * 4).zip(buf.par_chunks(w * 4)).for_each(|(d, s)| {
-        for (d, s) in d.chunks_exact_mut(4).zip(s.chunks_exact(4)) {
-            let a = s[3] as f32 / 255.0;
-            if a > 0.0 {
-                for k in 0..3 {
-                    d[k] = srgb_to_linear(s[k] as f32 / 255.0) * a + d[k] * (1.0 - a);
-                }
-                d[3] = a + d[3] * (1.0 - a);
-            }
-        }
-    });
-}
-
 /// Fill an opaque generated colour over the image at `op` opacity (Generate category).
 fn fill_over(img: &mut Image, op: f32, f: impl Fn(f32, f32) -> [f32; 3] + Sync) {
     let w = img.w;
diff --git a/crates/render/src/graphic_clip.rs b/crates/render/src/graphic_clip.rs
new file mode 100644
index 000000000..cdcdd61d0
--- /dev/null
+++ b/crates/render/src/graphic_clip.rs
@@ -0,0 +1,469 @@
+//! Graphic clips: text and shape layers drawn as vectors straight into the output (no resampling),
+//! with fill, up to two strokes (outer / centre / inner), a background box and a drop shadow.
+//! Each layer is rasterised into a tight premultiplied linear-light image that is cached while
+//! the layer and its transform stay the same.
+
+use std::collections::HashMap;
+use std::hash::{Hash, Hasher};
+use std::sync::{Arc, Mutex, OnceLock};
+
+use filmcraft_geom::{Affine, Vec2};
+use filmcraft_project::EffectInstance;
+use filmcraft_project::graphic::{LayerContent, LayerSpec, ShapeProps, TextProps, eval_layer};
+use filmcraft_text::raster::{Xform, apply, fill_into, xform_scale};
+use filmcraft_text::{Align, Caps, Layout, Mask, ParagraphStyle, StrokeKind, TextStyle, layout, mask, render};
+use filmcraft_time::Tick;
+use rayon::prelude::*;
+
+use crate::graphics::premul_linear;
+use crate::image::Image;
+
+/// f64 affine → the text crate's f32 transform.
+pub fn xform(a: &Affine) -> Xform {
+    [a.a as f32, a.b as f32, a.c as f32, a.d as f32, a.e as f32, a.f as f32]
+}
+
+/// Layer pixels → graphic canvas pixels (position / anchor / scale / rotation).
+pub fn layer_matrix(spec: &LayerSpec) -> Affine {
+    let t = &spec.transform;
+    Affine::motion(t.position, t.scale, t.rotation, t.anchor)
+}
+
+/// Text style + paragraph style of a text layer.
+pub fn text_styles(t: &TextProps) -> (TextStyle, ParagraphStyle) {
+    (
+        TextStyle {
+            family: if t.font.is_empty() { filmcraft_text::fonts::DEFAULT_FAMILY.into() } else { t.font.clone() },
+            style: if t.style.is_empty() { "Regular".into() } else { t.style.clone() },
+            size: t.size,
+            tracking: t.tracking,
+            kerning: t.kerning,
+            ligatures: t.ligatures,
+            baseline_shift: t.baseline_shift,
+            faux_bold: t.faux_bold,
+            faux_italic: t.faux_italic,
+            caps: match t.caps {
+                1 => Caps::All,
+                2 => Caps::Small,
+                _ => Caps::Normal,
+            },
+            underline: t.underline,
+        },
+        ParagraphStyle {
+            align: match t.align {
+                1 => Align::Center,
+                2 => Align::Right,
+                3 => Align::Justify,
+                _ => Align::Left,
+            },
+            leading: t.leading,
+            width: (t.box_width > 0.0).then_some(t.box_width),
+            rtl: None,
+        },
+    )
+}
+
+/// The laid-out text of a text layer (cached by the text engine).
+pub fn text_layout(t: &TextProps) -> Arc<Layout> {
+    let (st, ps) = text_styles(t);
+    layout(&t.text, &st, &ps)
+}
+
+/// A shape layer's outline in layer pixels (centred on the layer origin).
+pub fn shape_path(s: &ShapeProps) -> filmcraft_text::Path {
+    let (w, h) = (s.size.0 / 2.0, s.size.1 / 2.0);
+    match s.shape {
+        1 => filmcraft_text::Path::ellipse(0.0, 0.0, w, h),
+        2 => {
+            let n = s.sides.max(3);
+            let pts: Vec<(f32, f32)> = (0..n)
+                .map(|i| {
+                    let a = std::f32::consts::TAU * i as f32 / n as f32 - std::f32::consts::FRAC_PI_2;
+                    (a.cos() * w, a.sin() * h)
+                })
+                .collect();
+            filmcraft_text::Path::polygon(&pts)
+        }
+        3 if s.points.len() >= 3 => filmcraft_text::Path::polygon(&s.points.iter().map(|p| (p[0], p[1])).collect::<Vec<_>>()),
+        _ => filmcraft_text::Path::round_rect(-w, -h, w, h, s.corner_radius),
+    }
+}
+
+/// Content bounds `[x0, y0, x1, y1]` of a layer in layer pixels (text box or shape box).
+pub fn layer_local_bounds(spec: &LayerSpec) -> [f32; 4] {
+    match &spec.content {
+        LayerContent::Text(t) => text_layout(t).bounds,
+        LayerContent::Shape(s) => match shape_path(s).bounds() {
+            Some(b) => [b.0, b.1, b.2, b.3],
+            None => [0.0; 4],
+        },
+    }
+}
+
+/// The four corners of a layer's content box in graphic canvas pixels (selection boxes, hit
+/// testing, alignment), clockwise from the top-left.
+pub fn layer_quad(spec: &LayerSpec) -> [Vec2; 4] {
+    let b = layer_local_bounds(spec);
+    let m = layer_matrix(spec);
+    [Vec2::new(b[0] as f64, b[1] as f64), Vec2::new(b[2] as f64, b[1] as f64), Vec2::new(b[2] as f64, b[3] as f64), Vec2::new(b[0] as f64, b[3] as f64)]
+        .map(|p| m.apply(p))
+}
+
+/// A rendered layer: premultiplied linear RGBA at device position (`x`, `y`).
+#[derive(Debug)]
+pub struct LayerRaster {
+    pub x: i32,
+    pub y: i32,
+    pub img: Image,
+}
+
+fn stroke_kind(k: u32) -> StrokeKind {
+    match k {
+        1 => StrokeKind::Center,
+        2 => StrokeKind::Inner,
+        _ => StrokeKind::Outer,
+    }
+}
+
+fn bbox_of(m: &Xform, b: [f32; 4], pad: f32) -> [f32; 4] {
+    let pts = [(b[0] - pad, b[1] - pad), (b[2] + pad, b[1] - pad), (b[0] - pad, b[3] + pad), (b[2] + pad, b[3] + pad)];
+    let mut o = [f32::MAX, f32::MAX, f32::MIN, f32::MIN];
+    for (x, y) in pts {
+        let (a, c) = apply(m, x, y);
+        o = [o[0].min(a), o[1].min(c), o[2].max(a), o[3].max(c)];
+    }
+    o
+}
+
+fn union(a: [f32; 4], b: [f32; 4]) -> [f32; 4] {
+    [a[0].min(b[0]), a[1].min(b[1]), a[2].max(b[2]), a[3].max(b[3])]
+}
+
+/// Over-composite `c` (premultiplied) through `m` into `px` (premultiplied RGBA, same size).
+fn over_mask(px: &mut [f32], m: &Mask, c: [f32; 4]) {
+    if c[3] <= 0.0 || m.w == 0 {
+        return;
+    }
+    px.par_chunks_mut(4 * m.w).zip(m.a.par_chunks(m.w)).for_each(|(row, mrow)| {
+        for (p, &a) in row.chunks_exact_mut(4).zip(mrow) {
+            if a > 0.0 {
+                let k = 1.0 - c[3] * a;
+                for i in 0..4 {
+                    p[i] = c[i] * a + p[i] * k;
+                }
+            }
+        }
+    });
+}
+
+/// Rasterise one layer with layer→device transform `m`, clipped to a `cw`×`ch` canvas.
+pub fn raster_layer(spec: &LayerSpec, m: &Xform, cw: usize, ch: usize) -> Option<LayerRaster> {
+    if !spec.enabled || spec.transform.opacity <= 0.0 {
+        return None;
+    }
+    let s = xform_scale(m).max(1e-6);
+    let ap = &spec.appearance;
+    let text = match &spec.content {
+        LayerContent::Text(t) => {
+            let l = text_layout(t);
+            if l.glyphs.is_empty() && l.underlines.is_empty() && ap.background.is_none() {
+                return None;
+            }
+            Some(l)
+        }
+        LayerContent::Shape(_) => None,
+    };
+    let lb = match &text {
+        Some(l) => l.bounds,
+        None => layer_local_bounds(spec),
+    };
+    let shape = match &spec.content {
+        LayerContent::Shape(sh) => Some(shape_path(sh).transformed(m)),
+        _ => None,
+    };
+    let stroke_out = ap
+        .strokes
+        .iter()
+        .map(|(_, w, k)| {
+            if *k == 2 {
+                0.0
+            } else if *k == 1 {
+                w / 2.0
+            } else {
+                *w
+            }
+        })
+        .fold(0.0f32, f32::max);
+    let overhang = text.as_ref().map_or(0.0, |l| l.glyphs.iter().map(|g| g.size).fold(0.0f32, f32::max) * 0.35);
+    let mut bb = bbox_of(m, lb, overhang + stroke_out + 2.0 / s);
+    if let Some((_, pad, _)) = ap.background {
+        bb = union(bb, bbox_of(m, lb, pad + 1.0 / s));
+    }
+    let mut shadow_dev = (0.0f32, 0.0f32);
+    if let Some(sh) = &ap.shadow {
+        // the offset is in layer space, so it turns and scales with the layer
+        shadow_dev = (m[0] * sh.offset.0 + m[2] * sh.offset.1, m[1] * sh.offset.0 + m[3] * sh.offset.1);
+        let grow = (sh.size + sh.blur) * s + 2.0;
+        bb = union(bb, [bb[0] + shadow_dev.0 - grow, bb[1] + shadow_dev.1 - grow, bb[2] + shadow_dev.0 + grow, bb[3] + shadow_dev.1 + grow]);
+    }
+    // clip to the canvas, keeping enough margin for blur to read content just outside it
+    let margin = ap.shadow.as_ref().map_or(2.0, |sh| (sh.blur + sh.size) * s + shadow_dev.0.abs().max(shadow_dev.1.abs()) + 2.0);
+    let x0 = bb[0].floor().max(-margin) as i32;
+    let y0 = bb[1].floor().max(-margin) as i32;
+    let x1 = bb[2].ceil().min(cw as f32 + margin) as i32;
+    let y1 = bb[3].ceil().min(ch as f32 + margin) as i32;
+    if x1 <= x0 || y1 <= y0 || x1 <= 0 || y1 <= 0 || x0 >= cw as i32 || y0 >= ch as i32 {
+        return None;
+    }
+    let (w, h) = ((x1 - x0) as usize, (y1 - y0) as usize);
+    if w * h > 64 << 20 {
+        return None;
+    }
+    let mut cover = Mask::new(w, h);
+    if let Some(l) = &text {
+        render::draw(l, m, &mut cover, (x0, y0));
+    }
+    if let Some(p) = &shape {
+        fill_into(p, &mut cover, -x0 as f32, -y0 as f32);
+    }
+    let strokes: Vec<(Mask, [f32; 4])> = ap.strokes.iter().map(|(c, sw, k)| (mask::stroke(&cover, sw * s, stroke_kind(*k)), *c)).collect();
+    let bg = ap.background.map(|(c, pad, r)| {
+        let p = filmcraft_text::Path::round_rect(lb[0] - pad, lb[1] - pad, lb[2] + pad, lb[3] + pad, r).transformed(m);
+        let mut bm = Mask::new(w, h);
+        fill_into(&p, &mut bm, -x0 as f32, -y0 as f32);
+        (bm, c)
+    });
+    let mut px = vec![0.0f32; w * h * 4];
+    if let Some(sh) = &ap.shadow {
+        let mut u = if ap.fill.is_some() { cover.clone() } else { Mask::new(w, h) };
+        for (sm, _) in &strokes {
+            u.max_with(sm);
+        }
+        if let Some((bm, _)) = &bg {
+            u.max_with(bm);
+        }
+        if sh.size > 0.0 {
+            u = mask::stroke(&u, sh.size * s, StrokeKind::Outer);
+        }
+        let u = mask::offset(&u, shadow_dev.0.round() as i32, shadow_dev.1.round() as i32);
+        let u = mask::blur(&u, sh.blur * s / 3.0);
+        over_mask(&mut px, &u, premul_linear(sh.color));
+    }
+    if let Some((bm, c)) = &bg {
+        over_mask(&mut px, bm, premul_linear(*c));
+    }
+    // outer strokes sit under the fill; centre and inner strokes are drawn over it
+    let outer = |k: u32| k != 1 && k != 2;
+    for ((sm, c), (_, _, k)) in strokes.iter().zip(&ap.strokes).rev() {
+        if outer(*k) {
+            over_mask(&mut px, sm, premul_linear(*c));
+        }
+    }
+    if let Some(c) = ap.fill {
+        over_mask(&mut px, &cover, premul_linear(c));
+    }
+    for ((sm, c), (_, _, k)) in strokes.iter().zip(&ap.strokes).rev() {
+        if !outer(*k) {
+            over_mask(&mut px, sm, premul_linear(*c));
+        }
+    }
+    let op = spec.transform.opacity;
+    if op < 1.0 {
+        px.iter_mut().for_each(|v| *v *= op);
+    }
+    Some(LayerRaster { x: x0, y: y0, img: Image { w, h, px } })
+}
+
+type Cache = Mutex<HashMap<u64, (u64, Option<Arc<LayerRaster>>)>>;
+
+fn raster_cache() -> &'static Cache {
+    static C: OnceLock<Cache> = OnceLock::new();
+    C.get_or_init(Default::default)
+}
+
+/// [`raster_layer`] through a small cache (static titles re-composite without re-rasterising).
+pub fn raster_layer_cached(spec: &LayerSpec, m: &Xform, cw: usize, ch: usize) -> Option<Arc<LayerRaster>> {
+    let mut hs = std::collections::hash_map::DefaultHasher::new();
+    format!("{spec:?}").hash(&mut hs);
+    m.iter().for_each(|v| v.to_bits().hash(&mut hs));
+    (cw, ch).hash(&mut hs);
+    let key = hs.finish();
+    static CLOCK: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
+    let now = CLOCK.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+    if let Some(e) = raster_cache().lock().unwrap_or_else(|e| e.into_inner()).get_mut(&key) {
+        e.0 = now;
+        return e.1.clone();
+    }
+    let r = raster_layer(spec, m, cw, ch).map(Arc::new);
+    let mut c = raster_cache().lock().unwrap_or_else(|e| e.into_inner());
+    if c.len() >= 96
+        && let Some(k) = c.iter().min_by_key(|(_, v)| v.0).map(|(k, _)| *k)
+    {
+        c.remove(&k);
+    }
+    c.insert(key, (now, r.clone()));
+    r
+}
+
+/// Over-composite a raster at (`r.x` + `dx`, `r.y` + `dy`) onto `img`.
+pub fn composite_raster(img: &mut Image, r: &LayerRaster, dx: i32, dy: i32) {
+    let (rx, ry) = (r.x + dx, r.y + dy);
+    let (w, h) = (img.w as i32, img.h as i32);
+    let ys = ry.max(0)..(ry + r.img.h as i32).min(h);
+    let xs = rx.max(0)..(rx + r.img.w as i32).min(w);
+    if ys.is_empty() || xs.is_empty() {
+        return;
+    }
+    let iw = img.w;
+    img.px[ys.start as usize * iw * 4..ys.end as usize * iw * 4].par_chunks_mut(iw * 4).enumerate().for_each(|(row_i, row)| {
+        let sy = (ys.start + row_i as i32 - ry) as usize;
+        for x in xs.clone() {
+            let si = (sy * r.img.w + (x - rx) as usize) * 4;
+            let s = &r.img.px[si..si + 4];
+            if s[3] <= 0.0 {
+                continue;
+            }
+            let d = &mut row[x as usize * 4..x as usize * 4 + 4];
+            let k = 1.0 - s[3];
+            for c in 0..4 {
+                d[c] = s[c] + d[c] * k;
+            }
+        }
+    });
+}
+
+/// Evaluated layers of a graphic clip's effect list at clip time `t`, in paint order.
+pub fn graphic_specs(effects: &[EffectInstance], t: Tick, canvas: (u32, u32)) -> Vec<LayerSpec> {
+    effects.iter().filter(|e| filmcraft_project::graphic::is_layer(e)).filter_map(|e| eval_layer(e, t, canvas)).collect()
+}
+
+/// Draw all layers of a graphic clip onto `out`; `m` maps graphic canvas pixels to `out` pixels.
+pub fn render_graphic(effects: &[EffectInstance], t: Tick, canvas: (u32, u32), m: &Affine, out: &mut Image) {
+    for spec in graphic_specs(effects, t, canvas) {
+        let lm = xform(&m.then_apply(&layer_matrix(&spec)));
+        if let Some(r) = raster_layer_cached(&spec, &lm, out.w, out.h) {
+            composite_raster(out, &r, 0, 0);
+        }
+    }
+}
+
+/// All layers composed into one tight image (for the GPU plan): `(image, x, y)` in output pixels.
+pub fn render_graphic_tight(effects: &[EffectInstance], t: Tick, canvas: (u32, u32), m: &Affine, w: usize, h: usize) -> Option<(Image, i32, i32)> {
+    let rasters: Vec<Arc<LayerRaster>> =
+        graphic_specs(effects, t, canvas).iter().filter_map(|spec| raster_layer_cached(spec, &xform(&m.then_apply(&layer_matrix(spec))), w, h)).collect();
+    let x0 = rasters.iter().map(|r| r.x).min()?.max(0);
+    let y0 = rasters.iter().map(|r| r.y).min()?.max(0);
+    let x1 = rasters.iter().map(|r| r.x + r.img.w as i32).max()?.min(w as i32);
+    let y1 = rasters.iter().map(|r| r.y + r.img.h as i32).max()?.min(h as i32);
+    if x1 <= x0 || y1 <= y0 {
+        return None;
+    }
+    let mut img = Image::new((x1 - x0) as usize, (y1 - y0) as usize);
+    for r in &rasters {
+        composite_raster(&mut img, r, -x0, -y0);
+    }
+    Some((img, x0, y0))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use filmcraft_project::graphic::{new_shape_layer, new_text_layer};
+    use filmcraft_project::{ParamValue, find_effect};
+
+    fn set(e: &mut EffectInstance, k: &str, v: ParamValue) {
+        e.params.get_mut(k).unwrap_or_else(|| panic!("{k}")).value = v;
+    }
+
+    #[test]
+    fn text_layer_renders_white_text_at_position() {
+        let e = new_text_layer("HELLO", Vec2::new(100.0, 150.0), 60.0);
+        let mut img = Image::new(400, 200);
+        render_graphic(&[e], Tick::ZERO, (400, 200), &Affine::IDENTITY, &mut img);
+        let ink: Vec<(usize, usize)> = (0..200).flat_map(|y| (0..400).map(move |x| (x, y))).filter(|&(x, y)| img.get(x, y)[3] > 0.5).collect();
+        assert!(ink.len() > 500);
+        let minx = ink.iter().map(|p| p.0).min().unwrap();
+        let maxy = ink.iter().map(|p| p.1).max().unwrap();
+        assert!((98..=106).contains(&minx), "starts at the position: {minx}");
+        assert!((145..=152).contains(&maxy), "sits on the baseline: {maxy}");
+        assert!(img.get(ink[0].0, ink[0].1)[0] > 0.4, "white");
+    }
+
+    #[test]
+    fn shape_appearance_layers() {
+        let mut e = new_shape_layer(0, Vec2::new(100.0, 100.0), Vec2::new(80.0, 40.0), vec![]);
+        set(&mut e, "fill_color", ParamValue::Color([0.0, 0.0, 1.0, 1.0]));
+        set(&mut e, "stroke", ParamValue::Bool(true));
+        set(&mut e, "stroke_width", ParamValue::Float(6.0));
+        set(&mut e, "stroke_color", ParamValue::Color([1.0, 0.0, 0.0, 1.0]));
+        set(&mut e, "shadow", ParamValue::Bool(true));
+        set(&mut e, "shadow_distance", ParamValue::Float(20.0));
+        set(&mut e, "shadow_blur", ParamValue::Float(0.0));
+        let mut img = Image::new(200, 200);
+        render_graphic(&[e], Tick::ZERO, (200, 200), &Affine::IDENTITY, &mut img);
+        let p = img.get(100, 100);
+        assert!(p[2] > 0.9 && p[0] < 0.05, "blue fill {p:?}");
+        let s = img.get(100, 78);
+        assert!(s[0] > 0.9 && s[2] < 0.05, "red outer stroke above the box {s:?}");
+        // shadow: below-right of the box, outside the stroke
+        let sh = img.get(150, 135);
+        assert!(sh[3] > 0.5 && sh[0] < 0.05 && sh[2] < 0.05, "black shadow {sh:?}");
+        assert_eq!(img.get(20, 20)[3], 0.0);
+    }
+
+    #[test]
+    fn inner_and_centre_strokes() {
+        for (kind, inside, outside) in [(2u32, true, false), (1, true, true)] {
+            let mut e = new_shape_layer(2, Vec2::new(100.0, 100.0), Vec2::new(120.0, 120.0), vec![]);
+            set(&mut e, "sides", ParamValue::Float(4.0));
+            set(&mut e, "stroke", ParamValue::Bool(true));
+            set(&mut e, "stroke_width", ParamValue::Float(6.0));
+            set(&mut e, "stroke_type", ParamValue::Choice(kind));
+            set(&mut e, "stroke_color", ParamValue::Color([0.0, 1.0, 0.0, 1.0]));
+            let mut img = Image::new(200, 200);
+            render_graphic(&[e], Tick::ZERO, (200, 200), &Affine::IDENTITY, &mut img);
+            // diamond: top vertex at y = 40; probe straight below/above the right vertex (160, 100)
+            let green = |x: usize| {
+                let p = img.get(x, 100);
+                p[1] > 0.9 && p[0] < 0.1
+            };
+            assert_eq!(green(157), inside, "kind {kind} inside");
+            assert_eq!(green(161), outside, "kind {kind} outside");
+            assert!(!green(120), "fill in the middle");
+        }
+    }
+
+    #[test]
+    fn rotation_scale_and_opacity() {
+        let mut e = new_shape_layer(0, Vec2::new(100.0, 100.0), Vec2::new(100.0, 10.0), vec![]);
+        set(&mut e, "rotation", ParamValue::Float(90.0));
+        set(&mut e, "opacity", ParamValue::Float(50.0));
+        let mut img = Image::new(200, 200);
+        render_graphic(&[e.clone()], Tick::ZERO, (200, 200), &Affine::IDENTITY, &mut img);
+        assert!((img.get(100, 60)[3] - 0.5).abs() < 0.02, "vertical after 90°");
+        assert_eq!(img.get(60, 100)[3], 0.0);
+        // a 2× output transform (e.g. Motion scale) draws vectors crisply at the larger size
+        let mut big = Image::new(400, 400);
+        render_graphic(&[e], Tick::ZERO, (200, 200), &Affine::scale(2.0, 2.0), &mut big);
+        assert!((big.get(200, 110)[3] - 0.5).abs() < 0.02);
+        let q = layer_quad(&eval_layer(&find_effect("graphic_shape").unwrap().instance(), Tick::ZERO, (200, 200)).unwrap());
+        assert!((q[0].x - (100.0 - 200.0)).abs() < 1e-6 && (q[2].y - (100.0 + 100.0)).abs() < 1e-6);
+    }
+
+    #[test]
+    fn tight_image_matches_full_render() {
+        let a = new_text_layer("Tight", Vec2::new(50.0, 80.0), 40.0);
+        let b = new_shape_layer(1, Vec2::new(150.0, 120.0), Vec2::new(60.0, 60.0), vec![]);
+        let fx = vec![b, a];
+        let mut full = Image::new(220, 160);
+        render_graphic(&fx, Tick::ZERO, (220, 160), &Affine::IDENTITY, &mut full);
+        let (tight, x, y) = render_graphic_tight(&fx, Tick::ZERO, (220, 160), &Affine::IDENTITY, 220, 160).unwrap();
+        assert!(tight.w < 220 && tight.h < 160);
+        for yy in 0..tight.h {
+            for xx in 0..tight.w {
+                let (p, q) = (tight.get(xx, yy), full.get(xx + x as usize, yy + y as usize));
+                assert!((p[3] - q[3]).abs() < 1e-5);
+            }
+        }
+    }
+}
diff --git a/crates/render/src/graphics.rs b/crates/render/src/graphics.rs
new file mode 100644
index 000000000..3664aa01f
--- /dev/null
+++ b/crates/render/src/graphics.rs
@@ -0,0 +1,72 @@
+//! Text and vector graphics drawn with `filmcraft-text`: the Timecode / Clip Name burn-ins and
+//! (see below) graphic clips' text and shape layers.
+
+use filmcraft_color::srgb_to_linear;
+use filmcraft_geom::Vec2;
+use filmcraft_text::{Align, Mask, ParagraphStyle, TextStyle, layout, render};
+use rayon::prelude::*;
+
+use crate::image::Image;
+
+/// sRGB-encoded straight colour (0..1) → premultiplied linear.
+pub fn premul_linear(c: [f32; 4]) -> [f32; 4] {
+    let a = c[3].clamp(0.0, 1.0);
+    [srgb_to_linear(c[0]) * a, srgb_to_linear(c[1]) * a, srgb_to_linear(c[2]) * a, a]
+}
+
+/// Composite `color` (premultiplied linear) through coverage `m` placed at (`x0`, `y0`), scaled by
+/// `opacity`, over `img`.
+pub fn paint_mask(img: &mut Image, m: &Mask, x0: i32, y0: i32, color: [f32; 4], opacity: f32) {
+    if m.w == 0 || m.h == 0 || color[3] <= 0.0 || opacity <= 0.0 {
+        return;
+    }
+    let w = img.w;
+    let ys = y0.max(0) as usize..((y0 + m.h as i32).min(img.h as i32)).max(0) as usize;
+    if ys.is_empty() {
+        return;
+    }
+    let xs = x0.max(0)..(x0 + m.w as i32).min(w as i32);
+    if xs.is_empty() {
+        return;
+    }
+    let rows = &mut img.px[ys.start * w * 4..ys.end * w * 4];
+    rows.par_chunks_mut(w * 4).enumerate().for_each(|(ry, row)| {
+        let my = (ys.start + ry) as i32 - y0;
+        let mrow = &m.a[my as usize * m.w..(my as usize + 1) * m.w];
+        for x in xs.clone() {
+            let cov = mrow[(x - x0) as usize] * opacity;
+            if cov <= 0.0 {
+                continue;
+            }
+            let p = &mut row[x as usize * 4..x as usize * 4 + 4];
+            let k = 1.0 - color[3] * cov;
+            for c in 0..4 {
+                p[c] = color[c] * cov + p[c] * k;
+            }
+        }
+    });
+}
+
+/// Draw `text` centred on `pos` (layer pixels) at `px` pixels in white over a black box of
+/// `box_alpha` (the Timecode and Clip Name effects).
+pub fn burn_text(img: &mut Image, text: &str, family: &str, pos: Vec2, px: f32, box_alpha: f32) {
+    if text.is_empty() || pos.x.is_nan() {
+        return;
+    }
+    let st = TextStyle { family: family.into(), style: "Regular".into(), size: px, ..Default::default() };
+    let l = layout(text, &st, &ParagraphStyle { align: Align::Center, ..Default::default() });
+    let vm = filmcraft_text::fonts::face(filmcraft_text::resolve(family, "Regular").face).metrics(px);
+    // centre the cap height on pos
+    let (bx, by) = (pos.x as f32, pos.y as f32 + vm.cap_height / 2.0);
+    let pad = px * 0.25;
+    let b = l.bounds;
+    let boxp = filmcraft_text::Path::rect(bx + b[0] - pad, by - vm.cap_height - pad, bx + b[2] + pad, by + vm.descent * 0.6 + pad);
+    if let Some(bb) = boxp.bounds() {
+        let (x0, y0) = (bb.0.floor() as i32, bb.1.floor() as i32);
+        let m =
+            filmcraft_text::raster::fill(&boxp, (bb.2.ceil() as i32 - x0).max(1) as usize, (bb.3.ceil() as i32 - y0).max(1) as usize, -x0 as f32, -y0 as f32);
+        paint_mask(img, &m, x0, y0, [0.0, 0.0, 0.0, 1.0], box_alpha);
+    }
+    let (m, x0, y0) = render::rasterize(&l, &render::at(bx, by.round()));
+    paint_mask(img, &m, x0, y0, [1.0, 1.0, 1.0, 1.0], 1.0);
+}
diff --git a/crates/render/src/lib.rs b/crates/render/src/lib.rs
index 0c36a42d8..a0ab6060c 100644
--- a/crates/render/src/lib.rs
+++ b/crates/render/src/lib.rs
@@ -11,7 +11,10 @@ pub mod audio;
 pub mod audio_fx;
 pub mod blend;
 pub mod effects;
+pub mod graphic_clip;
+pub mod graphics;
 pub mod image;
+pub mod mixer;
 pub mod plan;
 pub mod preview;
 pub mod transitions;
@@ -172,7 +175,7 @@ pub(crate) fn source_size(project: &Project, item: ItemId) -> Option<(u32, u32)>
     match &project.item(item)?.kind {
         ItemKind::Media(m) => m.info.video.as_ref().map(|v| (v.width, v.height)),
         ItemKind::Sequence(s) => Some((s.settings.width, s.settings.height)),
-        ItemKind::AdjustmentLayer { width, height, .. } => Some((*width, *height)),
+        ItemKind::AdjustmentLayer { width, height, .. } | ItemKind::Graphic { width, height, .. } => Some((*width, *height)),
         ItemKind::Subclip { parent, .. } => source_size(project, *parent),
     }
 }
@@ -239,11 +242,26 @@ pub(crate) fn item_layer(
             render_seq(project, nested, mt, sub, sources)
         }
         ItemKind::AdjustmentLayer { .. } => return None,
+        ItemKind::Graphic { .. } => {
+            if !(opts.effects && item.has_standard_effects()) {
+                // vectors straight to the output: no resampling, crisp at any Motion scale
+                let m = Affine::scale(opts.scale as f64, opts.scale as f64).then_apply(&motion);
+                let mut canvas = Image::new(w, h);
+                graphic_clip::render_graphic(&item.effects, mt, src_size, &m, &mut canvas);
+                let (op, bl) = opacity_blend(item, mt);
+                return Some((canvas, op, bl));
+            }
+            // standard effects work on the graphic at source resolution, then Motion places it
+            let (gw, gh) = (((src_size.0 as f32 * want).ceil() as usize).max(1), ((src_size.1 as f32 * want).ceil() as usize).max(1));
+            let mut img = Image::new(gw, gh);
+            graphic_clip::render_graphic(&item.effects, mt, src_size, &Affine::scale(want as f64, want as f64), &mut img);
+            img
+        }
     };
     let px_scale = layer.w as f32 / src_size.0.max(1) as f32;
     if opts.effects {
         let cx = effects::FxCtx { t: mt, px_scale, seconds: (t - item.start).seconds(), timecode: tc, clip_name: &item.name };
-        for e in item.effects.iter().filter(|e| e.def().is_some_and(|d| !d.intrinsic)) {
+        for e in item.effects.iter().filter(|e| e.def().is_some_and(|d| !d.intrinsic) && !filmcraft_project::graphic::is_layer(e)) {
             if filmcraft_media::cancel::cancelled() {
                 return None;
             }
@@ -311,6 +329,10 @@ pub fn arc_source(s: impl filmcraft_media::MediaSource + 'static) -> SharedSourc
 #[cfg(test)]
 mod tests;
 
+#[cfg(test)]
+#[path = "mixer_tests.rs"]
+mod mixer_tests;
+
 #[cfg(test)]
 #[path = "preview_tests.rs"]
 mod preview_tests;
diff --git a/crates/render/src/mixer.rs b/crates/render/src/mixer.rs
new file mode 100644
index 000000000..e83e0be20
--- /dev/null
+++ b/crates/render/src/mixer.rs
@@ -0,0 +1,803 @@
+//! The audio mixer graph (Audio Track Mixer): tracks → submixes → Mix.
+//!
+//! Signal path of every strip, in Premiere's documented order:
+//!
+//! ```text
+//! track input (clips: gain → clip effects → clip Volume / Channel Volume / Panner, transitions)
+//!   → input map / mono fold → pre-fader inserts → pre-fader sends → mute → fader (volume)
+//!   → meter → post-fader inserts → post-fader sends → pan / balance → output (submix or Mix)
+//! submix: bus sum → the same strip path → output (Mix or a later submix)
+//! Mix:    bus sum → pre-fader inserts → fader → meter → post-fader inserts → out
+//! ```
+//!
+//! * **Sample accurate.** Automated lanes (volume, pan, mute, send levels) are evaluated per sample
+//!   from their keyframes; effect parameters update on an absolute 64-sample grid. The output does
+//!   not depend on how callers cut the timeline into requests.
+//! * **Latency compensated.** Inserts that report latency (look-ahead limiter, STFT effects) delay
+//!   their strip; every route into a bus gets a compensation delay so all inputs of a bus line up,
+//!   and the whole graph is read ahead by its total latency, so the output is aligned with the
+//!   timeline. Automation is evaluated at *content* time (input time minus the latency so far).
+//! * **Stateful and pull-based.** Graph state (insert DSP, compensation delays) is cached per graph
+//!   structure and keyed by the next sample it will produce. Sequential consumers (playback, export,
+//!   meters) continue it; any other request starts fresh with a pre-roll long enough for effect
+//!   tails and the graph latency.
+//! * **Solo.** When any strip is soloed, a strip stays audible if it is soloed or solo-safe, feeds
+//!   (directly or through submixes) a soloed or solo-safe strip, or is fed by one. Everything else
+//!   is solo-muted (silent, sends included). Track mute sits after the pre-fader sends, so
+//!   pre-fader sends of a muted track keep sending, as in Premiere.
+//! * **Pan law.** Mono tracks pan with the −3 dB constant-power law (centre = −3 dB per side);
+//!   stereo (and, for now, 5.1) tracks and sends use balance (centre = unity, the far side follows
+//!   the same constant-power curve normalised to the centre).
+//!
+//! [`LiveMix`] carries what the UI does while playing: control overrides while a fader is held
+//! (with Touch's ramp back to the automation), per-strip meters, and the newest project snapshot.
+
+use std::borrow::Cow;
+use std::collections::{HashMap, HashSet};
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex, OnceLock};
+
+use filmcraft_audio_dsp::AudioEffect;
+use filmcraft_frame::AudioBuffer;
+use filmcraft_project::mixer::{LANE_MUTE, LANE_PAN, LANE_VOLUME, fx_lane, send_lane};
+use filmcraft_project::{AudioChannels, EffectInstance, InputMap, Param, ParamValue, Project, Sequence, Track, TrackId};
+use filmcraft_time::Tick;
+use rayon::prelude::*;
+
+use crate::SourceProvider;
+use crate::audio::{pan_gains, track_input};
+use crate::audio_fx::{Mapping, mapping};
+
+/// Strip id of the Mix (master) track in [`LiveMix`] and commands.
+pub const MASTER: TrackId = filmcraft_project::mixer::MASTER_STRIP;
+/// Effect parameters update on this absolute sample grid.
+pub const PARAM_BLOCK: i64 = 64;
+/// Longest pre-roll for a fresh graph (seconds).
+const MAX_PREROLL_S: f64 = 3.0;
+
+// ------------------------------------------------------------------------------------- live state
+
+/// A control held (or just released) on the mixer while playing.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Override {
+    pub value: f64,
+    /// Released at `.0`; the value ramps back to the automation over `.1` (Touch).
+    pub release: Option<(Tick, Tick)>,
+}
+
+/// What the live mixer UI feeds into playback (and reads back from it).
+#[derive(Default)]
+pub struct LiveMix {
+    overrides: Mutex<HashMap<(TrackId, String), Override>>,
+    active: AtomicBool,
+    meters: Mutex<HashMap<TrackId, [f32; 2]>>,
+    project: Mutex<Option<Arc<Project>>>,
+}
+
+fn lock<T>(m: &Mutex<T>) -> std::sync::MutexGuard<'_, T> {
+    m.lock().unwrap_or_else(|e| e.into_inner())
+}
+
+impl LiveMix {
+    pub fn new() -> Self {
+        Self::default()
+    }
+    /// Hold a control at `value` (a fader or knob being touched/moved).
+    pub fn hold(&self, strip: TrackId, lane: &str, value: f64) {
+        lock(&self.overrides).insert((strip, lane.to_string()), Override { value, release: None });
+        self.active.store(true, Ordering::Release);
+    }
+    /// Release a held control at `at`: playback ramps from the held value back to the automation
+    /// over `ramp` (zero = jump back immediately).
+    pub fn release(&self, strip: TrackId, lane: &str, at: Tick, ramp: Tick) {
+        let mut g = lock(&self.overrides);
+        if ramp.0 <= 0 {
+            g.remove(&(strip, lane.to_string()));
+        } else if let Some(o) = g.get_mut(&(strip, lane.to_string())) {
+            o.release = Some((at, ramp));
+        }
+        self.active.store(!g.is_empty(), Ordering::Release);
+    }
+    pub fn clear(&self, strip: TrackId, lane: &str) {
+        let mut g = lock(&self.overrides);
+        g.remove(&(strip, lane.to_string()));
+        self.active.store(!g.is_empty(), Ordering::Release);
+    }
+    pub fn clear_all(&self) {
+        lock(&self.overrides).clear();
+        self.active.store(false, Ordering::Release);
+    }
+    /// Whether any control is overridden (rendered audio previews are bypassed then).
+    pub fn is_active(&self) -> bool {
+        self.active.load(Ordering::Acquire)
+    }
+    pub fn get(&self, strip: TrackId, lane: &str) -> Option<Override> {
+        lock(&self.overrides).get(&(strip, lane.to_string())).copied()
+    }
+    pub fn overrides(&self) -> HashMap<(TrackId, String), Override> {
+        lock(&self.overrides).clone()
+    }
+    /// Peak levels (linear, L/R, post-fader) per strip since the last call; [`MASTER`] is the Mix.
+    pub fn take_meters(&self) -> HashMap<TrackId, [f32; 2]> {
+        std::mem::take(&mut *lock(&self.meters))
+    }
+    fn post_meters(&self, m: &[(TrackId, [f32; 2])]) {
+        let mut g = lock(&self.meters);
+        for (id, p) in m {
+            let e = g.entry(*id).or_insert([0.0; 2]);
+            e[0] = e[0].max(p[0]);
+            e[1] = e[1].max(p[1]);
+        }
+    }
+    /// Publish the newest project snapshot (playback picks up edits made while it runs).
+    pub fn publish_project(&self, p: Arc<Project>) {
+        *lock(&self.project) = Some(p);
+    }
+    pub fn project(&self) -> Option<Arc<Project>> {
+        lock(&self.project).clone()
+    }
+}
+
+// ------------------------------------------------------------------------------------- pan laws
+
+/// −3 dB constant-power pan of a mono signal: (left, right) gains; centre = 0.7071 each.
+pub fn pan_law_mono(pan: f32) -> (f32, f32) {
+    let a = (pan.clamp(-1.0, 1.0) + 1.0) * std::f32::consts::FRAC_PI_4;
+    (a.cos(), a.sin())
+}
+
+/// Stereo balance (centre = unity). Same curve as the clip Panner.
+pub fn balance(pan: f32) -> (f32, f32) {
+    pan_gains(pan.clamp(-1.0, 1.0))
+}
+
+#[inline]
+fn db_gain(db: f64) -> f32 {
+    if db <= filmcraft_project::mixer::FADER_MIN_DB { 0.0 } else { 10f64.powf(db / 20.0) as f32 }
+}
+
+// ------------------------------------------------------------------------------------- lanes
+
+/// One automatable control of a strip, ready for per-sample evaluation.
+struct Lane<'a> {
+    param: Option<&'a Param>,
+    stat: f64,
+    ov: Option<Override>,
+    /// Switch lanes (mute) hold between keyframes whatever their interpolation.
+    hold: bool,
+}
+
+impl<'a> Lane<'a> {
+    fn new(track: &'a Track, strip: TrackId, key: &str, ovs: &HashMap<(TrackId, String), Override>) -> Self {
+        let reads = track.mixer.mode.reads();
+        let param = track.lane(key).filter(|p| reads && p.is_animated());
+        let hold = filmcraft_project::mixer::lane_info(key).is_some_and(|i| i.hold);
+        Lane { param, stat: track.lane_static(key).unwrap_or(0.0), ov: ovs.get(&(strip, key.to_string())).copied(), hold }
+    }
+    fn auto(&self, t: Tick) -> f64 {
+        match self.param {
+            None => self.stat,
+            Some(p) if self.hold => {
+                let i = p.keyframes.partition_point(|k| k.time <= t);
+                p.keyframes[i.saturating_sub(1)].value.as_f64().unwrap_or(0.0)
+            }
+            Some(p) => p.scalar_at(t),
+        }
+    }
+    /// The value when it is the same at every sample.
+    fn constant(&self) -> Option<f64> {
+        match self.ov {
+            Some(Override { value, release: None }) => Some(value),
+            Some(_) => None,
+            None => self.param.is_none().then_some(self.stat),
+        }
+    }
+    fn at(&self, t: Tick) -> f64 {
+        match self.ov {
+            None => self.auto(t),
+            Some(Override { value, release: None }) => value,
+            Some(Override { value, release: Some((r, d)) }) => {
+                if t < r {
+                    value
+                } else if t >= r + d {
+                    self.auto(t)
+                } else {
+                    let u = (t - r).0 as f64 / d.0.max(1) as f64;
+                    value + (self.auto(t) - value) * u
+                }
+            }
+        }
+    }
+    /// Per-sample values for content samples `c0 ..`, mapped through `f`, into `out`.
+    /// Returns the constant instead when the lane does not change.
+    fn fill(&self, c0: i64, sr: u32, out: &mut [f32], f: impl Fn(f64) -> f32) -> Option<f32> {
+        if let Some(v) = self.constant() {
+            return Some(f(v));
+        }
+        for (i, o) in out.iter_mut().enumerate() {
+            *o = f(self.at(Tick::from_units(c0 + i as i64, sr as i64)));
+        }
+        None
+    }
+}
+
+// ------------------------------------------------------------------------------------- plan
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+enum Kind {
+    Track,
+    Submix,
+    Master,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+enum Tap {
+    /// After the pre-fader inserts.
+    Pre,
+    /// After the post-fader inserts (before pan).
+    Post,
+    /// The strip output (after pan).
+    Out,
+}
+
+struct Insert<'a> {
+    slot: usize,
+    effect: Cow<'a, EffectInstance>,
+    map: Mapping,
+}
+
+struct Strip<'a> {
+    track: Cow<'a, Track>,
+    kind: Kind,
+    pre: Vec<Insert<'a>>,
+    post: Vec<Insert<'a>>,
+    /// Silent (solo-muted, or muted with nothing tapping before the mute).
+    silent: bool,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+struct RouteSpec {
+    src: usize,
+    tap: Tap,
+    /// Send index (sends), `None` for the main output.
+    send: Option<usize>,
+    target: usize,
+}
+
+struct Plan<'a> {
+    strips: Vec<Strip<'a>>,
+    routes: Vec<RouteSpec>,
+}
+
+fn inserts<'a>(track: &'a Track, post: bool) -> Vec<Insert<'a>> {
+    let reads = track.mixer.mode.reads();
+    track
+        .effects
+        .iter()
+        .enumerate()
+        .take(filmcraft_project::mixer::MAX_INSERTS)
+        .filter(|(_, e)| e.enabled && e.post_fader == post && !e.param("bypass").and_then(|p| p.value.as_bool()).unwrap_or(false))
+        .filter_map(|(slot, e)| mapping(&e.effect).map(|m| (slot, e, m)))
+        .map(|(slot, e, map)| {
+            let effect = if reads { Cow::Borrowed(e) } else { Cow::Owned(strip_keyframes(e)) };
+            Insert { slot, effect, map }
+        })
+        .collect()
+}
+
+fn strip_keyframes(e: &EffectInstance) -> EffectInstance {
+    let mut c = e.clone();
+    for p in c.params.values_mut() {
+        p.keyframes.clear();
+    }
+    c
+}
+
+impl<'a> Plan<'a> {
+    fn build(seq: &'a Sequence, ovs: &HashMap<(TrackId, String), Override>) -> Plan<'a> {
+        let mut strips: Vec<Strip<'a>> = Vec::new();
+        for t in &seq.audio_tracks {
+            strips.push(Strip { track: Cow::Borrowed(t), kind: Kind::Track, pre: inserts(t, false), post: inserts(t, true), silent: false });
+        }
+        for t in &seq.submix_tracks {
+            strips.push(Strip { track: Cow::Borrowed(t), kind: Kind::Submix, pre: inserts(t, false), post: inserts(t, true), silent: false });
+        }
+        let m = seq.master_strip();
+        strips.push(Strip { track: Cow::Owned(m), kind: Kind::Master, pre: Vec::new(), post: Vec::new(), silent: false });
+        let mi = strips.len() - 1;
+        // master inserts borrow from the sequence (same effects as the owned copy)
+        {
+            let reads = seq.master_mixer.mode.reads();
+            let mk = |post: bool| -> Vec<Insert<'a>> {
+                seq.master_effects
+                    .iter()
+                    .enumerate()
+                    .take(filmcraft_project::mixer::MAX_INSERTS)
+                    .filter(|(_, e)| e.enabled && e.post_fader == post)
+                    .filter_map(|(slot, e)| {
+                        mapping(&e.effect).map(|map| Insert { slot, effect: if reads { Cow::Borrowed(e) } else { Cow::Owned(strip_keyframes(e)) }, map })
+                    })
+                    .collect()
+            };
+            strips[mi].pre = mk(false);
+            strips[mi].post = mk(true);
+        }
+        // live overrides of effect parameters
+        for s in strips.iter_mut() {
+            let id = s.track.id;
+            for ins in s.pre.iter_mut().chain(s.post.iter_mut()) {
+                let slot = ins.slot;
+                let pids: Vec<String> = ins.effect.params.keys().cloned().collect();
+                for pid in pids {
+                    if let Some(o) = ovs.get(&(id, fx_lane(slot, &pid))) {
+                        let e = ins.effect.to_mut();
+                        if let Some(p) = e.param_mut(&pid) {
+                            p.value = ParamValue::Float(o.value);
+                            p.keyframes.clear();
+                        }
+                    }
+                }
+            }
+        }
+        // routes
+        let ntr = seq.audio_tracks.len();
+        let index_of = |id: TrackId| seq.submix_tracks.iter().position(|t| t.id == id).map(|i| ntr + i);
+        let mut routes = Vec::new();
+        for (si, s) in strips.iter().enumerate() {
+            if s.kind == Kind::Master {
+                continue;
+            }
+            // submixes may only feed submixes after them (no feedback)
+            let valid = |ti: usize| s.kind == Kind::Track || ti > si;
+            for (k, snd) in s.track.mixer.sends.iter().enumerate().take(filmcraft_project::mixer::MAX_SENDS) {
+                if let Some(ti) = index_of(snd.target).filter(|&ti| valid(ti)) {
+                    routes.push(RouteSpec { src: si, tap: if snd.pre_fader { Tap::Pre } else { Tap::Post }, send: Some(k), target: ti });
+                }
+            }
+            let target = s.track.mixer.output.and_then(index_of).filter(|&ti| valid(ti)).unwrap_or(mi);
+            routes.push(RouteSpec { src: si, tap: Tap::Out, send: None, target });
+        }
+        let mut plan = Plan { strips, routes };
+        plan.solo(ovs);
+        plan
+    }
+
+    /// Solo-mute and static-mute pruning.
+    fn solo(&mut self, ovs: &HashMap<(TrackId, String), Override>) {
+        let n = self.strips.len();
+        let soloed: Vec<usize> = (0..n).filter(|&i| self.strips[i].kind != Kind::Master && self.strips[i].track.solo).collect();
+        if !soloed.is_empty() {
+            let mut keep: HashSet<usize> = soloed.iter().copied().collect();
+            keep.extend((0..n).filter(|&i| self.strips[i].kind != Kind::Master && self.strips[i].track.mixer.solo_safe));
+            let seeds: Vec<usize> = keep.iter().copied().collect();
+            // downstream and upstream closures
+            for &s in &seeds {
+                let mut stack = vec![s];
+                while let Some(x) = stack.pop() {
+                    for r in self.routes.iter().filter(|r| r.src == x) {
+                        if keep.insert(r.target) {
+                            stack.push(r.target);
+                        }
+                    }
+                }
+                let mut stack = vec![s];
+                while let Some(x) = stack.pop() {
+                    for r in self.routes.iter().filter(|r| r.target == x) {
+                        if keep.insert(r.src) {
+                            stack.push(r.src);
+                        }
+                    }
+                }
+            }
+            for (i, s) in self.strips.iter_mut().enumerate() {
+                if s.kind != Kind::Master && !keep.contains(&i) {
+                    s.silent = true;
+                }
+            }
+        }
+        // statically muted with nothing before the mute that is heard: skip entirely
+        for (i, s) in self.strips.iter_mut().enumerate() {
+            let id = s.track.id;
+            let mute_static = Lane::new(&s.track, id, LANE_MUTE, ovs).constant().is_some_and(|m| m >= 0.5);
+            let pre_sends = self.routes.iter().any(|r| r.src == i && r.tap == Tap::Pre);
+            if s.kind != Kind::Master && mute_static && !pre_sends {
+                s.silent = true;
+            }
+        }
+    }
+
+    fn structure_hash(&self, sr: u32) -> u64 {
+        use std::hash::{Hash, Hasher};
+        let mut h = std::collections::hash_map::DefaultHasher::new();
+        sr.hash(&mut h);
+        for s in &self.strips {
+            s.track.id.hash(&mut h);
+            s.kind.hash(&mut h);
+            for (side, v) in [(0u8, &s.pre), (1u8, &s.post)] {
+                for i in v.iter() {
+                    (side, i.slot, &i.effect.effect, i.map.dsp).hash(&mut h);
+                }
+            }
+        }
+        self.routes.hash(&mut h);
+        h.finish()
+    }
+
+    /// Longest pre-roll the inserts need for a fresh graph (samples).
+    fn preroll(&self, t: Tick, sr: u32) -> usize {
+        let s = self.strips.iter().flat_map(|s| s.pre.iter().chain(&s.post)).map(|i| (i.map.preroll)(&i.effect, t)).fold(0.0, f64::max);
+        (s.min(MAX_PREROLL_S) * sr as f64).ceil() as usize
+    }
+}
+
+// ------------------------------------------------------------------------------------- state
+
+struct DelayLine {
+    buf: Vec<[f32; 2]>,
+    pos: usize,
+}
+
+impl DelayLine {
+    fn new(len: usize) -> Self {
+        DelayLine { buf: vec![[0.0; 2]; len], pos: 0 }
+    }
+    /// Delay `x` in place.
+    fn run(&mut self, x: &mut [Vec<f32>; 2]) {
+        if self.buf.is_empty() {
+            return;
+        }
+        let n = self.buf.len();
+        for i in 0..x[0].len() {
+            let out = self.buf[self.pos];
+            self.buf[self.pos] = [x[0][i], x[1][i]];
+            x[0][i] = out[0];
+            x[1][i] = out[1];
+            self.pos = (self.pos + 1) % n;
+        }
+    }
+    fn clear(&mut self) {
+        self.buf.fill([0.0; 2]);
+    }
+}
+
+struct StripState {
+    pre: Vec<Box<dyn AudioEffect>>,
+    post: Vec<Box<dyn AudioEffect>>,
+    lat_pre: usize,
+    lat_post: usize,
+    /// Latency of the strip's input (bus alignment).
+    in_lat: usize,
+    /// Compensation delay per outgoing route (same order as the plan's routes from this strip).
+    delays: Vec<DelayLine>,
+}
+
+struct GraphState {
+    next_out: i64,
+    strips: Vec<StripState>,
+    latency: usize,
+}
+
+fn build_state(plan: &Plan, sr: u32) -> GraphState {
+    let mk = |v: &[Insert]| -> Vec<Box<dyn AudioEffect>> { v.iter().filter_map(|i| filmcraft_audio_dsp::create_effect(i.map.dsp, sr as f32, 2)).collect() };
+    let mut strips: Vec<StripState> = plan
+        .strips
+        .iter()
+        .map(|s| {
+            let pre = mk(&s.pre);
+            let post = mk(&s.post);
+            let lat_pre = pre.iter().map(|d| d.latency()).sum();
+            let lat_post = post.iter().map(|d| d.latency()).sum();
+            StripState { pre, post, lat_pre, lat_post, in_lat: 0, delays: Vec::new() }
+        })
+        .collect();
+    let tap_lat = |s: &StripState, tap: Tap| s.in_lat + if tap == Tap::Pre { s.lat_pre } else { s.lat_pre + s.lat_post };
+    // strips are in topological order (routes only go forward)
+    for i in 0..strips.len() {
+        let in_lat = plan.routes.iter().filter(|r| r.target == i).map(|r| tap_lat(&strips[r.src], r.tap)).max().unwrap_or(0);
+        strips[i].in_lat = in_lat;
+    }
+    for r in &plan.routes {
+        let d = strips[r.target].in_lat - tap_lat(&strips[r.src], r.tap);
+        strips[r.src].delays.push(DelayLine::new(d));
+    }
+    let m = strips.len() - 1;
+    let latency = strips[m].in_lat + strips[m].lat_pre + strips[m].lat_post;
+    GraphState { next_out: 0, strips, latency }
+}
+
+fn cache() -> &'static Mutex<HashMap<u64, Vec<GraphState>>> {
+    static C: OnceLock<Mutex<HashMap<u64, Vec<GraphState>>>> = OnceLock::new();
+    C.get_or_init(Default::default)
+}
+
+/// Total latency (samples) of the sequence's mixer graph: how far ahead of the timeline the graph
+/// is read so its output lines up.
+pub fn graph_latency(seq: &Sequence) -> usize {
+    let plan = Plan::build(seq, &HashMap::new());
+    build_state(&plan, seq.settings.sample_rate).latency
+}
+
+// ------------------------------------------------------------------------------------- processing
+
+type Stereo = [Vec<f32>; 2];
+
+fn silent(n: usize) -> Stereo {
+    [vec![0.0; n], vec![0.0; n]]
+}
+
+/// Run `chain` over `buf` (input-time samples from `x0`) with parameters at content time
+/// `x - lat` updated on the absolute [`PARAM_BLOCK`] grid.
+fn run_inserts(chain: &mut [Box<dyn AudioEffect>], ins: &[Insert], buf: &mut Stereo, x0: i64, lat: usize, sr: u32) {
+    if chain.is_empty() {
+        return;
+    }
+    let n = buf[0].len();
+    let mut i = 0usize;
+    while i < n {
+        let pos = x0 + i as i64;
+        let end = (((pos.div_euclid(PARAM_BLOCK) + 1) * PARAM_BLOCK - x0) as usize).min(n);
+        // parameters of the whole grid block (also when a request starts mid-block)
+        let t = Tick::from_units(pos.div_euclid(PARAM_BLOCK) * PARAM_BLOCK - lat as i64, sr as i64);
+        for (d, e) in chain.iter_mut().zip(ins) {
+            (e.map.apply)(d.as_mut(), &e.effect, t);
+        }
+        let [l, r] = buf;
+        let mut ch: [&mut [f32]; 2] = [&mut l[i..end], &mut r[i..end]];
+        for d in chain.iter_mut() {
+            d.process(&mut ch);
+        }
+        i = end;
+    }
+}
+
+/// Multiply by a per-sample (or constant) gain pair.
+fn apply_gain(buf: &mut Stereo, g: Option<f32>, per: &[f32]) {
+    match g {
+        Some(1.0) => {}
+        Some(g) => {
+            for c in buf.iter_mut() {
+                for s in c.iter_mut() {
+                    *s *= g;
+                }
+            }
+        }
+        None => {
+            for c in buf.iter_mut() {
+                for (s, g) in c.iter_mut().zip(per) {
+                    *s *= g;
+                }
+            }
+        }
+    }
+}
+
+/// Apply a pan/balance lane (values −100 … 100) with `law`.
+fn apply_pan(buf: &mut Stereo, lane: &Lane, c0: i64, sr: u32, law: fn(f32) -> (f32, f32), scratch: &mut [f32]) {
+    match lane.fill(c0, sr, scratch, |v| v as f32) {
+        Some(p) => {
+            let (gl, gr) = law(p / 100.0);
+            if gl != 1.0 || gr != 1.0 {
+                buf[0].iter_mut().for_each(|s| *s *= gl);
+                buf[1].iter_mut().for_each(|s| *s *= gr);
+            }
+        }
+        None => {
+            for (i, p) in scratch.iter().enumerate() {
+                let (gl, gr) = law(p / 100.0);
+                buf[0][i] *= gl;
+                buf[1][i] *= gr;
+            }
+        }
+    }
+}
+
+struct StripOut {
+    /// (route index in the plan, delayed signal)
+    routes: Vec<(usize, Stereo)>,
+    meter: [f32; 2],
+    /// Final signal (Mix only).
+    out: Option<Stereo>,
+}
+
+#[allow(clippy::too_many_arguments)]
+fn run_strip(
+    plan: &Plan,
+    si: usize,
+    st: &mut StripState,
+    mut buf: Stereo,
+    x0: i64,
+    skip: usize,
+    sr: u32,
+    ovs: &HashMap<(TrackId, String), Override>,
+) -> StripOut {
+    let s = &plan.strips[si];
+    let tr: &Track = &s.track;
+    let id = tr.id;
+    let n = buf[0].len();
+    let my_routes: Vec<(usize, &RouteSpec)> = plan.routes.iter().enumerate().filter(|(_, r)| r.src == si).collect();
+    let mut outs: Vec<(usize, Stereo)> = Vec::new();
+    let mut scratch = vec![0f32; n];
+    // input map / mono fold (tracks)
+    let mono = tr.channels == AudioChannels::Mono;
+    if s.kind != Kind::Master {
+        let [l, r] = &mut buf;
+        match tr.mixer.input_map {
+            InputMap::Stereo => {}
+            InputMap::Left => r.copy_from_slice(l),
+            InputMap::Right => l.copy_from_slice(r),
+            InputMap::Swap => std::mem::swap(l, r),
+            InputMap::Mono => {
+                for (a, b) in l.iter_mut().zip(r.iter_mut()) {
+                    let m = (*a + *b) * 0.5;
+                    *a = m;
+                    *b = m;
+                }
+            }
+        }
+        if mono && tr.mixer.input_map != InputMap::Mono {
+            for (a, b) in l.iter_mut().zip(r.iter_mut()) {
+                let m = (*a + *b) * 0.5;
+                *a = m;
+                *b = m;
+            }
+        }
+    }
+    let lat_a = st.in_lat;
+    run_inserts(&mut st.pre, &s.pre, &mut buf, x0, lat_a, sr);
+    let lat_b = st.in_lat + st.lat_pre;
+    let c_b = x0 - lat_b as i64;
+    let send = |tap: Tap, buf: &Stereo, c0: i64, scratch: &mut [f32], st: &mut StripState, outs: &mut Vec<(usize, Stereo)>| {
+        for (k, (ri, r)) in my_routes.iter().enumerate() {
+            if r.tap != tap {
+                continue;
+            }
+            let mut sig = buf.clone();
+            if let Some(si) = r.send {
+                let snd = &tr.mixer.sends[si];
+                if snd.muted {
+                    sig = silent(n);
+                } else {
+                    let lane = Lane::new(tr, id, &send_lane(si), ovs);
+                    let g = lane.fill(c0, sr, scratch, db_gain);
+                    apply_gain(&mut sig, g, scratch);
+                    let (gl, gr) = balance((snd.pan / 100.0) as f32);
+                    if gl != 1.0 || gr != 1.0 {
+                        sig[0].iter_mut().for_each(|x| *x *= gl);
+                        sig[1].iter_mut().for_each(|x| *x *= gr);
+                    }
+                }
+            }
+            st.delays[k].run(&mut sig);
+            outs.push((*ri, sig));
+        }
+    };
+    send(Tap::Pre, &buf, c_b, &mut scratch, st, &mut outs);
+    // mute → fader
+    let mute = Lane::new(tr, id, LANE_MUTE, ovs);
+    match mute.fill(c_b, sr, &mut scratch, |m| if m >= 0.5 { 0.0 } else { 1.0 }) {
+        Some(g) => apply_gain(&mut buf, Some(g), &[]),
+        None => apply_gain(&mut buf, None, &scratch),
+    }
+    let vol = Lane::new(tr, id, LANE_VOLUME, ovs);
+    let g = vol.fill(c_b, sr, &mut scratch, db_gain);
+    apply_gain(&mut buf, g, &scratch);
+    let mut meter = [0f32; 2];
+    for (c, m) in meter.iter_mut().enumerate() {
+        *m = buf[c][skip.min(n)..].iter().fold(0f32, |a, x| a.max(x.abs()));
+    }
+    run_inserts(&mut st.post, &s.post, &mut buf, x0, lat_b, sr);
+    let lat_c = lat_b + st.lat_post;
+    let c_c = x0 - lat_c as i64;
+    send(Tap::Post, &buf, c_c, &mut scratch, st, &mut outs);
+    if s.kind == Kind::Master {
+        return StripOut { routes: outs, meter, out: Some(buf) };
+    }
+    let pan = Lane::new(tr, id, LANE_PAN, ovs);
+    apply_pan(&mut buf, &pan, c_c, sr, if mono { pan_law_mono } else { balance }, &mut scratch);
+    send(Tap::Out, &buf, c_c, &mut scratch, st, &mut outs);
+    StripOut { routes: outs, meter, out: None }
+}
+
+/// Mix `frames` stereo samples of the sequence starting at sample `start` through the mixer graph.
+/// `live` adds the UI's held controls and receives the meters.
+pub fn mix_graph(project: &Project, seq: &Sequence, start: i64, frames: usize, sources: &dyn SourceProvider, live: Option<&LiveMix>) -> AudioBuffer {
+    let sr = seq.settings.sample_rate.max(1);
+    let ovs = live.filter(|l| l.is_active()).map(LiveMix::overrides).unwrap_or_default();
+    let plan = Plan::build(seq, &ovs);
+    let key = plan.structure_hash(sr);
+    let taken = {
+        let mut c = lock(cache());
+        c.get_mut(&key).and_then(|v| v.iter().position(|g| g.next_out == start).map(|i| v.swap_remove(i)))
+    };
+    let (mut st, skip) = match taken {
+        Some(st) => (st, 0usize),
+        None => {
+            let st = build_state(&plan, sr);
+            let pre = plan.preroll(Tick::from_units(start, sr as i64), sr).max(st.latency);
+            (st, pre)
+        }
+    };
+    let lat = st.latency as i64;
+    let x0 = start + lat - skip as i64;
+    let total = skip + frames;
+    let ns = plan.strips.len();
+    let mut bus: Vec<Option<Stereo>> = (0..ns).map(|_| None).collect();
+    let mut meters: Vec<(TrackId, [f32; 2])> = Vec::new();
+    let range = filmcraft_time::TimeRange::from_bounds(Tick::from_units(x0, sr as i64), Tick::from_units(x0 + total as i64, sr as i64));
+    // tracks: independent, in parallel
+    let ntr = plan.strips.iter().take_while(|s| s.kind == Kind::Track).count();
+    let (track_states, rest) = st.strips.split_at_mut(ntr);
+    let track_outs: Vec<Option<StripOut>> = track_states
+        .par_iter_mut()
+        .enumerate()
+        .map(|(si, ss)| {
+            let s = &plan.strips[si];
+            if s.silent {
+                ss.delays.iter_mut().for_each(DelayLine::clear);
+                return None;
+            }
+            let has_clips = s.track.items.iter().any(|i| i.enabled && i.range().overlaps(&range));
+            if !has_clips && s.pre.is_empty() && s.post.is_empty() && ss.delays.iter().all(|d| d.buf.is_empty()) {
+                return None;
+            }
+            let input = if has_clips {
+                let b = track_input(project, &s.track, x0, total, sr, sources);
+                let mut it = b.channels.into_iter();
+                [it.next().unwrap_or_else(|| vec![0.0; total]), it.next().unwrap_or_else(|| vec![0.0; total])]
+            } else {
+                silent(total)
+            };
+            Some(run_strip(&plan, si, ss, input, x0, skip, sr, &ovs))
+        })
+        .collect();
+    let deliver = |o: StripOut, si: usize, bus: &mut Vec<Option<Stereo>>, meters: &mut Vec<(TrackId, [f32; 2])>| {
+        meters.push((plan.strips[si].track.id, o.meter));
+        for (ri, sig) in o.routes {
+            let t = plan.routes[ri].target;
+            let b = bus[t].get_or_insert_with(|| silent(total));
+            for c in 0..2 {
+                for (d, s) in b[c].iter_mut().zip(&sig[c]) {
+                    *d += *s;
+                }
+            }
+        }
+        o.out
+    };
+    for (si, o) in track_outs.into_iter().enumerate() {
+        if let Some(o) = o {
+            deliver(o, si, &mut bus, &mut meters);
+        }
+    }
+    // submixes in order, then the Mix
+    let mut out = silent(total);
+    for (k, ss) in rest.iter_mut().enumerate() {
+        let si = ntr + k;
+        let s = &plan.strips[si];
+        if s.silent {
+            ss.delays.iter_mut().for_each(DelayLine::clear);
+            continue;
+        }
+        let input = bus[si].take().unwrap_or_else(|| silent(total));
+        let o = run_strip(&plan, si, ss, input, x0, skip, sr, &ovs);
+        if let Some(fin) = deliver(o, si, &mut bus, &mut meters) {
+            out = fin;
+        }
+    }
+    st.next_out = start + frames as i64;
+    {
+        let mut c = lock(cache());
+        let v = c.entry(key).or_default();
+        v.push(st);
+        if v.len() > 4 {
+            v.remove(0);
+        }
+        if c.len() > 64 {
+            c.clear();
+        }
+    }
+    if let Some(l) = live {
+        l.post_meters(&meters);
+    }
+    let [l, r] = out;
+    AudioBuffer { sample_rate: sr, channels: vec![l[skip..].to_vec(), r[skip..].to_vec()] }
+}
diff --git a/crates/render/src/mixer_tests.rs b/crates/render/src/mixer_tests.rs
new file mode 100644
index 000000000..154b98298
--- /dev/null
+++ b/crates/render/src/mixer_tests.rs
@@ -0,0 +1,453 @@
+//! Mixer graph tests: gain and pan laws, automation, solo/mute, sends, latency, identity, speed.
+
+use std::sync::Arc;
+
+use filmcraft_frame::{AudioBuffer, VideoFrame};
+use filmcraft_media::{AudioStreamInfo, FrameRequest, MediaError, MediaInfo, MediaKind, MediaSource};
+use filmcraft_project::mixer::{LANE_MUTE, LANE_PAN, LANE_VOLUME, send_lane};
+use filmcraft_project::{
+    AudioChannels, AutomationMode, ItemId, ItemKind, Keyframe, Label, MediaClip, MediaRef, ParamValue, Project, SequenceSettings, Track, TrackId, TrackKind,
+    TrackSend,
+};
+use filmcraft_time::{FrameRate, TICKS_PER_SECOND, Tick, TimeRange};
+
+use crate::SourceMap;
+use crate::mixer::{LiveMix, balance, graph_latency, mix_graph, pan_law_mono};
+
+const SR: i64 = 48_000;
+
+/// A synthetic stereo source: `f(sample, channel)`.
+struct FnSource {
+    info: MediaInfo,
+    f: fn(i64, usize) -> f32,
+}
+
+impl MediaSource for FnSource {
+    fn info(&self) -> &MediaInfo {
+        &self.info
+    }
+    fn video_frame(&self, _: FrameRequest) -> filmcraft_media::Result<Arc<VideoFrame>> {
+        Err(MediaError::Unsupported("audio only".into()))
+    }
+    fn audio(&self, start: i64, frames: usize, sample_rate: u32) -> filmcraft_media::Result<AudioBuffer> {
+        let f = self.f;
+        Ok(AudioBuffer { sample_rate, channels: (0..2).map(|c| (0..frames).map(|i| f(start + i as i64, c)).collect()).collect() })
+    }
+}
+
+struct Rig {
+    p: Project,
+    seq: ItemId,
+    map: SourceMap,
+}
+
+impl Rig {
+    /// A sequence with `n` audio tracks, each holding one 10 s clip of its signal.
+    fn new(signals: &[fn(i64, usize) -> f32]) -> Rig {
+        let mut p = Project::new("mix");
+        let seq = p.new_sequence("s", SequenceSettings::default(), 0, signals.len(), None);
+        let mut map = SourceMap::default();
+        for (k, f) in signals.iter().enumerate() {
+            let info = MediaInfo {
+                name: format!("sig{k}"),
+                kind: MediaKind::AudioOnly,
+                duration: Tick(10 * TICKS_PER_SECOND),
+                video: None,
+                audio: Some(AudioStreamInfo { sample_rate: 48_000, channels: 2, codec: "test".into(), bits_per_sample: Some(32) }),
+                container: "test".into(),
+                start_timecode: None,
+                file_size: None,
+            };
+            let id = p.add_item(
+                &info.name.clone(),
+                Label::Iris,
+                ItemKind::Media(MediaClip {
+                    media: MediaRef::File { path: format!("/sig{k}.wav") },
+                    info: info.clone(),
+                    interpret: Default::default(),
+                    mark_in: None,
+                    mark_out: None,
+                    markers: vec![],
+                    offline: false,
+                    proxy: None,
+                }),
+                None,
+            );
+            map.0.insert(id, Arc::new(FnSource { info, f: *f }));
+            let ti = p.make_track_item(id, TrackKind::Audio, Tick::ZERO, TimeRange::new(Tick::ZERO, Tick(10 * TICKS_PER_SECOND)), FrameRate::FPS_24).unwrap();
+            p.sequence_mut(seq).unwrap().audio_tracks[k].items.push(ti);
+        }
+        Rig { p, seq, map }
+    }
+    fn track(&mut self, k: usize) -> &mut Track {
+        &mut self.p.sequence_mut(self.seq).unwrap().audio_tracks[k]
+    }
+    fn add_submix(&mut self, name: &str) -> TrackId {
+        let id = TrackId(self.p.alloc_id());
+        self.p.sequence_mut(self.seq).unwrap().submix_tracks.push(Track::new(id, TrackKind::Audio, name.into()));
+        id
+    }
+    fn submix(&mut self, id: TrackId) -> &mut Track {
+        self.p.sequence_mut(self.seq).unwrap().mix_track_mut(id).unwrap()
+    }
+    fn mix(&self, start: i64, n: usize) -> [Vec<f32>; 2] {
+        let b = mix_graph(&self.p, self.p.sequence(self.seq).unwrap(), start, n, &self.map, None);
+        [b.channels[0].clone(), b.channels[1].clone()]
+    }
+    /// Mix `[start, start + n)` in consecutive requests of the given sizes (cycled).
+    fn mix_cut(&self, start: i64, n: usize, sizes: &[usize], live: Option<&LiveMix>) -> [Vec<f32>; 2] {
+        let mut out = [Vec::new(), Vec::new()];
+        let (mut pos, mut k) = (start, 0);
+        while pos < start + n as i64 {
+            let m = sizes[k % sizes.len()].min((start + n as i64 - pos) as usize);
+            let b = mix_graph(&self.p, self.p.sequence(self.seq).unwrap(), pos, m, &self.map, live);
+            out[0].extend_from_slice(&b.channels[0]);
+            out[1].extend_from_slice(&b.channels[1]);
+            pos += m as i64;
+            k += 1;
+        }
+        out
+    }
+}
+
+fn dc(_: i64, _: usize) -> f32 {
+    0.5
+}
+
+fn kf(t_samples: i64, v: f64) -> Keyframe {
+    Keyframe::new(Tick::from_units(t_samples, SR), ParamValue::Float(v))
+}
+
+fn close(a: f32, b: f32, tol: f32) -> bool {
+    (a - b).abs() <= tol
+}
+
+#[test]
+fn fader_gain_is_sample_exact() {
+    let mut r = Rig::new(&[dc]);
+    r.track(0).volume_db = -6.0;
+    let [l, rr] = r.mix(1000, 256);
+    let g = 0.5 * 10f32.powf(-6.0 / 20.0);
+    assert!(l.iter().chain(&rr).all(|&s| close(s, g, 1e-6)), "{} vs {g}", l[0]);
+    // −∞ silences; +15 dB is the top of the fader
+    r.track(0).volume_db = -96.0;
+    assert!(r.mix(0, 64)[0].iter().all(|&s| s == 0.0));
+    r.track(0).volume_db = 15.0;
+    assert!(close(r.mix(0, 64)[0][10], 0.5 * 10f32.powf(0.75), 1e-5));
+    // Mix fader multiplies on top
+    r.track(0).volume_db = -6.0;
+    r.p.sequence_mut(r.seq).unwrap().master_volume_db = -6.0;
+    assert!(close(r.mix(0, 64)[0][3], 0.5 * 10f32.powf(-12.0 / 20.0), 1e-6));
+}
+
+#[test]
+fn pan_laws() {
+    // mono track: −3 dB constant power (centre 0.7071 per side, power constant across the arc)
+    for p in [-100.0, -50.0, 0.0, 25.0, 100.0] {
+        let (l, r) = pan_law_mono((p / 100.0) as f32);
+        assert!(close(l * l + r * r, 1.0, 1e-6), "power at {p}");
+    }
+    let (l, r) = pan_law_mono(0.0);
+    assert!(close(20.0 * l.log10(), -3.0103, 1e-3) && close(l, r, 1e-7));
+    let mut rig = Rig::new(&[dc]);
+    rig.track(0).channels = AudioChannels::Mono;
+    rig.track(0).pan = 50.0;
+    let [l, r] = rig.mix(0, 128);
+    let a = 1.5 * std::f32::consts::FRAC_PI_4;
+    assert!(close(l[64], 0.5 * a.cos(), 1e-6) && close(r[64], 0.5 * a.sin(), 1e-6), "{} {}", l[64], r[64]);
+    rig.track(0).pan = -100.0;
+    let [l, r] = rig.mix(0, 128);
+    assert!(close(l[1], 0.5, 1e-6) && r[1].abs() < 1e-6);
+    // stereo track: balance (centre unity, far side attenuated)
+    rig.track(0).channels = AudioChannels::Stereo;
+    rig.track(0).pan = 0.0;
+    let [l, r] = rig.mix(0, 64);
+    assert!(close(l[5], 0.5, 1e-7) && close(r[5], 0.5, 1e-7));
+    rig.track(0).pan = 50.0;
+    let (bl, br) = balance(0.5);
+    let [l, r] = rig.mix(0, 64);
+    assert!(close(l[5], 0.5 * bl, 1e-6) && close(r[5], 0.5 * br, 1e-6) && br == 1.0 && bl < 0.6);
+}
+
+#[test]
+fn volume_automation_is_sample_accurate_and_block_invariant() {
+    let mut r = Rig::new(&[dc]);
+    {
+        let t = r.track(0);
+        let lane = t.lane_mut(LANE_VOLUME).unwrap();
+        lane.keyframes = vec![kf(0, 0.0), kf(1000, -20.0), kf(1500, -20.0), kf(1600, 0.0)];
+    }
+    let whole = r.mix(0, 2000);
+    for k in [0usize, 1, 63, 64, 65, 127, 128, 500, 999, 1000, 1500, 1550, 1599, 1600] {
+        let db = if k <= 1000 {
+            -20.0 * k as f64 / 1000.0
+        } else if k <= 1500 {
+            -20.0
+        } else if k <= 1600 {
+            -20.0 + 20.0 * (k - 1500) as f64 / 100.0
+        } else {
+            0.0
+        };
+        let want = 0.5 * 10f64.powf(db / 20.0);
+        assert!((whole[0][k] as f64 - want).abs() < 1e-6, "sample {k}: {} vs {want}", whole[0][k]);
+    }
+    // the same range cut into odd-sized requests is bit-identical
+    for sizes in [&[1usize, 63, 64, 65][..], &[333], &[7, 1024, 5]] {
+        let cut = r.mix_cut(0, 2000, sizes, None);
+        assert_eq!(cut, whole, "cut {sizes:?}");
+    }
+    // Off mode ignores the automation
+    r.track(0).mixer.mode = AutomationMode::Off;
+    assert!(close(r.mix(1200, 16)[0][0], 0.5, 1e-7));
+}
+
+#[test]
+fn effect_and_pan_automation_on_the_block_grid() {
+    let mut r = Rig::new(&[dc]);
+    {
+        let t = r.track(0);
+        let mut amp = filmcraft_project::find_effect("amplify").unwrap().instance();
+        let g = amp.param_mut("gain").unwrap();
+        g.keyframes = vec![kf(0, 0.0), kf(4800, 6.0)];
+        t.effects.push(amp);
+        t.lane_mut(LANE_PAN).unwrap().keyframes = vec![kf(0, -100.0), kf(4800, 100.0)];
+    }
+    let whole = r.mix(0, 4800);
+    for sizes in [&[100usize, 17][..], &[64], &[4800]] {
+        assert_eq!(r.mix_cut(0, 4800, sizes, None), whole, "{sizes:?}");
+    }
+    // hard left at the start, hard right at the end
+    assert!(whole[1][0].abs() < 1e-6 && whole[0][4799].abs() < 1e-3);
+}
+
+#[test]
+fn clip_volume_and_track_automation_both_apply() {
+    let mut r = Rig::new(&[dc]);
+    {
+        let t = r.track(0);
+        let it = &mut t.items[0];
+        let lvl = it.effect_mut("volume").unwrap().param_mut("level").unwrap();
+        lvl.keyframes = vec![Keyframe::new(Tick::ZERO, ParamValue::Float(-6.0)), Keyframe::new(Tick(TICKS_PER_SECOND), ParamValue::Float(-6.0))];
+        t.lane_mut(LANE_VOLUME).unwrap().keyframes = vec![kf(0, -6.0), kf(48_000, -6.0)];
+    }
+    let [l, _] = r.mix(100, 64);
+    assert!(close(l[0], 0.5 * 10f32.powf(-12.0 / 20.0), 1e-6), "{}", l[0]);
+}
+
+fn level(r: &Rig) -> f32 {
+    r.mix(2000, 64)[0][10]
+}
+
+fn dc1(_: i64, _: usize) -> f32 {
+    0.1
+}
+fn dc2(_: i64, _: usize) -> f32 {
+    0.2
+}
+fn dc4(_: i64, _: usize) -> f32 {
+    0.4
+}
+
+#[test]
+fn solo_and_mute_logic() {
+    let mut r = Rig::new(&[dc1, dc2, dc4]);
+    let s1 = r.add_submix("Submix 1");
+    r.track(1).mixer.output = Some(s1);
+    assert!(close(level(&r), 0.7, 1e-6));
+    r.track(0).solo = true;
+    assert!(close(level(&r), 0.1, 1e-6), "solo A1");
+    r.track(0).muted = true;
+    assert!(close(level(&r), 0.0, 1e-6), "soloed but muted");
+    r.track(0).muted = false;
+    r.track(0).solo = false;
+    // soloing a submix keeps its sources
+    r.submix(s1).solo = true;
+    assert!(close(level(&r), 0.2, 1e-6), "solo S1");
+    r.submix(s1).solo = false;
+    // soloing a track keeps its destination submix
+    r.track(1).solo = true;
+    assert!(close(level(&r), 0.2, 1e-6), "solo A2 through S1");
+    // solo safe: a solo-safe submix and its sources stay audible while others solo
+    let s2 = r.add_submix("Dialogue");
+    r.track(2).mixer.output = Some(s2);
+    r.submix(s2).mixer.solo_safe = true;
+    assert!(close(level(&r), 0.6, 1e-6), "solo A2 + solo-safe S2");
+    r.submix(s2).mixer.solo_safe = false;
+    assert!(close(level(&r), 0.2, 1e-6));
+    r.track(1).solo = false;
+    // mute automation (hold)
+    r.track(2).lane_mut(LANE_MUTE).unwrap().keyframes = vec![kf(0, 0.0), kf(2005, 1.0)];
+    let x = r.mix(2000, 10)[0].clone();
+    assert!(close(x[4], 0.7, 1e-6) && close(x[5], 0.3, 1e-6), "{x:?}");
+}
+
+#[test]
+fn sends_route_to_submixes() {
+    let mut r = Rig::new(&[dc]);
+    let fx = r.add_submix("Reverb");
+    {
+        let t = r.track(0);
+        let mut s = TrackSend::new(fx);
+        s.level_db = -6.0;
+        t.mixer.sends.push(s);
+    }
+    let g6 = 10f32.powf(-6.0 / 20.0);
+    assert!(close(level(&r), 0.5 + 0.5 * g6, 1e-6), "post-fader send adds to the Mix");
+    // post-fader send follows the fader
+    r.track(0).volume_db = -6.0;
+    assert!(close(level(&r), 0.5 * g6 + 0.5 * g6 * g6, 1e-6));
+    // pre-fader send ignores fader and mute
+    r.track(0).mixer.sends[0].pre_fader = true;
+    r.track(0).muted = true;
+    assert!(close(level(&r), 0.5 * g6, 1e-6), "pre-fader send of a muted track");
+    r.track(0).muted = false;
+    r.track(0).volume_db = -96.0;
+    assert!(close(level(&r), 0.5 * g6, 1e-6));
+    // send level automation and submix fader
+    r.track(0).lane_mut(&send_lane(0)).unwrap().keyframes = vec![kf(0, 0.0), kf(4000, 0.0)];
+    r.submix(fx).volume_db = -6.0;
+    assert!(close(level(&r), 0.5 * g6, 1e-6));
+    // the track output can go to a submix; submixes chain forward only
+    r.track(0).volume_db = 0.0;
+    r.track(0).mixer.sends.clear();
+    r.track(0).mixer.output = Some(fx);
+    let fx2 = r.add_submix("Bus 2");
+    r.submix(fx).mixer.output = Some(fx2);
+    r.submix(fx2).volume_db = -6.0;
+    assert!(close(level(&r), 0.5 * g6 * g6, 1e-6));
+    // a backwards route (feedback) falls back to the Mix
+    r.submix(fx2).mixer.output = Some(fx);
+    assert!(close(level(&r), 0.5 * g6 * g6, 1e-6));
+}
+
+fn impulse(i: i64, _: usize) -> f32 {
+    if i == 10_000 { 0.25 } else { 0.0 }
+}
+
+#[test]
+fn latency_compensation_aligns_paths() {
+    // A1 goes through a look-ahead limiter (latency), A2 is dry; both carry the same impulse.
+    let mut r = Rig::new(&[impulse, impulse]);
+    let mut lim = filmcraft_project::find_effect("hard_limiter").unwrap().instance();
+    lim.param_mut("max").unwrap().value = ParamValue::Float(0.0);
+    r.track(0).effects.push(lim.clone());
+    let lat = graph_latency(r.p.sequence(r.seq).unwrap());
+    assert!(lat > 0, "limiter reports look-ahead");
+    let [l, _] = r.mix(9_000, 2_000);
+    let peak = l.iter().enumerate().fold((0usize, 0f32), |m, (i, &s)| if s.abs() > m.1 { (i, s.abs()) } else { m });
+    assert_eq!(peak.0 + 9_000, 10_000, "aligned impulse lands on its timeline sample");
+    assert!(close(peak.1, 0.5, 1e-3), "both paths sum coherently: {}", peak.1);
+    // through a submix with its own latency, a send and a dry path stay aligned
+    let bus = r.add_submix("Bus");
+    r.submix(bus).effects.push(lim);
+    r.track(1).mixer.sends.push(TrackSend::new(bus));
+    let [l, _] = r.mix(9_000, 2_000);
+    let peak = l.iter().enumerate().fold((0usize, 0f32), |m, (i, &s)| if s.abs() > m.1 { (i, s.abs()) } else { m });
+    assert_eq!(peak.0 + 9_000, 10_000);
+    assert!(close(peak.1, 0.75, 2e-3), "{}", peak.1);
+    // automation is evaluated at content time: a volume step on A1 at the impulse applies to it
+    r.track(0).lane_mut(LANE_VOLUME).unwrap().keyframes = vec![kf(0, 0.0), kf(9_999, 0.0), kf(10_000, -96.0)];
+    r.track(0).lane_mut(LANE_VOLUME).unwrap().keyframes[1].interp = filmcraft_project::Interpolation::Hold;
+    let [l, _] = r.mix(9_000, 2_000);
+    assert!(close(l[1000], 0.5, 2e-3), "A1 silenced exactly at its content sample: {}", l[1000]);
+}
+
+fn noise(i: i64, c: usize) -> f32 {
+    let x = (i as u64).wrapping_mul(0x9E37_79B9_7F4A_7C15) ^ (c as u64 * 0x1234_5678);
+    let x = x ^ (x >> 29);
+    ((x.wrapping_mul(0xBF58_476D_1CE4_E5B9) >> 40) as f32 / (1u64 << 24) as f32 - 0.5) * 0.4
+}
+
+fn busy_rig(tracks: usize) -> Rig {
+    let sig: Vec<fn(i64, usize) -> f32> = vec![noise; tracks];
+    let mut r = Rig::new(&sig);
+    let bus = r.add_submix("Bus");
+    let mut comp = filmcraft_project::find_effect("dynamics").unwrap().instance();
+    comp.param_mut("threshold").unwrap().value = ParamValue::Float(-20.0);
+    r.submix(bus).effects.push(comp);
+    for k in 0..tracks {
+        let t = r.track(k);
+        for (id, post) in [("parametric_eq", false), ("dynamics", false), ("studio_reverb", true)] {
+            let mut e = filmcraft_project::find_effect(id).unwrap().instance();
+            e.post_fader = post;
+            t.effects.push(e);
+        }
+        t.pan = (k as f64 * 37.0) % 200.0 - 100.0;
+        t.lane_mut(LANE_VOLUME).unwrap().keyframes = vec![kf(0, -6.0), kf(96_000, 0.0)];
+        if k % 3 == 0 {
+            t.mixer.sends.push(TrackSend::new(bus));
+        }
+    }
+    r
+}
+
+#[test]
+fn render_and_playback_paths_are_identical() {
+    // export renders in large batches; playback pulls small device blocks with live meters
+    let r = busy_rig(4);
+    let export = r.mix_cut(0, 24_000, &[8_000], None);
+    let live = LiveMix::new();
+    let playback = r.mix_cut(0, 24_000, &[512, 480, 1024], Some(&live));
+    assert_eq!(export, playback);
+    assert!(export[0].iter().any(|s| s.abs() > 1e-3));
+    let m = live.take_meters();
+    assert!(m.get(&crate::mixer::MASTER).is_some_and(|p| p[0] > 0.0), "meters published");
+    // deterministic: a second render from scratch is identical
+    let again = Rig::new(&[]);
+    drop(again);
+    assert_eq!(busy_rig(4).mix_cut(0, 24_000, &[8_000], None), export);
+}
+
+#[test]
+fn live_override_holds_and_ramps_back() {
+    let mut r = Rig::new(&[dc]);
+    r.track(0).lane_mut(LANE_VOLUME).unwrap().keyframes = vec![kf(0, 0.0), kf(96_000, 0.0)];
+    let id = r.track(0).id;
+    let live = LiveMix::new();
+    live.hold(id, LANE_VOLUME, -6.0);
+    let b = mix_graph(&r.p, r.p.sequence(r.seq).unwrap(), 0, 64, &r.map, Some(&live));
+    assert!(close(b.channels[0][0], 0.5 * 10f32.powf(-0.3), 1e-6));
+    // released at sample 4800 with a 4800-sample ramp: halfway back at 7200
+    live.release(id, LANE_VOLUME, Tick::from_units(4800, SR), Tick::from_units(4800, SR));
+    let b = mix_graph(&r.p, r.p.sequence(r.seq).unwrap(), 7200, 1, &r.map, Some(&live));
+    assert!(close(b.channels[0][0], 0.5 * 10f32.powf(-3.0 / 20.0), 1e-6), "{}", b.channels[0][0]);
+    let b = mix_graph(&r.p, r.p.sequence(r.seq).unwrap(), 9600, 1, &r.map, Some(&live));
+    assert!(close(b.channels[0][0], 0.5, 1e-6));
+}
+
+/// 24 tracks × 3 inserts (EQ, Dynamics, Studio Reverb) + a compressed submix at 48 kHz, one core.
+#[test]
+fn perf_24_tracks_3_effects_realtime_factor() {
+    let r = busy_rig(24);
+    let secs = if cfg!(debug_assertions) { 2.0 } else { 10.0 };
+    let n = (secs * SR as f64) as usize;
+    let pool = rayon::ThreadPoolBuilder::new().num_threads(1).build().unwrap();
+    // warm up (fresh graph + pre-roll), then time steady-state playback-sized blocks
+    pool.install(|| r.mix_cut(0, 4_800, &[1024], None));
+    let t0 = std::time::Instant::now();
+    pool.install(|| r.mix_cut(4_800, n, &[1024], None));
+    let el = t0.elapsed().as_secs_f64();
+    let rt = secs / el;
+    eprintln!("mixer perf: 24 tracks x 3 inserts + submix, {secs} s of 48 kHz stereo in {el:.3} s on one core = {rt:.1}x realtime");
+    let min = if cfg!(debug_assertions) { 1.0 } else { 4.0 };
+    assert!(rt > min, "realtime factor {rt:.2}");
+}
+
+#[test]
+fn audio_transition_curves() {
+    use crate::transitions::audio_gains;
+    for i in 0..=20 {
+        let p = i as f32 / 20.0;
+        let (a, b) = audio_gains("constant_power", p);
+        assert!(close(a * a + b * b, 1.0, 1e-5), "constant power keeps power at {p}");
+        let (a, b) = audio_gains("constant_gain", p);
+        assert!(close(a + b, 1.0, 1e-6), "constant gain keeps amplitude at {p}");
+        let (a, b) = audio_gains("exponential_fade", p);
+        assert!((0.0..=1.0).contains(&a) && (0.0..=1.0).contains(&b));
+    }
+    for k in ["constant_power", "constant_gain", "exponential_fade"] {
+        assert_eq!(audio_gains(k, 0.0), (1.0, 0.0), "{k} starts on A");
+        let (a, b) = audio_gains(k, 1.0);
+        assert!(a.abs() < 1e-6 && close(b, 1.0, 1e-6), "{k} ends on B");
+    }
+}
diff --git a/crates/render/src/plan.rs b/crates/render/src/plan.rs
index 3732f0452..74a82edf9 100644
--- a/crates/render/src/plan.rs
+++ b/crates/render/src/plan.rs
@@ -141,6 +141,20 @@ fn push_item(
 ) {
     let mt = item.source_time_at(t);
     let (op, bl) = crate::opacity_blend(item, mt);
+    // Graphic clips without standard effects: the layers are rasterised (cached) into one tight
+    // image the GPU places as a layer.
+    if bl == Blend::Normal
+        && !(opts.effects && item.has_standard_effects())
+        && project.item(item.item).is_some_and(|p| matches!(p.kind, ItemKind::Graphic { .. }))
+    {
+        let Some(size) = crate::source_size(project, item.item) else { return };
+        let (w, h) = output_size(seq, opts.scale);
+        let m = Affine::scale(opts.scale as f64, opts.scale as f64).then_apply(&motion_matrix(seq, item, size, mt));
+        if let Some((img, x, y)) = crate::graphic_clip::render_graphic_tight(&item.effects, mt, size, &m, w, h) {
+            out.push(PlanLayer { frame: cpu_frame(img), matrix: Affine::translate(x as f64, y as f64), opacity: op * extra_opacity });
+        }
+        return;
+    }
     if gpu_simple(project, item, mt) && bl == Blend::Normal {
         let Some(src) = sources.source(item.item) else { return };
         let Some(size) = crate::source_size(project, item.item) else { return };
diff --git a/crates/render/src/preview.rs b/crates/render/src/preview.rs
index 11769c0a4..4ffc0dfd8 100644
--- a/crates/render/src/preview.rs
+++ b/crates/render/src/preview.rs
@@ -247,10 +247,12 @@ pub fn audio_segments(project: &Project, seq_id: ItemId) -> Vec<AudioSegment> {
     cuts.dedup();
     let any_solo = seq.audio_tracks.iter().any(|t| t.solo);
     let mut global = Fnv128::new();
-    global.json(&(HASH_VERSION, "audio", sr, seq.master_volume_db, &seq.master_effects, any_solo));
+    global.json(&(HASH_VERSION, "audio", sr, seq.master_volume_db, &seq.master_effects, &seq.master_mixer, any_solo));
     for (ti, tr) in seq.audio_tracks.iter().enumerate() {
-        global.json(&(ti, tr.muted, tr.solo, tr.volume_db, tr.pan, tr.channels, &tr.effects));
+        global.json(&(ti, tr.muted, tr.solo, tr.volume_db, tr.pan, tr.channels, &tr.effects, &tr.mixer));
     }
+    // submixes (routing, inserts, automation) affect every segment
+    global.json(&seq.submix_tracks);
     let mut out = Vec::new();
     for w in cuts.windows(2) {
         let (a, b) = (w[0], w[1]);
@@ -339,6 +341,7 @@ fn hash_source(h: &mut Fnv128, project: &Project, id: ItemId, depth: u32) {
             hash_source(h, project, *parent, depth + 1);
         }
         ItemKind::AdjustmentLayer { .. } => h.json(&("adjustment", &pi.kind)),
+        ItemKind::Graphic { .. } => h.json(&("graphic", &pi.kind)),
         ItemKind::Sequence(s) => {
             h.json(&("sequence", &s.settings));
             for (ti, tr) in s.video_tracks.iter().enumerate() {
@@ -415,6 +418,8 @@ fn decode_cost_ms(project: &Project, id: ItemId, depth: u32) -> f64 {
         }
         ItemKind::Subclip { parent, .. } => decode_cost_ms(project, *parent, depth + 1),
         ItemKind::AdjustmentLayer { .. } => 0.0,
+        // vector layers are drawn on the CPU (cached while static)
+        ItemKind::Graphic { .. } => 1.5,
         ItemKind::Sequence(s) => {
             if depth > 8 {
                 return 0.0;
diff --git a/crates/testkit/Cargo.toml b/crates/testkit/Cargo.toml
new file mode 100644
index 000000000..eca8a6c87
--- /dev/null
+++ b/crates/testkit/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+name = "filmcraft-testkit"
+description = "Test-only helpers: ffmpeg/ffprobe oracle discovery, fixture directories, golden-image comparison"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+rust-version.workspace = true
+publish = false
+
+[lints]
+workspace = true
+
+# Used only as a dev-dependency. No FilmCraft dependencies, so any crate (including L0 codecs) can
+# use it without creating dependency cycles.
+[dependencies]
+png = "0.18"
diff --git a/crates/testkit/src/fixtures.rs b/crates/testkit/src/fixtures.rs
new file mode 100644
index 000000000..62e9a1449
--- /dev/null
+++ b/crates/testkit/src/fixtures.rs
@@ -0,0 +1,136 @@
+//! Fixture locations and race-free generation.
+//!
+//! Fixtures live in `<workspace>/target/fixtures/<crate>/` whatever `CARGO_TARGET_DIR` is, so
+//! parallel agents with private target dirs share one generated set. `FILMCRAFT_FIXTURES_DIR`
+//! overrides the root. Media is never committed.
+
+use std::path::{Path, PathBuf};
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+/// The workspace root (the directory holding the top-level `Cargo.toml`).
+pub fn workspace_root() -> PathBuf {
+    let here = Path::new(env!("CARGO_MANIFEST_DIR"));
+    let root = here.parent().and_then(Path::parent).unwrap_or(here);
+    root.canonicalize().unwrap_or_else(|_| root.to_path_buf())
+}
+
+/// Root of all generated fixtures: `$FILMCRAFT_FIXTURES_DIR` or `<workspace>/target/fixtures`.
+pub fn fixtures_root() -> PathBuf {
+    match std::env::var_os("FILMCRAFT_FIXTURES_DIR").filter(|v| !v.is_empty()) {
+        Some(d) => PathBuf::from(d),
+        None => workspace_root().join("target").join("fixtures"),
+    }
+}
+
+/// `<fixtures root>/<sub>` (created). `sub` may contain `/` (e.g. `"opus/oracle"`).
+pub fn fixtures_dir(sub: &str) -> PathBuf {
+    let mut d = fixtures_root();
+    for part in sub.split('/').filter(|p| !p.is_empty()) {
+        d.push(part);
+    }
+    std::fs::create_dir_all(&d).unwrap_or_else(|e| panic!("create {}: {e}", d.display()));
+    d
+}
+
+/// A temporary sibling of `out` that no other thread or process will pick: the stem gets
+/// `.tmp-<pid>-<thread>-<n>` and the extension is kept (ffmpeg chooses the muxer from it).
+pub fn temp_path(out: &Path) -> PathBuf {
+    static N: AtomicUsize = AtomicUsize::new(0);
+    let tid = format!("{:?}", std::thread::current().id()).replace(|c: char| !c.is_ascii_alphanumeric(), "");
+    let n = N.fetch_add(1, Ordering::Relaxed);
+    let stem = out.file_stem().map(|s| s.to_string_lossy().to_string()).unwrap_or_default();
+    let name = match out.extension() {
+        Some(ext) => format!("{stem}.tmp-{}-{tid}-{n}.{}", std::process::id(), ext.to_string_lossy()),
+        None => format!("{stem}.tmp-{}-{tid}-{n}", std::process::id()),
+    };
+    out.with_file_name(name)
+}
+
+/// Return `out` if it already exists (non-empty); otherwise run `make(tmp)` on a [`temp_path`]
+/// and atomically rename the result into place. Concurrent generators race harmlessly.
+/// `None` when `make` reports failure (the temporary file is removed).
+pub fn generate(out: &Path, make: impl FnOnce(&Path) -> bool) -> Option<PathBuf> {
+    if std::fs::metadata(out).is_ok_and(|m| m.len() > 0) {
+        return Some(out.to_path_buf());
+    }
+    if let Some(dir) = out.parent() {
+        let _ = std::fs::create_dir_all(dir);
+    }
+    let tmp = temp_path(out);
+    if !make(&tmp) || !tmp.exists() {
+        let _ = std::fs::remove_file(&tmp);
+        return None;
+    }
+    std::fs::rename(&tmp, out).ok()?;
+    Some(out.to_path_buf())
+}
+
+/// Status of one fixture for `cargo xtask fixtures`.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Status {
+    Made,
+    Cached,
+    Skipped,
+}
+
+/// Print a `FIXTURE <made|cached|skipped> <name>` line (parsed by `cargo xtask fixtures`).
+pub fn report(name: &str, status: Status) {
+    let s = match status {
+        Status::Made => "made",
+        Status::Cached => "cached",
+        Status::Skipped => "skipped",
+    };
+    println!("FIXTURE {s} {name}");
+}
+
+/// Run a fixture generator and [`report`] it: `cached` when every path in `outputs` existed
+/// before, `made` when `generate` succeeded, `skipped` otherwise.
+pub fn generate_and_report<T>(name: &str, outputs: &[PathBuf], generate: impl FnOnce() -> Option<T>) -> Option<T> {
+    let existed = !outputs.is_empty() && outputs.iter().all(|p| std::fs::metadata(p).is_ok_and(|m| m.len() > 0));
+    let r = generate();
+    report(
+        name,
+        match (&r, existed) {
+            (None, _) => Status::Skipped,
+            (Some(_), true) => Status::Cached,
+            (Some(_), false) => Status::Made,
+        },
+    );
+    r
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn root_is_the_workspace() {
+        assert!(workspace_root().join("Cargo.toml").exists());
+        assert!(workspace_root().join("crates").join("testkit").exists());
+    }
+
+    #[test]
+    fn temp_paths_are_unique_and_keep_the_extension() {
+        let out = Path::new("/x/clip.mp4");
+        let a = temp_path(out);
+        let b = temp_path(out);
+        assert_ne!(a, b);
+        assert_eq!(a.extension().unwrap(), "mp4");
+        let other = std::thread::spawn(move || temp_path(Path::new("/x/clip.mp4"))).join().unwrap();
+        assert_ne!(a, other);
+    }
+
+    #[test]
+    fn generate_is_cached_and_atomic() {
+        let dir = std::env::temp_dir().join(format!("filmcraft-testkit-gen-{}", std::process::id()));
+        let out = dir.join("f.bin");
+        let _ = std::fs::remove_file(&out);
+        assert!(generate(&out, |_| false).is_none());
+        assert!(!out.exists());
+        let p = generate(&out, |t| std::fs::write(t, b"abc").is_ok()).unwrap();
+        assert_eq!(std::fs::read(&p).unwrap(), b"abc");
+        // cached: the generator is not called again
+        let p2 = generate(&out, |_| panic!("regenerated")).unwrap();
+        assert_eq!(p, p2);
+    }
+}
diff --git a/crates/testkit/src/golden.rs b/crates/testkit/src/golden.rs
new file mode 100644
index 000000000..d79fbad02
--- /dev/null
+++ b/crates/testkit/src/golden.rs
@@ -0,0 +1,344 @@
+//! Golden-image testing: RGBA8 images, PNG I/O, difference metrics and reference checks.
+//!
+//! A golden test renders an image, then calls [`assert_golden`] with the path of a committed
+//! reference PNG and a [`Tolerance`]. On mismatch the actual image and an amplified difference
+//! image are written to `<workspace>/target/golden-failures/` for inspection.
+//!
+//! `FILMCRAFT_BLESS=1` (re)writes the reference instead of comparing, plus its `.attribution`
+//! sidecar when missing (AGENTS.md §1). References must be produced by FilmCraft itself (original
+//! work), be small (< [`MAX_GOLDEN_BYTES`]) and be listed in `ATTRIBUTION.md`.
+
+use std::io::{BufReader, Cursor};
+use std::path::{Path, PathBuf};
+
+/// Size limit for a committed golden PNG.
+pub const MAX_GOLDEN_BYTES: u64 = 50 * 1024;
+
+/// An 8-bit RGBA image, row-major, no padding.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Rgba8 {
+    pub w: u32,
+    pub h: u32,
+    pub px: Vec<u8>,
+}
+
+impl Rgba8 {
+    pub fn new(w: u32, h: u32, px: Vec<u8>) -> Self {
+        assert_eq!(px.len(), w as usize * h as usize * 4, "pixel buffer size");
+        Self { w, h, px }
+    }
+    pub fn get(&self, x: u32, y: u32) -> [u8; 4] {
+        let i = (y as usize * self.w as usize + x as usize) * 4;
+        [self.px[i], self.px[i + 1], self.px[i + 2], self.px[i + 3]]
+    }
+    fn opaque(&self) -> bool {
+        self.px.chunks_exact(4).all(|p| p[3] == 255)
+    }
+}
+
+/// Encode as PNG (RGB when fully opaque, else RGBA), maximum compression.
+pub fn encode_png(img: &Rgba8) -> Result<Vec<u8>, String> {
+    let mut out = Vec::new();
+    {
+        let mut enc = png::Encoder::new(&mut out, img.w, img.h);
+        let opaque = img.opaque();
+        enc.set_color(if opaque { png::ColorType::Rgb } else { png::ColorType::Rgba });
+        enc.set_depth(png::BitDepth::Eight);
+        enc.set_compression(png::Compression::High);
+        let mut w = enc.write_header().map_err(|e| e.to_string())?;
+        if opaque {
+            let rgb: Vec<u8> = img.px.chunks_exact(4).flat_map(|p| [p[0], p[1], p[2]]).collect();
+            w.write_image_data(&rgb).map_err(|e| e.to_string())?;
+        } else {
+            w.write_image_data(&img.px).map_err(|e| e.to_string())?;
+        }
+        w.finish().map_err(|e| e.to_string())?;
+    }
+    Ok(out)
+}
+
+/// Decode a PNG (8-bit gray/RGB/RGBA, palette expanded) to RGBA8.
+pub fn decode_png(bytes: &[u8]) -> Result<Rgba8, String> {
+    let mut dec = png::Decoder::new(BufReader::new(Cursor::new(bytes)));
+    dec.set_transformations(png::Transformations::EXPAND | png::Transformations::STRIP_16);
+    let mut r = dec.read_info().map_err(|e| e.to_string())?;
+    let mut buf = vec![0; r.output_buffer_size().ok_or("PNG too large")?];
+    let info = r.next_frame(&mut buf).map_err(|e| e.to_string())?;
+    let (w, h) = (info.width, info.height);
+    let n = w as usize * h as usize;
+    let px = match info.color_type {
+        png::ColorType::Rgba => buf[..n * 4].to_vec(),
+        png::ColorType::Rgb => buf[..n * 3].chunks_exact(3).flat_map(|p| [p[0], p[1], p[2], 255]).collect(),
+        png::ColorType::GrayscaleAlpha => buf[..n * 2].chunks_exact(2).flat_map(|p| [p[0], p[0], p[0], p[1]]).collect(),
+        png::ColorType::Grayscale => buf[..n].iter().flat_map(|&g| [g, g, g, 255]).collect(),
+        png::ColorType::Indexed => return Err("unexpanded palette PNG".into()),
+    };
+    Ok(Rgba8 { w, h, px })
+}
+
+pub fn read_png(path: &Path) -> Result<Rgba8, String> {
+    let bytes = std::fs::read(path).map_err(|e| format!("{}: {e}", path.display()))?;
+    decode_png(&bytes).map_err(|e| format!("{}: {e}", path.display()))
+}
+
+pub fn write_png(path: &Path, img: &Rgba8) -> Result<u64, String> {
+    let bytes = encode_png(img)?;
+    if let Some(d) = path.parent() {
+        std::fs::create_dir_all(d).map_err(|e| e.to_string())?;
+    }
+    std::fs::write(path, &bytes).map_err(|e| format!("{}: {e}", path.display()))?;
+    Ok(bytes.len() as u64)
+}
+
+/// Per-pixel difference statistics over all four channels (8-bit levels).
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Diff {
+    /// Largest absolute channel difference.
+    pub max_abs: u8,
+    /// Mean absolute channel difference.
+    pub mean_abs: f64,
+    /// 99th percentile of the per-pixel maximum channel difference.
+    pub p99: u8,
+    /// PSNR in dB over all channels (`f64::INFINITY` when identical).
+    pub psnr: f64,
+    /// Pixels with any channel different.
+    pub differing: usize,
+}
+
+impl std::fmt::Display for Diff {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "PSNR {:.2} dB, max {}, p99 {}, mean {:.3}, {} pixels differ", self.psnr, self.max_abs, self.p99, self.mean_abs, self.differing)
+    }
+}
+
+/// Compare two images of equal size.
+pub fn diff(a: &Rgba8, b: &Rgba8) -> Result<Diff, String> {
+    if (a.w, a.h) != (b.w, b.h) {
+        return Err(format!("size {}x{} vs {}x{}", a.w, a.h, b.w, b.h));
+    }
+    let mut hist = [0usize; 256];
+    let (mut sum, mut sq, mut max, mut differing) = (0u64, 0u64, 0u8, 0usize);
+    for (p, q) in a.px.chunks_exact(4).zip(b.px.chunks_exact(4)) {
+        let mut m = 0u8;
+        for k in 0..4 {
+            let d = p[k].abs_diff(q[k]);
+            sum += d as u64;
+            sq += d as u64 * d as u64;
+            m = m.max(d);
+        }
+        hist[m as usize] += 1;
+        max = max.max(m);
+        differing += (m > 0) as usize;
+    }
+    let pixels = (a.w as usize * a.h as usize).max(1);
+    let target = (pixels * 99).div_ceil(100);
+    let mut acc = 0;
+    let mut p99 = 0u8;
+    for (v, n) in hist.iter().enumerate() {
+        acc += n;
+        if acc >= target {
+            p99 = v as u8;
+            break;
+        }
+    }
+    let n = (pixels * 4) as f64;
+    let mse = sq as f64 / n;
+    let psnr = if mse == 0.0 { f64::INFINITY } else { 10.0 * (255.0f64 * 255.0 / mse).log10() };
+    Ok(Diff { max_abs: max, mean_abs: sum as f64 / n, p99, psnr, differing })
+}
+
+/// Acceptance thresholds; every set limit must hold.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Tolerance {
+    pub min_psnr: f64,
+    pub max_abs: u8,
+    pub p99: u8,
+}
+
+impl Tolerance {
+    /// Bit-exact.
+    pub const EXACT: Tolerance = Tolerance { min_psnr: f64::INFINITY, max_abs: 0, p99: 0 };
+    /// Default for CPU renders compared with CPU-made references: absorbs float differences
+    /// between platforms (FMA, SIMD widths, thread scheduling of reductions) but not real changes.
+    pub const RENDER: Tolerance = Tolerance { min_psnr: 45.0, max_abs: 12, p99: 2 };
+
+    pub fn accepts(&self, d: &Diff) -> bool {
+        d.psnr >= self.min_psnr && d.max_abs <= self.max_abs && d.p99 <= self.p99
+    }
+}
+
+/// Whether `FILMCRAFT_BLESS` asks to regenerate references.
+pub fn blessing() -> bool {
+    std::env::var("FILMCRAFT_BLESS").is_ok_and(|v| matches!(v.trim().to_ascii_lowercase().as_str(), "1" | "true" | "yes" | "on"))
+}
+
+/// Where failing comparisons write `<name>.actual.png` / `<name>.diff.png`.
+pub fn failures_dir() -> PathBuf {
+    crate::workspace_root().join("target").join("golden-failures")
+}
+
+/// Difference image: |a − b| per channel ×8, opaque.
+pub fn diff_image(a: &Rgba8, b: &Rgba8) -> Rgba8 {
+    let px =
+        a.px.chunks_exact(4)
+            .zip(b.px.chunks_exact(4))
+            .flat_map(|(p, q)| {
+                let d = |k: usize| (p[k].abs_diff(q[k]) as u32 * 8).min(255) as u8;
+                let al = d(3);
+                [d(0).max(al), d(1).max(al), d(2).max(al), 255]
+            })
+            .collect();
+    Rgba8 { w: a.w, h: a.h, px }
+}
+
+/// Today's date (UTC) as YYYY-MM-DD, for attribution sidecars.
+fn today() -> String {
+    let secs = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map(|d| d.as_secs()).unwrap_or(0);
+    // civil-from-days (Howard Hinnant)
+    let z = (secs / 86_400) as i64 + 719_468;
+    let era = z.div_euclid(146_097);
+    let doe = z - era * 146_097;
+    let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365;
+    let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
+    let mp = (5 * doy + 2) / 153;
+    let d = doy - (153 * mp + 2) / 5 + 1;
+    let m = if mp < 10 { mp + 3 } else { mp - 9 };
+    let y = yoe + era * 400 + (m <= 2) as i64;
+    format!("{y:04}-{m:02}-{d:02}")
+}
+
+/// The attribution sidecar text for a generated golden image.
+pub fn sidecar_text(file_name: &str, title: &str, generated_by: &str) -> String {
+    format!(
+        "asset:        {file_name}\n\
+         title:        {title}\n\
+         author:       FilmCraft contributors\n\
+         source:       original work (rendered by FilmCraft's own renderer from a procedurally generated project; no external media)\n\
+         license:      MIT OR Apache-2.0\n\
+         license-file:\n\
+         added:        {} by FilmCraft contributors (FILMCRAFT_BLESS=1)\n\
+         notes:        Golden reference image generated by {generated_by}. Regenerate with FILMCRAFT_BLESS=1. Contains no Adobe artwork.\n",
+        today()
+    )
+}
+
+/// The `ATTRIBUTION.md` table row for a golden image at workspace-relative `rel`.
+pub fn attribution_row(rel: &str, generated_by: &str) -> String {
+    format!("| `{rel}` | FilmCraft contributors | Original work: golden reference rendered by FilmCraft ({generated_by}) | MIT OR Apache-2.0 |")
+}
+
+/// Compare `actual` with the golden PNG at `golden` (or bless it). `title` and `generated_by`
+/// fill the attribution sidecar written on bless. Returns the difference on success.
+pub fn check_golden(golden: &Path, actual: &Rgba8, tol: Tolerance, title: &str, generated_by: &str) -> Result<Diff, String> {
+    let name = golden.file_stem().map(|s| s.to_string_lossy().to_string()).unwrap_or_default();
+    if blessing() {
+        let size = write_png(golden, actual)?;
+        if size > MAX_GOLDEN_BYTES {
+            return Err(format!("{}: {size} bytes exceeds the {MAX_GOLDEN_BYTES}-byte golden limit; render smaller", golden.display()));
+        }
+        let side = PathBuf::from(format!("{}.attribution", golden.display()));
+        if !side.exists() {
+            let file = golden.file_name().map(|s| s.to_string_lossy().to_string()).unwrap_or_default();
+            std::fs::write(&side, sidecar_text(&file, title, generated_by)).map_err(|e| e.to_string())?;
+        }
+        let root = crate::workspace_root();
+        let rel = golden.strip_prefix(&root).unwrap_or(golden).to_string_lossy().replace('\\', "/");
+        let index = std::fs::read_to_string(root.join("ATTRIBUTION.md")).unwrap_or_default();
+        if !index.contains(&format!("`{rel}`")) {
+            eprintln!("golden {rel}: add this row to ATTRIBUTION.md:\n{}", attribution_row(&rel, generated_by));
+        }
+        eprintln!("blessed {rel} ({size} bytes)");
+        return Ok(Diff { max_abs: 0, mean_abs: 0.0, p99: 0, psnr: f64::INFINITY, differing: 0 });
+    }
+    let expected = read_png(golden).map_err(|e| format!("{e}\n(missing or unreadable golden; generate it with FILMCRAFT_BLESS=1)"))?;
+    let d = diff(&expected, actual).map_err(|e| format!("{}: {e}", golden.display()))?;
+    if tol.accepts(&d) {
+        return Ok(d);
+    }
+    let dir = failures_dir();
+    let a = dir.join(format!("{name}.actual.png"));
+    let _ = write_png(&a, actual);
+    let _ = write_png(&dir.join(format!("{name}.diff.png")), &diff_image(&expected, actual));
+    Err(format!(
+        "{}: {d} (tolerance: PSNR ≥ {} dB, max ≤ {}, p99 ≤ {}); actual and diff written to {}",
+        golden.display(),
+        tol.min_psnr,
+        tol.max_abs,
+        tol.p99,
+        dir.display()
+    ))
+}
+
+/// [`check_golden`] that panics on failure.
+pub fn assert_golden(golden: &Path, actual: &Rgba8, tol: Tolerance, title: &str, generated_by: &str) -> Diff {
+    match check_golden(golden, actual, tol, title, generated_by) {
+        Ok(d) => d,
+        Err(e) => panic!("golden mismatch: {e}"),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn ramp(w: u32, h: u32, alpha: u8) -> Rgba8 {
+        let px = (0..w * h).flat_map(|i| [(i % w * 255 / w) as u8, (i / w * 255 / h) as u8, 77, alpha]).collect();
+        Rgba8::new(w, h, px)
+    }
+
+    #[test]
+    fn png_round_trip_rgb_and_rgba() {
+        for a in [255, 128] {
+            let img = ramp(37, 21, a);
+            let png = encode_png(&img).unwrap();
+            assert_eq!(decode_png(&png).unwrap(), img);
+        }
+    }
+
+    #[test]
+    fn diff_metrics() {
+        let a = ramp(10, 10, 255);
+        assert_eq!(diff(&a, &a).unwrap().psnr, f64::INFINITY);
+        let mut b = a.clone();
+        b.px[0] = b.px[0].wrapping_add(10); // one channel of one pixel
+        let d = diff(&a, &b).unwrap();
+        assert_eq!((d.max_abs, d.p99, d.differing), (10, 0, 1));
+        assert!((d.mean_abs - 10.0 / 400.0).abs() < 1e-12);
+        let mse: f64 = 100.0 / 400.0;
+        assert!((d.psnr - 10.0 * (255.0f64 * 255.0 / mse).log10()).abs() < 1e-9);
+        assert!(Tolerance::RENDER.accepts(&d));
+        assert!(!Tolerance::EXACT.accepts(&d));
+        assert!(diff(&a, &ramp(10, 11, 255)).is_err());
+    }
+
+    #[test]
+    fn check_golden_accepts_within_tolerance_and_reports_failures() {
+        if blessing() {
+            return;
+        }
+        let dir = std::env::temp_dir().join(format!("filmcraft-testkit-golden-{}", std::process::id()));
+        let path = dir.join("ramp.png");
+        let img = ramp(32, 16, 255);
+        write_png(&path, &img).unwrap();
+        assert!(check_golden(&path, &img, Tolerance::EXACT, "t", "unit test").is_ok());
+        let mut near = img.clone();
+        near.px[5] += 1;
+        assert!(check_golden(&path, &near, Tolerance::RENDER, "t", "unit test").is_ok());
+        let mut far = img.clone();
+        far.px.iter_mut().step_by(4).for_each(|v| *v = 255 - *v);
+        let e = check_golden(&path, &far, Tolerance::RENDER, "t", "unit test").unwrap_err();
+        assert!(e.contains("PSNR"), "{e}");
+        assert!(check_golden(&dir.join("missing.png"), &img, Tolerance::RENDER, "t", "unit test").unwrap_err().contains("FILMCRAFT_BLESS"));
+    }
+
+    #[test]
+    fn date_and_sidecar_fields() {
+        let t = today();
+        assert_eq!(t.len(), 10);
+        assert!(t.starts_with("20"));
+        let s = sidecar_text("x.png", "X", "test y");
+        for f in ["asset:", "title:", "author:", "source:", "license:", "added:"] {
+            assert!(s.lines().any(|l| l.starts_with(f) && l.len() > f.len() + 2), "{f}");
+        }
+    }
+}
diff --git a/crates/testkit/src/lib.rs b/crates/testkit/src/lib.rs
new file mode 100644
index 000000000..867df7b3b
--- /dev/null
+++ b/crates/testkit/src/lib.rs
@@ -0,0 +1,63 @@
+//! Test-only helpers shared by every FilmCraft crate (used as a dev-dependency only).
+//!
+//! - [`oracle`]: find `ffmpeg` / `ffprobe` (env vars, `PATH`, well-known dirs) and skip — or, with
+//!   `FILMCRAFT_REQUIRE_ORACLES=1`, fail — when they are missing ([`require_ffmpeg!`] & co.).
+//! - [`fixtures`]: the shared fixture directory (`<workspace>/target/fixtures/<crate>`) and
+//!   collision-free temporary names for concurrent generators.
+//! - [`golden`]: RGBA8 images, PNG I/O, image-difference metrics and golden-file checks
+//!   (`FILMCRAFT_BLESS=1` regenerates references).
+//!
+//! ffmpeg/ffprobe are external test oracles and fixture generators only; they are never linked
+//! or shipped (AGENTS.md §2).
+
+pub mod fixtures;
+pub mod golden;
+pub mod oracle;
+pub mod wav;
+
+pub use fixtures::{fixtures_dir, temp_path, workspace_root};
+pub use oracle::{ffmpeg, ffmpeg_or_skip, ffprobe, ffprobe_or_skip, oracles_required, skip};
+
+/// `let ff = require_ffmpeg!();` — the ffmpeg path, or return from the test after printing
+/// `SKIPPED: … ffmpeg not found` (a hard failure with `FILMCRAFT_REQUIRE_ORACLES=1`).
+/// `require_ffmpeg!(value)` returns `value` instead of `()`.
+#[macro_export]
+macro_rules! require_ffmpeg {
+    () => {
+        match $crate::ffmpeg_or_skip(concat!(module_path!(), ":", line!())) {
+            Some(p) => p,
+            None => return,
+        }
+    };
+    ($ret:expr) => {
+        match $crate::ffmpeg_or_skip(concat!(module_path!(), ":", line!())) {
+            Some(p) => p,
+            None => return $ret,
+        }
+    };
+}
+
+/// Like [`require_ffmpeg!`] for ffprobe.
+#[macro_export]
+macro_rules! require_ffprobe {
+    () => {
+        match $crate::ffprobe_or_skip(concat!(module_path!(), ":", line!())) {
+            Some(p) => p,
+            None => return,
+        }
+    };
+    ($ret:expr) => {
+        match $crate::ffprobe_or_skip(concat!(module_path!(), ":", line!())) {
+            Some(p) => p,
+            None => return $ret,
+        }
+    };
+}
+
+/// `let (ffmpeg, ffprobe) = require_oracles!();` — both tools or skip.
+#[macro_export]
+macro_rules! require_oracles {
+    () => {
+        ($crate::require_ffmpeg!(), $crate::require_ffprobe!())
+    };
+}
diff --git a/crates/testkit/src/oracle.rs b/crates/testkit/src/oracle.rs
new file mode 100644
index 000000000..8dbdbd3f7
--- /dev/null
+++ b/crates/testkit/src/oracle.rs
@@ -0,0 +1,170 @@
+//! Discovery of the external oracle tools (ffmpeg, ffprobe).
+//!
+//! Search order for a tool `T` (`ffmpeg` or `ffprobe`):
+//! 1. `FILMCRAFT_FFMPEG` / `FILMCRAFT_FFPROBE`: an explicit path (a set-but-wrong path is an error,
+//!    not a silent skip);
+//! 2. every directory on `PATH` (`T`, and `T.exe` on Windows);
+//! 3. well-known install locations (`/opt/homebrew/bin`, `/usr/local/bin`, `/usr/bin`,
+//!    `C:\ffmpeg\bin`, …).
+//!
+//! When a tool is missing, tests print `SKIPPED: …` and pass — unless
+//! `FILMCRAFT_REQUIRE_ORACLES=1` is set (CI), which turns every skip into a failure.
+
+use std::path::{Path, PathBuf};
+use std::sync::OnceLock;
+
+/// Environment variable that makes missing oracles a hard failure.
+pub const REQUIRE_ENV: &str = "FILMCRAFT_REQUIRE_ORACLES";
+
+const KNOWN_DIRS: &[&str] = &[
+    "/opt/homebrew/bin",
+    "/usr/local/bin",
+    "/usr/bin",
+    "/opt/local/bin",
+    "/snap/bin",
+    r"C:\ffmpeg\bin",
+    r"C:\Program Files\ffmpeg\bin",
+    r"C:\ProgramData\chocolatey\bin",
+];
+
+fn exe_names(name: &str) -> Vec<String> {
+    if cfg!(windows) { vec![format!("{name}.exe"), name.to_string()] } else { vec![name.to_string(), format!("{name}.exe")] }
+}
+
+fn is_file(p: &Path) -> bool {
+    p.is_file()
+}
+
+/// Find `name` given an explicit override, a `PATH`-style list and extra directories.
+/// (Pure function of its inputs; [`find_tool`] supplies the process environment.)
+pub fn find_tool_in(name: &str, explicit: Option<&std::ffi::OsStr>, path: Option<&std::ffi::OsStr>, extra: &[&str]) -> Result<Option<PathBuf>, String> {
+    if let Some(e) = explicit.filter(|e| !e.is_empty()) {
+        let p = PathBuf::from(e);
+        return if is_file(&p) { Ok(Some(p)) } else { Err(format!("{} is set but `{}` is not a file", env_var(name), p.display())) };
+    }
+    let names = exe_names(name);
+    if let Some(path) = path {
+        for dir in std::env::split_paths(path) {
+            for n in &names {
+                let p = dir.join(n);
+                if is_file(&p) {
+                    return Ok(Some(p));
+                }
+            }
+        }
+    }
+    for dir in extra {
+        for n in &names {
+            let p = Path::new(dir).join(n);
+            if is_file(&p) {
+                return Ok(Some(p));
+            }
+        }
+    }
+    Ok(None)
+}
+
+fn env_var(name: &str) -> String {
+    format!("FILMCRAFT_{}", name.to_ascii_uppercase())
+}
+
+/// Find a tool using the process environment (uncached).
+pub fn find_tool(name: &str) -> Option<PathBuf> {
+    let explicit = std::env::var_os(env_var(name));
+    let path = std::env::var_os("PATH");
+    match find_tool_in(name, explicit.as_deref(), path.as_deref(), KNOWN_DIRS) {
+        Ok(p) => p,
+        Err(e) => panic!("{e}"),
+    }
+}
+
+/// Path of ffmpeg, if available (cached for the process).
+pub fn ffmpeg() -> Option<PathBuf> {
+    static F: OnceLock<Option<PathBuf>> = OnceLock::new();
+    F.get_or_init(|| find_tool("ffmpeg")).clone()
+}
+
+/// Path of ffprobe, if available (cached for the process).
+pub fn ffprobe() -> Option<PathBuf> {
+    static F: OnceLock<Option<PathBuf>> = OnceLock::new();
+    F.get_or_init(|| find_tool("ffprobe")).clone()
+}
+
+/// Whether `FILMCRAFT_REQUIRE_ORACLES` is set to a true value.
+pub fn oracles_required() -> bool {
+    std::env::var(REQUIRE_ENV).is_ok_and(|v| matches!(v.trim().to_ascii_lowercase().as_str(), "1" | "true" | "yes" | "on"))
+}
+
+/// Report a skipped test: prints `SKIPPED (<context>): <reason>`. With
+/// `FILMCRAFT_REQUIRE_ORACLES=1` it panics instead, so CI cannot pass by skipping.
+pub fn skip(context: &str, reason: &str) {
+    if oracles_required() {
+        panic!("{context}: {reason}, and {REQUIRE_ENV}=1 forbids skipping oracle tests");
+    }
+    eprintln!("SKIPPED ({context}): {reason}");
+}
+
+fn tool_or_skip(name: &str, found: Option<PathBuf>, context: &str) -> Option<PathBuf> {
+    if found.is_none() {
+        skip(context, &format!("{name} not found (set {} or put {name} on PATH)", env_var(name)));
+    }
+    found
+}
+
+/// ffmpeg, or `None` after reporting a skip (see [`skip`]).
+pub fn ffmpeg_or_skip(context: &str) -> Option<PathBuf> {
+    tool_or_skip("ffmpeg", ffmpeg(), context)
+}
+
+/// ffprobe, or `None` after reporting a skip (see [`skip`]).
+pub fn ffprobe_or_skip(context: &str) -> Option<PathBuf> {
+    tool_or_skip("ffprobe", ffprobe(), context)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::ffi::OsString;
+
+    fn tmpdir(tag: &str) -> PathBuf {
+        let d = std::env::temp_dir().join(format!("filmcraft-testkit-{tag}-{}", std::process::id()));
+        std::fs::create_dir_all(&d).unwrap();
+        d
+    }
+
+    #[test]
+    fn explicit_path_wins_and_bad_path_errors() {
+        let d = tmpdir("explicit");
+        let f = d.join("my-ffmpeg");
+        std::fs::write(&f, b"").unwrap();
+        let got = find_tool_in("ffmpeg", Some(f.as_os_str()), None, &[]).unwrap();
+        assert_eq!(got, Some(f.clone()));
+        let missing = d.join("nope");
+        assert!(find_tool_in("ffmpeg", Some(missing.as_os_str()), None, &[]).is_err());
+        // empty value = unset
+        assert_eq!(find_tool_in("ffmpeg", Some(OsString::new().as_os_str()), None, &[]).unwrap(), None);
+    }
+
+    #[test]
+    fn path_search_finds_plain_and_exe_names() {
+        let a = tmpdir("path-a");
+        let b = tmpdir("path-b");
+        std::fs::write(b.join("ffprobe.exe"), b"").unwrap();
+        let path = std::env::join_paths([&a, &b]).unwrap();
+        let got = find_tool_in("ffprobe", None, Some(&path), &[]).unwrap();
+        assert_eq!(got, Some(b.join("ffprobe.exe")));
+        std::fs::write(a.join("ffprobe"), b"").unwrap();
+        let got = find_tool_in("ffprobe", None, Some(&path), &[]).unwrap();
+        assert!(got.is_some_and(|p| p.starts_with(&a)), "earlier PATH entry wins");
+    }
+
+    #[test]
+    fn known_dirs_are_the_fallback() {
+        let d = tmpdir("known");
+        std::fs::write(d.join("ffmpeg"), b"").unwrap();
+        let ds = d.to_string_lossy().to_string();
+        let got = find_tool_in("ffmpeg", None, Some(OsString::new().as_os_str()), &[ds.as_str()]).unwrap();
+        assert_eq!(got, Some(d.join("ffmpeg")));
+        assert_eq!(find_tool_in("ffmpeg-does-not-exist", None, None, &[ds.as_str()]).unwrap(), None);
+    }
+}
diff --git a/crates/testkit/src/wav.rs b/crates/testkit/src/wav.rs
new file mode 100644
index 000000000..72d3d29eb
--- /dev/null
+++ b/crates/testkit/src/wav.rs
@@ -0,0 +1,47 @@
+//! Minimal WAV writer (IEEE float, interleaved) for handing generated signals to ffmpeg.
+
+use std::path::Path;
+
+/// Encode planar `f32` channels (equal lengths) as a 32-bit float WAV file.
+pub fn encode_f32(channels: &[&[f32]], sample_rate: u32) -> Vec<u8> {
+    let nch = channels.len().max(1) as u16;
+    let frames = channels.first().map_or(0, |c| c.len());
+    assert!(channels.iter().all(|c| c.len() == frames), "channels must have equal lengths");
+    let data_len = (frames * nch as usize * 4) as u32;
+    let mut v = Vec::with_capacity(44 + data_len as usize);
+    v.extend_from_slice(b"RIFF");
+    v.extend_from_slice(&(36 + data_len).to_le_bytes());
+    v.extend_from_slice(b"WAVEfmt ");
+    v.extend_from_slice(&16u32.to_le_bytes());
+    v.extend_from_slice(&3u16.to_le_bytes()); // WAVE_FORMAT_IEEE_FLOAT
+    v.extend_from_slice(&nch.to_le_bytes());
+    v.extend_from_slice(&sample_rate.to_le_bytes());
+    v.extend_from_slice(&(sample_rate * nch as u32 * 4).to_le_bytes());
+    v.extend_from_slice(&(nch * 4).to_le_bytes());
+    v.extend_from_slice(&32u16.to_le_bytes());
+    v.extend_from_slice(b"data");
+    v.extend_from_slice(&data_len.to_le_bytes());
+    for i in 0..frames {
+        for c in channels {
+            v.extend_from_slice(&c[i].to_le_bytes());
+        }
+    }
+    v
+}
+
+/// Write planar `f32` channels to `path` as a float WAV.
+pub fn write_f32(path: &Path, channels: &[&[f32]], sample_rate: u32) -> std::io::Result<()> {
+    std::fs::write(path, encode_f32(channels, sample_rate))
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn header_sizes() {
+        let a = [0.5f32, -0.5];
+        let w = super::encode_f32(&[&a, &a], 48000);
+        assert_eq!(w.len(), 44 + 16);
+        assert_eq!(&w[0..4], b"RIFF");
+        assert_eq!(u32::from_le_bytes(w[40..44].try_into().unwrap()), 16);
+    }
+}
diff --git a/crates/text/Cargo.toml b/crates/text/Cargo.toml
new file mode 100644
index 000000000..d9f7f8e6e
--- /dev/null
+++ b/crates/text/Cargo.toml
@@ -0,0 +1,21 @@
+[package]
+name = "filmcraft-text"
+description = "FilmCraft text engine: font database (bundled + system), shaping, bidi, line breaking, paragraph layout and anti-aliased glyph/path rasterisation"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+rust-version.workspace = true
+
+[lints]
+workspace = true
+
+[dependencies]
+filmcraft-color = { workspace = true }
+# Font tables, glyph outlines and metrics (MIT OR Apache-2.0). Rasterisation is our own.
+skrifa = { version = "0.44", default-features = false, features = ["std"] }
+# OpenType shaping (HarfBuzz port on read-fonts, MIT); shares font parsing with skrifa.
+harfrust = { version = "0.12", default-features = false, features = ["std"] }
+# Unicode Bidirectional Algorithm (MIT OR Apache-2.0).
+unicode-bidi = "0.3.18"
+# UAX #14 line breaking (Apache-2.0).
+unicode-linebreak = "0.1.5"
diff --git a/crates/text/README.md b/crates/text/README.md
new file mode 100644
index 000000000..b55c0dab8
--- /dev/null
+++ b/crates/text/README.md
@@ -0,0 +1,30 @@
+# filmcraft-text
+
+FilmCraft's text engine (layer L1: depends on `filmcraft-color`, `skrifa`, `harfrust`,
+`unicode-bidi` and `unicode-linebreak`). It draws graphic-clip text and shapes, caption burn-in
+and the Timecode / Clip Name effects. Pure Rust; it builds for `wasm32-unknown-unknown`.
+
+| Module | What |
+|---|---|
+| `fonts` | Font database. Bundled faces (always present, also on the web): Inter Regular / Medium / SemiBold / Bold / Italic, JetBrains Mono Regular, Noto Serif Regular — all SIL OFL 1.1, unmodified, in `assets/fonts/` with `.attribution` sidecars. More faces come from `FontSource`s: `DirectorySource::system()` scans the platform font folders on first need (only the `name` and `OS/2` tables are read, via `sfnt`); on wasm the scan finds nothing and hosts can call `add_font_data`. `resolve(family, style)` picks a face, synthesises bold/italic when the family lacks them, and falls back to Inter (flagged `missing`). `fallback_for` finds a face for characters the chosen face lacks. |
+| `layout` | Paragraph layout: per-character font fallback → bidi levels (UAX #9) → items (runs of one face, direction and size) shaped with harfrust (OpenType kerning, ligatures, marks, complex scripts) → tracking → line breaking at UAX #14 opportunities (area text) → visual reordering per line → alignment (left / centre / right / justify), leading (added to the natural line height), baseline shift, all caps / synthesised small caps (78 %), underline. Every character boundary gets a caret stop (ligatures are split evenly), so editors can place carets, hit-test and draw selections. Layouts are cached by text + style (512 entries, LRU). |
+| `raster` | Our anti-aliased rasteriser (non-zero winding, 5 sub-scanlines, exact horizontal coverage, active-edge list), contour paths with transforms, rounded rectangles, ellipses, polygons and outline emboldening. Coverage is linear, so compositing in linear light is correct. |
+| `render` | Glyph outlines (cached per face + glyph) and glyph masks (cached per size in ⅛ px, ¼-px horizontal phase, synthetic style). Axis-aligned uniform transforms use the mask cache with sub-pixel x positioning; rotated / skewed / non-uniform transforms fill the transformed outlines of the whole run in one pass. Synthetic bold grows outlines by 2.5 % of the size; synthetic italic slants by 12°. |
+| `mask` | Outer / centre / inner strokes from an exact Euclidean distance transform (Felzenszwalb–Huttenlocher) with sub-pixel refinement, a three-pass box blur (≈ Gaussian) for shadows, offsets. |
+
+## Coordinates
+
+Pixels, y down. Point text: the origin is the alignment point on the first baseline (left edge,
+centre or right edge). Area text (`ParagraphStyle::width`): the origin is the box's top-left.
+
+## Performance
+
+A three-line, centred, 96 px bold title at 1080p (`perf::three_line_title_is_fast`), release build
+on an M-series Mac: about 1.6 ms cold (shaping, outline extraction, glyph rasterisation) and
+0.15 ms warm (layout cache + glyph cache). The test fails if the warm path exceeds 40 ms.
+
+## Not yet
+
+Per-character styling within one text layer (the whole layer has one style), vertical text, OpenType
+feature toggles beyond kerning/ligatures, variable-font axes, hinting, colour (emoji) glyphs, and
+hyphenation. Words longer than an area-text line overflow instead of breaking mid-word.
diff --git a/crates/text/src/fonts.rs b/crates/text/src/fonts.rs
new file mode 100644
index 000000000..809b7c2a6
--- /dev/null
+++ b/crates/text/src/fonts.rs
@@ -0,0 +1,474 @@
+//! The font database: bundled fonts (always available, also on the web) plus fonts discovered by
+//! [`FontSource`]s (system font folders on native platforms).
+//!
+//! Faces are addressed by [`FaceId`] (an index that never changes for the life of the process).
+//! [`resolve`] maps a family + style name (as stored in projects) to a face and the synthetic
+//! bold/italic needed when the family lacks that style. Unknown families fall back to Inter.
+
+use std::path::PathBuf;
+use std::sync::{Arc, OnceLock, RwLock};
+
+use skrifa::instance::{LocationRef, Size};
+use skrifa::{FontRef, MetadataProvider};
+
+use crate::sfnt::{FaceNames, read_faces, read_faces_bytes};
+
+/// Bundled fonts (SIL OFL 1.1; see `assets/fonts/*.attribution` and ATTRIBUTION.md).
+pub static INTER_REGULAR: &[u8] = include_bytes!("../../../assets/fonts/Inter-Regular.ttf");
+pub static INTER_MEDIUM: &[u8] = include_bytes!("../../../assets/fonts/Inter-Medium.ttf");
+pub static INTER_SEMIBOLD: &[u8] = include_bytes!("../../../assets/fonts/Inter-SemiBold.ttf");
+pub static INTER_BOLD: &[u8] = include_bytes!("../../../assets/fonts/Inter-Bold.ttf");
+pub static INTER_ITALIC: &[u8] = include_bytes!("../../../assets/fonts/Inter-Italic.ttf");
+pub static JETBRAINS_MONO_REGULAR: &[u8] = include_bytes!("../../../assets/fonts/JetBrainsMono-Regular.ttf");
+pub static NOTO_SERIF_REGULAR: &[u8] = include_bytes!("../../../assets/fonts/NotoSerif-Regular.ttf");
+
+/// The default family for new text.
+pub const DEFAULT_FAMILY: &str = "Inter";
+
+/// Index of a face in the database.
+pub type FaceId = usize;
+
+/// Where a face's bytes come from.
+#[derive(Clone, Debug)]
+pub enum FaceData {
+    Static(&'static [u8]),
+    Shared(Arc<Vec<u8>>),
+    /// A file read on first use.
+    File(PathBuf),
+}
+
+/// Description of a face offered by a [`FontSource`].
+#[derive(Clone, Debug)]
+pub struct FaceInfo {
+    pub family: String,
+    pub style: String,
+    pub weight: u16,
+    pub italic: bool,
+    pub index: u32,
+    pub data: FaceData,
+    /// "bundled", "system", …
+    pub origin: &'static str,
+}
+
+/// Something that can list fonts (system folders, a web font picker, a project's font folder…).
+pub trait FontSource: Send + Sync {
+    fn faces(&self) -> Vec<FaceInfo>;
+}
+
+/// Scans font folders on disk (reading only name tables). Native only; on the web there are no
+/// folders and the scan finds nothing.
+pub struct DirectorySource {
+    pub dirs: Vec<PathBuf>,
+}
+
+impl DirectorySource {
+    /// The platform's standard font folders.
+    pub fn system() -> Self {
+        let mut dirs: Vec<PathBuf> = Vec::new();
+        let home = std::env::var_os("HOME").map(PathBuf::from);
+        if cfg!(target_os = "macos") {
+            dirs.extend(["/System/Library/Fonts", "/Library/Fonts"].map(PathBuf::from));
+            if let Some(h) = &home {
+                dirs.push(h.join("Library/Fonts"));
+            }
+        } else if cfg!(windows) {
+            let win = std::env::var_os("WINDIR").map(PathBuf::from).unwrap_or_else(|| PathBuf::from("C:\\Windows"));
+            dirs.push(win.join("Fonts"));
+            if let Some(l) = std::env::var_os("LOCALAPPDATA") {
+                dirs.push(PathBuf::from(l).join("Microsoft\\Windows\\Fonts"));
+            }
+        } else if cfg!(unix) && !cfg!(target_arch = "wasm32") {
+            dirs.extend(["/usr/share/fonts", "/usr/local/share/fonts"].map(PathBuf::from));
+            if let Some(h) = &home {
+                dirs.push(h.join(".local/share/fonts"));
+                dirs.push(h.join(".fonts"));
+            }
+        }
+        Self { dirs }
+    }
+}
+
+fn walk(dir: &std::path::Path, depth: u32, out: &mut Vec<PathBuf>) {
+    let Ok(rd) = std::fs::read_dir(dir) else { return };
+    for e in rd.flatten() {
+        let p = e.path();
+        if p.is_dir() {
+            if depth < 4 {
+                walk(&p, depth + 1, out);
+            }
+        } else if p.extension().and_then(|x| x.to_str()).is_some_and(|x| matches!(x.to_ascii_lowercase().as_str(), "ttf" | "otf" | "ttc" | "otc")) {
+            out.push(p);
+        }
+    }
+}
+
+impl FontSource for DirectorySource {
+    fn faces(&self) -> Vec<FaceInfo> {
+        let mut files = Vec::new();
+        for d in &self.dirs {
+            walk(d, 0, &mut files);
+        }
+        files.sort();
+        let mut out = Vec::new();
+        for f in files {
+            let Ok(mut file) = std::fs::File::open(&f) else { continue };
+            for n in read_faces(&mut file) {
+                out.push(info_from(n, FaceData::File(f.clone()), "system"));
+            }
+        }
+        out
+    }
+}
+
+fn info_from(n: FaceNames, data: FaceData, origin: &'static str) -> FaceInfo {
+    FaceInfo { family: n.family, style: n.style, weight: n.weight, italic: n.italic, index: n.index, data, origin }
+}
+
+/// A loaded (or loadable) face.
+pub struct Face {
+    pub id: FaceId,
+    pub info: FaceInfo,
+    bytes: OnceLock<Option<FaceBytes>>,
+    shaper: OnceLock<harfrust::ShaperData>,
+}
+
+#[derive(Clone)]
+enum FaceBytes {
+    Static(&'static [u8]),
+    Shared(Arc<Vec<u8>>),
+}
+
+impl FaceBytes {
+    fn get(&self) -> &[u8] {
+        match self {
+            FaceBytes::Static(b) => b,
+            FaceBytes::Shared(b) => b,
+        }
+    }
+}
+
+/// Vertical metrics at a pixel size (all positive distances, y down from the baseline for the
+/// underline position).
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct VMetrics {
+    pub ascent: f32,
+    pub descent: f32,
+    pub line_gap: f32,
+    pub cap_height: f32,
+    pub x_height: f32,
+    pub underline_pos: f32,
+    pub underline_thickness: f32,
+}
+
+impl Face {
+    fn bytes(&self) -> Option<&[u8]> {
+        self.bytes
+            .get_or_init(|| match &self.info.data {
+                FaceData::Static(b) => Some(FaceBytes::Static(b)),
+                FaceData::Shared(b) => Some(FaceBytes::Shared(b.clone())),
+                FaceData::File(p) => std::fs::read(p).ok().map(|v| FaceBytes::Shared(Arc::new(v))),
+            })
+            .as_ref()
+            .map(FaceBytes::get)
+    }
+    /// The parsed font (None if the file is missing or unreadable).
+    pub fn font(&self) -> Option<FontRef<'_>> {
+        FontRef::from_index(self.bytes()?, self.info.index).ok()
+    }
+    pub(crate) fn shaper_data(&self) -> Option<&harfrust::ShaperData> {
+        let f = self.font()?;
+        Some(self.shaper.get_or_init(|| harfrust::ShaperData::new(&f)))
+    }
+    pub fn units_per_em(&self) -> f32 {
+        self.font().map(|f| f.metrics(Size::unscaled(), LocationRef::default()).units_per_em as f32).filter(|u| *u > 0.0).unwrap_or(1000.0)
+    }
+    /// Glyph for a character (None when the face does not cover it).
+    pub fn glyph(&self, c: char) -> Option<u32> {
+        self.font()?.charmap().map(c).map(|g| g.to_u32()).filter(|g| *g != 0)
+    }
+    pub fn has_char(&self, c: char) -> bool {
+        self.glyph(c).is_some()
+    }
+    pub fn metrics(&self, px: f32) -> VMetrics {
+        let Some(f) = self.font() else {
+            return VMetrics {
+                ascent: px * 0.8,
+                descent: px * 0.2,
+                cap_height: px * 0.7,
+                x_height: px * 0.5,
+                underline_pos: px * 0.1,
+                underline_thickness: px * 0.06,
+                ..Default::default()
+            };
+        };
+        let m = f.metrics(Size::new(px), LocationRef::default());
+        VMetrics {
+            ascent: m.ascent,
+            descent: -m.descent,
+            line_gap: m.leading,
+            cap_height: m.cap_height.unwrap_or(m.ascent * 0.7),
+            x_height: m.x_height.unwrap_or(m.ascent * 0.5),
+            underline_pos: m.underline.map_or(px * 0.1, |u| -u.offset),
+            underline_thickness: m.underline.map_or(px * 0.06, |u| u.thickness.max(px * 0.03)),
+        }
+    }
+    /// Whether the face's GSUB offers an OpenType feature (e.g. `smcp`).
+    pub fn has_feature(&self, tag: &[u8; 4]) -> bool {
+        use skrifa::raw::TableProvider;
+        let Some(f) = self.font() else { return false };
+        let Ok(gsub) = f.gsub() else { return false };
+        let Ok(list) = gsub.feature_list() else { return false };
+        list.feature_records().iter().any(|r| r.feature_tag().to_be_bytes() == *tag)
+    }
+}
+
+struct Db {
+    faces: Vec<Arc<Face>>,
+    scanned: bool,
+}
+
+fn db() -> &'static RwLock<Db> {
+    static DB: OnceLock<RwLock<Db>> = OnceLock::new();
+    DB.get_or_init(|| {
+        let mut db = Db { faces: Vec::new(), scanned: false };
+        for b in [INTER_REGULAR, INTER_MEDIUM, INTER_SEMIBOLD, INTER_BOLD, INTER_ITALIC, JETBRAINS_MONO_REGULAR, NOTO_SERIF_REGULAR] {
+            for n in read_faces_bytes(b) {
+                push(&mut db, info_from(n, FaceData::Static(b), "bundled"));
+            }
+        }
+        RwLock::new(db)
+    })
+}
+
+fn push(db: &mut Db, info: FaceInfo) -> FaceId {
+    let id = db.faces.len();
+    db.faces.push(Arc::new(Face { id, info, bytes: OnceLock::new(), shaper: OnceLock::new() }));
+    id
+}
+
+/// Add faces from a source (skipping family+style pairs already present). Returns how many were
+/// added.
+pub fn add_source(src: &dyn FontSource) -> usize {
+    let faces = src.faces();
+    let mut d = db().write().unwrap_or_else(|e| e.into_inner());
+    let mut n = 0;
+    for f in faces {
+        let dup = d.faces.iter().any(|g| g.info.family.eq_ignore_ascii_case(&f.family) && g.info.style.eq_ignore_ascii_case(&f.style));
+        if !dup {
+            push(&mut d, f);
+            n += 1;
+        }
+    }
+    n
+}
+
+/// Register a font from memory (e.g. a font file the user picked on the web). Returns its faces.
+pub fn add_font_data(data: Vec<u8>) -> Vec<FaceId> {
+    let data = Arc::new(data);
+    let names = read_faces_bytes(&data);
+    let mut d = db().write().unwrap_or_else(|e| e.into_inner());
+    names.into_iter().map(|n| push(&mut d, info_from(n, FaceData::Shared(data.clone()), "user"))).collect()
+}
+
+/// Scan the system font folders once (native only; a no-op on wasm). Returns the number of faces
+/// added by this call.
+pub fn scan_system() -> usize {
+    // Held for the whole scan: a concurrent caller waits for the complete list instead of
+    // returning early and resolving against a half-filled database.
+    static SCAN: std::sync::Mutex<()> = std::sync::Mutex::new(());
+    let _scan = SCAN.lock().unwrap_or_else(|e| e.into_inner());
+    if system_scanned() {
+        return 0;
+    }
+    let n = if cfg!(target_arch = "wasm32") { 0 } else { add_source(&DirectorySource::system()) };
+    db().write().unwrap_or_else(|e| e.into_inner()).scanned = true;
+    n
+}
+
+pub fn system_scanned() -> bool {
+    db().read().unwrap_or_else(|e| e.into_inner()).scanned
+}
+
+/// A face by id (panics never: unknown ids give the default face).
+pub fn face(id: FaceId) -> Arc<Face> {
+    let d = db().read().unwrap_or_else(|e| e.into_inner());
+    d.faces.get(id).or_else(|| d.faces.first()).cloned().expect("bundled fonts present")
+}
+
+/// All faces (bundled first).
+pub fn all_faces() -> Vec<Arc<Face>> {
+    db().read().unwrap_or_else(|e| e.into_inner()).faces.clone()
+}
+
+/// Families with their style names, sorted by family; styles in weight order.
+pub fn families() -> Vec<(String, Vec<String>)> {
+    let mut m: std::collections::BTreeMap<String, Vec<(bool, u16, String)>> = Default::default();
+    for f in all_faces() {
+        let v = m.entry(f.info.family.clone()).or_default();
+        if !v.iter().any(|(_, _, s)| s == &f.info.style) {
+            v.push((f.info.italic, f.info.weight, f.info.style.clone()));
+        }
+    }
+    m.into_iter()
+        .map(|(k, mut v)| {
+            v.sort();
+            (k, v.into_iter().map(|(_, _, s)| s).collect())
+        })
+        .collect()
+}
+
+/// The face chosen for a family/style request, plus synthetic emboldening / slant when the family
+/// lacks a real bold / italic.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub struct Resolved {
+    pub face: FaceId,
+    pub synth_bold: bool,
+    pub synth_italic: bool,
+    /// The requested family was not found (Premiere shows such fonts as missing).
+    pub missing: bool,
+}
+
+fn style_wants(style: &str) -> (u16, bool) {
+    let s = style.to_ascii_lowercase().replace([' ', '-'], "");
+    let italic = s.contains("italic") || s.contains("oblique");
+    let w = if s.contains("thin") || s.contains("hairline") {
+        100
+    } else if s.contains("extralight") || s.contains("ultralight") {
+        200
+    } else if s.contains("light") {
+        300
+    } else if s.contains("medium") {
+        500
+    } else if s.contains("semibold") || s.contains("demibold") {
+        600
+    } else if s.contains("extrabold") || s.contains("ultrabold") {
+        800
+    } else if s.contains("black") || s.contains("heavy") {
+        900
+    } else if s.contains("bold") {
+        700
+    } else {
+        400
+    };
+    (w, italic)
+}
+
+/// Resolve a family + style name. Family matching is case-insensitive; a style that the family
+/// lacks picks the nearest weight and synthesises bold (≥ 600 requested, ≤ 500 found) or italic.
+pub fn resolve(family: &str, style: &str) -> Resolved {
+    if let Some(r) = resolve_in(family, style) {
+        return r;
+    }
+    if !system_scanned() && !family.is_empty() && !family.eq_ignore_ascii_case(DEFAULT_FAMILY) {
+        scan_system();
+        if let Some(r) = resolve_in(family, style) {
+            return r;
+        }
+    }
+    let mut r = resolve_in(DEFAULT_FAMILY, style).expect("Inter is bundled");
+    r.missing = !family.is_empty() && !family.eq_ignore_ascii_case(DEFAULT_FAMILY);
+    r
+}
+
+fn resolve_in(family: &str, style: &str) -> Option<Resolved> {
+    let faces = all_faces();
+    let fam: Vec<&Arc<Face>> = faces.iter().filter(|f| f.info.family.eq_ignore_ascii_case(family)).collect();
+    if fam.is_empty() {
+        return None;
+    }
+    if let Some(f) = fam.iter().find(|f| f.info.style.eq_ignore_ascii_case(style)) {
+        return Some(Resolved { face: f.id, synth_bold: false, synth_italic: false, missing: false });
+    }
+    let (w, it) = style_wants(style);
+    let best = fam
+        .iter()
+        .min_by_key(|f| {
+            let italic_pen = if f.info.italic == it { 0 } else { 1000 };
+            italic_pen + (f.info.weight as i32 - w as i32).unsigned_abs()
+        })
+        .expect("non-empty");
+    Some(Resolved { face: best.id, synth_bold: w >= 600 && best.info.weight <= 500, synth_italic: it && !best.info.italic, missing: false })
+}
+
+/// A face that covers `c`, preferring `prefer`; bundled and already-registered faces are searched.
+pub fn fallback_for(c: char, prefer: FaceId) -> FaceId {
+    let p = face(prefer);
+    if p.has_char(c) || c.is_control() {
+        return prefer;
+    }
+    let faces = all_faces();
+    // prefer a face of the same italic-ness that is bundled (cheap), then anything loaded already
+    for f in faces.iter().filter(|f| f.info.origin == "bundled") {
+        if f.has_char(c) {
+            return f.id;
+        }
+    }
+    for f in faces.iter().filter(|f| f.info.origin != "bundled" && f.bytes.get().is_some()) {
+        if f.has_char(c) {
+            return f.id;
+        }
+    }
+    prefer
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn bundled_families_and_resolution() {
+        let fams = families();
+        let inter = fams.iter().find(|(f, _)| f == "Inter").expect("Inter");
+        for s in ["Regular", "Medium", "SemiBold", "Bold", "Italic"] {
+            assert!(inter.1.iter().any(|x| x == s), "{s} in {:?}", inter.1);
+        }
+        assert!(fams.iter().any(|(f, _)| f == "Noto Serif"));
+        assert!(fams.iter().any(|(f, _)| f == "JetBrains Mono"));
+        let b = resolve("inter", "bold");
+        assert_eq!(face(b.face).info.style, "Bold");
+        assert!(!b.synth_bold);
+        // Noto Serif has only Regular: Bold Italic is synthesised
+        let s = resolve("Noto Serif", "Bold Italic");
+        assert_eq!(face(s.face).info.family, "Noto Serif");
+        assert!(s.synth_bold && s.synth_italic);
+        // Inter Bold Italic: nearest is Italic (400) → synth bold
+        let bi = resolve("Inter", "Bold Italic");
+        assert!(face(bi.face).info.italic && bi.synth_bold && !bi.synth_italic);
+    }
+
+    #[test]
+    fn missing_family_falls_back_to_inter() {
+        let r = resolve("No Such Font Family 123", "Regular");
+        assert_eq!(face(r.face).info.family, "Inter");
+        assert!(r.missing);
+    }
+
+    /// Native: the system scan reads name tables only and resolves families installed there.
+    #[test]
+    fn system_scan_finds_fonts() {
+        let t = std::time::Instant::now();
+        scan_system(); // (another test may have triggered the scan already)
+        let n = all_faces().iter().filter(|f| f.info.origin == "system").count();
+        eprintln!("system fonts: {n} faces in {:?}", t.elapsed());
+        assert_eq!(scan_system(), 0, "scans once");
+        if cfg!(target_os = "macos") {
+            assert!(n > 20, "{n}");
+            let r = resolve("Helvetica", "Bold");
+            assert_eq!(face(r.face).info.family, "Helvetica");
+            let l = crate::layout("Helvetica", &crate::TextStyle { family: "Helvetica".into(), size: 30.0, ..Default::default() }, &Default::default());
+            assert!(!l.missing_font && l.glyphs.iter().all(|g| g.id != 0));
+        }
+    }
+
+    #[test]
+    fn metrics_and_coverage() {
+        let f = face(resolve("Inter", "Regular").face);
+        let m = f.metrics(100.0);
+        assert!(m.ascent > 80.0 && m.ascent < 110.0, "{m:?}");
+        assert!(m.descent > 10.0 && m.descent < 40.0);
+        assert!(m.cap_height > 60.0 && m.cap_height < 80.0);
+        assert!(f.has_char('A') && f.has_char('Ж'));
+        assert!(!f.has_char('\u{5d0}'), "Inter has no Hebrew");
+        assert!(f.has_feature(b"liga") || f.has_feature(b"calt"));
+    }
+}
diff --git a/crates/text/src/layout.rs b/crates/text/src/layout.rs
new file mode 100644
index 000000000..59c4941d8
--- /dev/null
+++ b/crates/text/src/layout.rs
@@ -0,0 +1,723 @@
+//! Paragraph layout: font fallback, bidi (UAX #9), shaping (OpenType via harfrust: kerning,
+//! ligatures, mark positioning, complex scripts), line breaking (UAX #14), alignment, leading,
+//! tracking, baseline shift, all caps / small caps, underline. Results are cached.
+//!
+//! Coordinates are pixels, y down. For **point text** (`ParagraphStyle::width == None`) the
+//! origin is the alignment point on the first baseline: x = 0 is the left edge (left / justify),
+//! the centre (centre) or the right edge (right). For **area text** (`width == Some(w)`) the
+//! origin is the top-left of the text box and lines wrap at `w`.
+
+use std::collections::HashMap;
+use std::hash::{Hash, Hasher};
+use std::ops::Range;
+use std::sync::{Arc, Mutex, OnceLock};
+
+use harfrust::{Direction, Feature, Tag, UnicodeBuffer};
+use unicode_bidi::{BidiInfo, Level};
+
+use crate::fonts::{self, FaceId, Resolved};
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
+pub enum Caps {
+    #[default]
+    Normal,
+    All,
+    Small,
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
+pub enum Align {
+    #[default]
+    Left,
+    Center,
+    Right,
+    Justify,
+}
+
+/// Character formatting.
+#[derive(Clone, Debug, PartialEq)]
+pub struct TextStyle {
+    pub family: String,
+    pub style: String,
+    /// Font size in pixels.
+    pub size: f32,
+    /// Tracking in 1/1000 em (added after every cluster).
+    pub tracking: f32,
+    /// Metric kerning (`kern`).
+    pub kerning: bool,
+    /// Standard ligatures (`liga`, `clig`).
+    pub ligatures: bool,
+    /// Baseline shift in pixels (positive = up).
+    pub baseline_shift: f32,
+    pub faux_bold: bool,
+    pub faux_italic: bool,
+    pub caps: Caps,
+    pub underline: bool,
+}
+
+impl Default for TextStyle {
+    fn default() -> Self {
+        Self {
+            family: fonts::DEFAULT_FAMILY.into(),
+            style: "Regular".into(),
+            size: 100.0,
+            tracking: 0.0,
+            kerning: true,
+            ligatures: true,
+            baseline_shift: 0.0,
+            faux_bold: false,
+            faux_italic: false,
+            caps: Caps::Normal,
+            underline: false,
+        }
+    }
+}
+
+/// Paragraph formatting.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct ParagraphStyle {
+    pub align: Align,
+    /// Extra line spacing in pixels added to the font's natural line height (Premiere's Leading).
+    pub leading: f32,
+    /// Wrap width (area text); None = point text.
+    pub width: Option<f32>,
+    /// Base direction: None = from the first strong character.
+    pub rtl: Option<bool>,
+}
+
+fn hf(h: &mut impl Hasher, v: f32) {
+    v.to_bits().hash(h);
+}
+
+impl Hash for TextStyle {
+    fn hash<H: Hasher>(&self, h: &mut H) {
+        self.family.hash(h);
+        self.style.hash(h);
+        hf(h, self.size);
+        hf(h, self.tracking);
+        hf(h, self.baseline_shift);
+        (self.kerning, self.ligatures, self.faux_bold, self.faux_italic, self.caps, self.underline).hash(h);
+    }
+}
+
+impl Hash for ParagraphStyle {
+    fn hash<H: Hasher>(&self, h: &mut H) {
+        self.align.hash(h);
+        hf(h, self.leading);
+        self.width.map(f32::to_bits).hash(h);
+        self.rtl.hash(h);
+    }
+}
+
+/// A positioned glyph. `(x, y)` is the glyph origin on its baseline.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Glyph {
+    pub face: FaceId,
+    pub id: u32,
+    pub x: f32,
+    pub y: f32,
+    pub size: f32,
+    /// Byte offset of the cluster in the source text.
+    pub cluster: usize,
+    pub synth_bold: bool,
+    pub synth_italic: bool,
+}
+
+/// One laid-out line.
+#[derive(Clone, Debug, PartialEq)]
+pub struct Line {
+    /// Byte range in the source text (without the terminating newline).
+    pub range: Range<usize>,
+    pub baseline: f32,
+    /// Left edge and width of the line's content (trailing spaces excluded).
+    pub x: f32,
+    pub width: f32,
+    pub ascent: f32,
+    pub descent: f32,
+    pub glyphs: Range<usize>,
+    /// Caret stops `(byte offset, x)` for every character boundary in the line, by byte offset.
+    pub carets: Vec<(usize, f32)>,
+}
+
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct Layout {
+    pub glyphs: Vec<Glyph>,
+    pub lines: Vec<Line>,
+    /// Underline rectangles `[x0, y0, x1, y1]`.
+    pub underlines: Vec<[f32; 4]>,
+    /// Logical bounds `[x0, y0, x1, y1]` (line boxes; area text spans the box width).
+    pub bounds: [f32; 4],
+    /// The face requested was missing (substituted).
+    pub missing_font: bool,
+    pub text_len: usize,
+}
+
+impl Layout {
+    /// Line index for a caret at byte `pos`.
+    pub fn line_of(&self, pos: usize) -> usize {
+        let mut li = 0;
+        for (i, l) in self.lines.iter().enumerate() {
+            if l.range.start <= pos {
+                li = i;
+            }
+        }
+        li
+    }
+    /// Caret position `(x, baseline, line)` for byte offset `pos`.
+    pub fn caret(&self, pos: usize) -> (f32, f32, usize) {
+        let li = self.line_of(pos);
+        let Some(l) = self.lines.get(li) else { return (0.0, 0.0, 0) };
+        let x = l.carets.iter().min_by_key(|(b, _)| b.abs_diff(pos)).map_or(l.x, |c| c.1);
+        (x, l.baseline, li)
+    }
+    /// Nearest caret byte offset to point `(x, y)`.
+    pub fn hit(&self, x: f32, y: f32) -> usize {
+        let Some(l) = self.lines.iter().min_by(|a, b| line_dist(a, y).total_cmp(&line_dist(b, y))) else {
+            return 0;
+        };
+        l.carets.iter().min_by(|a, b| (a.1 - x).abs().total_cmp(&(b.1 - x).abs())).map_or(l.range.start, |c| c.0)
+    }
+    /// Selection highlight rectangles `[x0, y0, x1, y1]` for the byte range `a..b`.
+    pub fn selection_rects(&self, a: usize, b: usize) -> Vec<[f32; 4]> {
+        let (a, b) = (a.min(b), a.max(b));
+        let mut out = Vec::new();
+        for l in &self.lines {
+            let s = a.max(l.range.start);
+            let e = b.min(l.range.end);
+            if s > e || (s == e && !(a < l.range.start && b > l.range.end)) {
+                continue;
+            }
+            let xs: Vec<f32> = l.carets.iter().filter(|(p, _)| *p >= s && *p <= e).map(|c| c.1).collect();
+            if xs.len() < 2 && b <= l.range.end {
+                continue;
+            }
+            let x0 = xs.iter().copied().fold(f32::MAX, f32::min);
+            let mut x1 = xs.iter().copied().fold(f32::MIN, f32::max);
+            if b > l.range.end {
+                x1 += l.ascent * 0.25; // selected newline
+            }
+            out.push([x0.min(x1), l.baseline - l.ascent, x1, l.baseline + l.descent]);
+        }
+        out
+    }
+}
+
+fn line_dist(l: &Line, y: f32) -> f32 {
+    let (t, b) = (l.baseline - l.ascent, l.baseline + l.descent);
+    if y < t {
+        t - y
+    } else if y > b {
+        y - b
+    } else {
+        0.0
+    }
+}
+
+struct ShapedGlyph {
+    face: FaceId,
+    id: u32,
+    cluster: usize,
+    adv: f32,
+    dx: f32,
+    dy: f32,
+    size: f32,
+}
+
+struct Item {
+    range: Range<usize>,
+    rtl: bool,
+    glyphs: Vec<ShapedGlyph>,
+}
+
+fn upper_single(c: char) -> char {
+    let mut u = c.to_uppercase();
+    match (u.next(), u.next()) {
+        (Some(x), None) => x,
+        _ => c,
+    }
+}
+
+const SMALL_CAPS_SCALE: f32 = 0.78;
+
+fn shape_item(text: &str, chars: &[(usize, char, char)], rtl: bool, face: FaceId, size: f32, style: &TextStyle) -> Vec<ShapedGlyph> {
+    let f = fonts::face(face);
+    let (Some(font), Some(data)) = (f.font(), f.shaper_data()) else { return Vec::new() };
+    let shaper = data.shaper(&font).build();
+    let mut buf = UnicodeBuffer::new();
+    for &(b, _, sc) in chars {
+        buf.add(if sc == '\t' { ' ' } else { sc }, b as u32);
+    }
+    buf.set_direction(if rtl { Direction::RightToLeft } else { Direction::LeftToRight });
+    buf.guess_segment_properties();
+    let mut feats = Vec::new();
+    if !style.kerning {
+        feats.push(Feature::new(Tag::new(b"kern"), 0, ..));
+    }
+    if !style.ligatures {
+        feats.push(Feature::new(Tag::new(b"liga"), 0, ..));
+        feats.push(Feature::new(Tag::new(b"clig"), 0, ..));
+    }
+    let out = shaper.shape(buf, harfrust::ShapeOptions::new().features(&feats));
+    let k = size / f.units_per_em();
+    let _ = text;
+    out.glyph_infos()
+        .iter()
+        .zip(out.glyph_positions())
+        .map(|(i, p)| ShapedGlyph {
+            face,
+            id: i.glyph_id,
+            cluster: i.cluster as usize,
+            adv: p.x_advance as f32 * k,
+            dx: p.x_offset as f32 * k,
+            dy: p.y_offset as f32 * k,
+            size,
+        })
+        .collect()
+}
+
+struct ParaLine {
+    range: Range<usize>,
+    glyphs: Vec<Glyph>,
+    carets: Vec<(usize, f32)>,
+    content: f32,
+    left_trim: f32,
+    ascent: f32,
+    descent: f32,
+}
+
+/// Lay out one paragraph (no newlines) whose text starts at byte `base` of the whole string.
+fn paragraph(text: &str, base: usize, style: &TextStyle, para: &ParagraphStyle, primary: Resolved) -> Vec<ParaLine> {
+    let pm = fonts::face(primary.face).metrics(style.size);
+    if text.is_empty() {
+        return vec![ParaLine {
+            range: base..base,
+            glyphs: vec![],
+            carets: vec![(base, 0.0)],
+            content: 0.0,
+            left_trim: 0.0,
+            ascent: pm.ascent,
+            descent: pm.descent,
+        }];
+    }
+    let default_level = para.rtl.map(|r| if r { Level::rtl() } else { Level::ltr() });
+    let bidi = BidiInfo::new(text, default_level);
+    let pinfo = &bidi.paragraphs[0];
+    let base_rtl = pinfo.level.is_rtl();
+    // per char: (byte, char, shaped char), face, level, small
+    let chars: Vec<(usize, char, char, FaceId, bool, bool)> = text
+        .char_indices()
+        .map(|(b, c)| {
+            let (sc, small) = match style.caps {
+                Caps::Normal => (c, false),
+                Caps::All => (upper_single(c), false),
+                Caps::Small if c.is_lowercase() => (upper_single(c), true),
+                Caps::Small => (c, false),
+            };
+            let face = if sc.is_whitespace() { primary.face } else { fonts::fallback_for(sc, primary.face) };
+            (b, c, sc, face, bidi.levels[b].is_rtl(), small)
+        })
+        .collect();
+    // items: runs of equal (face, rtl, small)
+    let mut items: Vec<Item> = Vec::new();
+    let mut i = 0;
+    while i < chars.len() {
+        let (face, rtl, small) = (chars[i].3, chars[i].4, chars[i].5);
+        let mut j = i + 1;
+        while j < chars.len() && chars[j].3 == face && chars[j].4 == rtl && chars[j].5 == small {
+            j += 1;
+        }
+        let sub: Vec<(usize, char, char)> = chars[i..j].iter().map(|c| (c.0, c.1, c.2)).collect();
+        let size = if small { style.size * SMALL_CAPS_SCALE } else { style.size };
+        let mut glyphs = shape_item(text, &sub, rtl, face, size, style);
+        // tracking after each cluster
+        if style.tracking != 0.0 {
+            let t = style.tracking * style.size / 1000.0;
+            for k in 0..glyphs.len() {
+                if k + 1 == glyphs.len() || glyphs[k + 1].cluster != glyphs[k].cluster {
+                    glyphs[k].adv += t;
+                }
+            }
+        }
+        let end = if j < chars.len() { chars[j].0 } else { text.len() };
+        items.push(Item { range: chars[i].0..end, rtl, glyphs });
+        i = j;
+    }
+    // advance per char byte (cluster start)
+    let mut char_adv = vec![0.0f32; text.len() + 1];
+    for it in &items {
+        for g in &it.glyphs {
+            char_adv[g.cluster.min(text.len())] += g.adv;
+        }
+    }
+    let range_w = |r: Range<usize>| -> f32 { char_adv[r].iter().sum() };
+    let trailing_ws = |r: &Range<usize>| -> (usize, f32) {
+        let mut end = r.end;
+        let mut w = 0.0;
+        for (b, c) in text[r.clone()].char_indices().rev() {
+            if !c.is_whitespace() {
+                break;
+            }
+            end = r.start + b;
+            w += char_adv[r.start + b];
+        }
+        (end, w)
+    };
+    // line breaking
+    let mut ranges: Vec<Range<usize>> = Vec::new();
+    match para.width {
+        None => ranges.push(0..text.len()),
+        Some(maxw) => {
+            let mut start = 0usize;
+            let mut last_ok: Option<usize> = None;
+            for (p, _) in unicode_linebreak::linebreaks(text) {
+                loop {
+                    let r = start..p;
+                    let (ce, _) = trailing_ws(&r);
+                    let w = range_w(start..ce);
+                    if w <= maxw || last_ok.is_none() {
+                        last_ok = Some(p);
+                        break;
+                    }
+                    let b = last_ok.take().expect("checked");
+                    ranges.push(start..b);
+                    start = b;
+                }
+            }
+            ranges.push(start..text.len());
+            ranges.retain(|r| !r.is_empty());
+            if ranges.is_empty() {
+                ranges.push(0..text.len());
+            }
+        }
+    }
+    let nlines = ranges.len();
+    let mut out = Vec::new();
+    for (li, r) in ranges.into_iter().enumerate() {
+        let (ce, tw) = trailing_ws(&r);
+        let content = range_w(r.start..ce);
+        // justification
+        let mut space_extra = 0.0;
+        if para.align == Align::Justify
+            && li + 1 < nlines
+            && let Some(maxw) = para.width
+        {
+            let spaces = text[r.start..ce].chars().filter(|c| *c == ' ').count();
+            if spaces > 0 {
+                space_extra = ((maxw - content) / spaces as f32).max(0.0);
+            }
+        }
+        let (levels, runs) = bidi.visual_runs(pinfo, r.clone());
+        let mut pen = 0.0f32;
+        let mut glyphs = Vec::new();
+        let mut extents: HashMap<usize, (f32, f32, bool)> = HashMap::new();
+        for run in runs {
+            let rtl = levels[run.start].is_rtl();
+            let mut idx: Vec<usize> = (0..items.len()).filter(|&k| items[k].range.start < run.end && items[k].range.end > run.start).collect();
+            if rtl {
+                idx.reverse();
+            }
+            for k in idx {
+                for g in items[k].glyphs.iter().filter(|g| run.contains(&g.cluster)) {
+                    let x0 = pen;
+                    glyphs.push(Glyph {
+                        face: g.face,
+                        id: g.id,
+                        x: pen + g.dx,
+                        y: -g.dy - style.baseline_shift,
+                        size: g.size,
+                        cluster: base + g.cluster,
+                        synth_bold: primary.synth_bold || style.faux_bold,
+                        synth_italic: primary.synth_italic || style.faux_italic,
+                    });
+                    pen += g.adv;
+                    if space_extra > 0.0 && text[g.cluster..].starts_with(' ') && g.cluster < ce {
+                        pen += space_extra;
+                    }
+                    let e = extents.entry(g.cluster).or_insert((x0, pen, items[k].rtl));
+                    e.0 = e.0.min(x0);
+                    e.1 = e.1.max(pen);
+                }
+            }
+        }
+        // caret stops for each char boundary in the line
+        let mut carets = Vec::new();
+        let mut cluster_starts: Vec<usize> = extents.keys().copied().collect();
+        cluster_starts.sort_unstable();
+        let char_bytes: Vec<usize> = text[r.clone()].char_indices().map(|(b, _)| r.start + b).collect();
+        for (ci, &cs) in cluster_starts.iter().enumerate() {
+            let (x0, x1, rtl) = extents[&cs];
+            let next = cluster_starts.get(ci + 1).copied().unwrap_or(r.end);
+            let members: Vec<usize> = char_bytes.iter().copied().filter(|b| *b >= cs && *b < next).collect();
+            let n = members.len().max(1) as f32;
+            for (mi, b) in members.iter().enumerate() {
+                let f = mi as f32 / n;
+                let x = if rtl { x1 - (x1 - x0) * f } else { x0 + (x1 - x0) * f };
+                carets.push((base + b, x));
+            }
+        }
+        // end of line caret
+        let end_x = match chars.iter().rev().find(|c| c.0 < r.end && c.0 >= r.start) {
+            Some(c) => {
+                let cs = cluster_starts.iter().rev().find(|s| **s <= c.0).copied();
+                match cs.and_then(|s| extents.get(&s)) {
+                    Some(&(x0, x1, rtl)) => {
+                        if rtl {
+                            x0
+                        } else {
+                            x1
+                        }
+                    }
+                    None => pen,
+                }
+            }
+            None => 0.0,
+        };
+        carets.push((base + r.end, end_x));
+        carets.sort_by_key(|c| c.0);
+        carets.dedup_by_key(|c| c.0);
+        let mut asc = pm.ascent;
+        let mut desc = pm.descent;
+        for g in &glyphs {
+            if g.face != primary.face {
+                let m = fonts::face(g.face).metrics(g.size);
+                asc = asc.max(m.ascent);
+                desc = desc.max(m.descent);
+            }
+        }
+        let content_w = if space_extra > 0.0 { para.width.unwrap_or(content) } else { content };
+        out.push(ParaLine {
+            range: base + r.start..base + r.end,
+            glyphs,
+            carets,
+            content: content_w,
+            left_trim: if base_rtl { tw } else { 0.0 },
+            ascent: asc,
+            descent: desc,
+        });
+    }
+    out
+}
+
+/// Lay out `text` (paragraphs separated by `\n`).
+pub fn layout_uncached(text: &str, style: &TextStyle, para: &ParagraphStyle) -> Layout {
+    let primary = fonts::resolve(&style.family, &style.style);
+    let pm = fonts::face(primary.face).metrics(style.size);
+    let line_h = (pm.ascent + pm.descent + pm.line_gap).max(style.size * 0.5) + para.leading;
+    let mut lay = Layout { missing_font: primary.missing, text_len: text.len(), ..Default::default() };
+    let mut base = 0usize;
+    let mut plines = Vec::new();
+    for p in text.split('\n') {
+        let p_clean = p.strip_suffix('\r').unwrap_or(p);
+        plines.extend(paragraph(p_clean, base, style, para, primary));
+        base += p.len() + 1;
+    }
+    let first_baseline = if para.width.is_some() { pm.ascent } else { 0.0 };
+    for (i, pl) in plines.into_iter().enumerate() {
+        let baseline = first_baseline + line_h * i as f32;
+        let shift = match (para.width, para.align) {
+            (None, Align::Left | Align::Justify) => 0.0,
+            (None, Align::Center) => -pl.content / 2.0,
+            (None, Align::Right) => -pl.content,
+            (Some(_), Align::Left | Align::Justify) => 0.0,
+            (Some(w), Align::Center) => (w - pl.content) / 2.0,
+            (Some(w), Align::Right) => w - pl.content,
+        } - pl.left_trim;
+        let g0 = lay.glyphs.len();
+        lay.glyphs.extend(pl.glyphs.into_iter().map(|mut g| {
+            g.x += shift;
+            g.y += baseline;
+            g
+        }));
+        let x = shift + pl.left_trim;
+        if style.underline && pl.content > 0.0 {
+            lay.underlines.push([x, baseline + pm.underline_pos, x + pl.content, baseline + pm.underline_pos + pm.underline_thickness]);
+        }
+        lay.lines.push(Line {
+            range: pl.range,
+            baseline,
+            x,
+            width: pl.content,
+            ascent: pl.ascent,
+            descent: pl.descent,
+            glyphs: g0..lay.glyphs.len(),
+            carets: pl.carets.into_iter().map(|(b, cx)| (b, cx + shift)).collect(),
+        });
+    }
+    let (mut x0, mut x1) = (f32::MAX, f32::MIN);
+    for l in &lay.lines {
+        x0 = x0.min(l.x);
+        x1 = x1.max(l.x + l.width);
+    }
+    if let Some(w) = para.width {
+        x0 = 0.0;
+        x1 = x1.max(w);
+    }
+    let first = &lay.lines[0];
+    let last = lay.lines.last().expect("at least one line");
+    lay.bounds = [x0, first.baseline - first.ascent, x1.max(x0), last.baseline + last.descent];
+    lay
+}
+
+fn cache() -> &'static Mutex<HashMap<u64, (u64, Arc<Layout>)>> {
+    static C: OnceLock<Mutex<HashMap<u64, (u64, Arc<Layout>)>>> = OnceLock::new();
+    C.get_or_init(Default::default)
+}
+
+/// Lay out `text` (cached by text and styles).
+pub fn layout(text: &str, style: &TextStyle, para: &ParagraphStyle) -> Arc<Layout> {
+    let mut h = std::collections::hash_map::DefaultHasher::new();
+    text.hash(&mut h);
+    style.hash(&mut h);
+    para.hash(&mut h);
+    let key = h.finish();
+    static CLOCK: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
+    let now = CLOCK.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+    if let Some(e) = cache().lock().unwrap_or_else(|e| e.into_inner()).get_mut(&key) {
+        e.0 = now;
+        return e.1.clone();
+    }
+    let l = Arc::new(layout_uncached(text, style, para));
+    let mut c = cache().lock().unwrap_or_else(|e| e.into_inner());
+    if c.len() >= 512 {
+        // evict the oldest quarter
+        let mut ages: Vec<u64> = c.values().map(|v| v.0).collect();
+        ages.sort_unstable();
+        let cut = ages[ages.len() / 4];
+        c.retain(|_, v| v.0 > cut);
+    }
+    c.insert(key, (now, l.clone()));
+    l
+}
+
+/// Width of a single line of `text` (no wrapping).
+pub fn measure(text: &str, style: &TextStyle) -> f32 {
+    let l = layout(text, style, &ParagraphStyle::default());
+    l.lines.iter().map(|l| l.width).fold(0.0, f32::max)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn st(size: f32) -> TextStyle {
+        TextStyle { size, ..Default::default() }
+    }
+
+    #[test]
+    fn kerning_and_ligatures_change_advances() {
+        let kern = measure("AVAVAV", &st(100.0));
+        let nokern = measure("AVAVAV", &TextStyle { kerning: false, ..st(100.0) });
+        assert!(kern < nokern - 5.0, "kerning tightens AV: {kern} vs {nokern}");
+        // tracking adds 1/1000 em per cluster
+        let tracked = measure("AVAVAV", &TextStyle { tracking: 100.0, ..st(100.0) });
+        assert!((tracked - kern - 6.0 * 10.0).abs() < 0.5, "{tracked} {kern}");
+    }
+
+    #[test]
+    fn point_text_alignment() {
+        let l = layout("Hello", &st(50.0), &ParagraphStyle { align: Align::Center, ..Default::default() });
+        let line = &l.lines[0];
+        assert!((line.x + line.width / 2.0).abs() < 0.01);
+        let r = layout("Hello", &st(50.0), &ParagraphStyle { align: Align::Right, ..Default::default() });
+        assert!((r.lines[0].x + r.lines[0].width).abs() < 0.01);
+        assert_eq!(l.glyphs.len(), 5);
+        assert!(l.bounds[1] < -30.0 && l.bounds[3] > 5.0, "{:?}", l.bounds);
+    }
+
+    #[test]
+    fn wraps_area_text_and_justifies() {
+        let p = ParagraphStyle { width: Some(300.0), align: Align::Justify, ..Default::default() };
+        let l = layout("the quick brown fox jumps over the lazy dog again and again", &st(40.0), &p);
+        assert!(l.lines.len() >= 3, "{}", l.lines.len());
+        for line in &l.lines[..l.lines.len() - 1] {
+            assert!((line.width - 300.0).abs() < 0.5, "justified to the box: {}", line.width);
+        }
+        // the lines tile the text
+        assert_eq!(l.lines[0].range.start, 0);
+        for w in l.lines.windows(2) {
+            assert_eq!(w[0].range.end, w[1].range.start);
+            assert!(w[1].baseline > w[0].baseline);
+        }
+        let left = layout("the quick brown fox jumps over the lazy dog", &st(40.0), &ParagraphStyle { width: Some(300.0), ..Default::default() });
+        assert!(left.lines.iter().all(|l| l.width <= 300.0 + 0.01));
+    }
+
+    #[test]
+    fn newlines_make_paragraphs_and_leading_adds() {
+        let l = layout("one\ntwo\n\nfour", &st(30.0), &ParagraphStyle::default());
+        assert_eq!(l.lines.len(), 4);
+        assert_eq!(l.lines[1].range, 4..7);
+        assert_eq!(l.lines[2].range, 8..8);
+        let gap = l.lines[1].baseline - l.lines[0].baseline;
+        let l2 = layout("one\ntwo", &st(30.0), &ParagraphStyle { leading: 10.0, ..Default::default() });
+        assert!((l2.lines[1].baseline - l2.lines[0].baseline - gap - 10.0).abs() < 1e-3);
+    }
+
+    #[test]
+    fn carets_and_hit_testing() {
+        let l = layout("abc\nde", &st(40.0), &ParagraphStyle::default());
+        let (x0, _, li0) = l.caret(0);
+        let (x1, _, _) = l.caret(1);
+        let (x3, _, _) = l.caret(3);
+        assert!(x0.abs() < 1e-3 && x1 > x0 && x3 > x1);
+        assert_eq!(li0, 0);
+        let (_, b4, li4) = l.caret(4);
+        assert_eq!(li4, 1);
+        assert!(b4 > 0.0);
+        assert_eq!(l.hit(x1 + 1.0, 0.0), 1);
+        assert_eq!(l.hit(1000.0, b4), 6);
+        let rects = l.selection_rects(1, 5);
+        assert_eq!(rects.len(), 2);
+    }
+
+    #[test]
+    fn bidi_reorders_rtl_runs() {
+        // Hebrew letters are laid out right-to-left: the first logical letter is rightmost.
+        let l = layout("ab \u{5d0}\u{5d1}\u{5d2} cd", &st(40.0), &ParagraphStyle::default());
+        let x_of = |byte: usize| l.glyphs.iter().find(|g| g.cluster == byte).map(|g| g.x).unwrap();
+        let alef = "ab ".len();
+        let gimel = alef + 4;
+        assert!(x_of(alef) > x_of(gimel), "alef right of gimel");
+        assert!(x_of(0) < x_of(gimel) && x_of(alef) < x_of("ab \u{5d0}\u{5d1}\u{5d2} ".len()));
+    }
+
+    #[test]
+    fn caps_and_small_caps() {
+        let s = st(50.0);
+        let up = measure("HELLO", &s);
+        let all = measure("hello", &TextStyle { caps: Caps::All, ..s.clone() });
+        assert!((up - all).abs() < 0.01);
+        let small = measure("hello", &TextStyle { caps: Caps::Small, ..s.clone() });
+        assert!(small < up * 0.9 && small > up * 0.6, "{small} {up}");
+        let l = layout("Hi", &TextStyle { baseline_shift: 10.0, underline: true, ..s }, &ParagraphStyle::default());
+        assert!((l.glyphs[0].y + 10.0).abs() < 1e-3);
+        assert_eq!(l.underlines.len(), 1);
+    }
+
+    #[test]
+    fn ligature_caret_interpolates() {
+        // Inter has an "fi"-like ligature only via calt in some versions; use "ffi" which most
+        // fonts ligate. Whatever shaping does, every char boundary has a caret.
+        let l = layout("office", &st(40.0), &ParagraphStyle::default());
+        let stops: Vec<usize> = l.lines[0].carets.iter().map(|c| c.0).collect();
+        assert_eq!(stops, vec![0, 1, 2, 3, 4, 5, 6]);
+        let xs: Vec<f32> = l.lines[0].carets.iter().map(|c| c.1).collect();
+        assert!(xs.windows(2).all(|w| w[1] >= w[0]), "{xs:?}");
+    }
+
+    #[test]
+    fn fallback_font_for_missing_glyphs() {
+        // Inter lacks Devanagari/Hebrew; Noto Serif lacks Hebrew too → glyphs still produced (notdef)
+        let l = layout("A\u{3b1}", &TextStyle { family: "Noto Serif".into(), ..st(40.0) }, &ParagraphStyle::default());
+        assert_eq!(l.glyphs.len(), 2);
+        assert!(l.glyphs.iter().all(|g| g.id != 0));
+    }
+
+    #[test]
+    fn empty_text_has_a_caret() {
+        let l = layout("", &st(40.0), &ParagraphStyle::default());
+        assert_eq!(l.lines.len(), 1);
+        assert_eq!(l.caret(0).0, 0.0);
+        assert!(l.bounds[3] > l.bounds[1]);
+    }
+}
diff --git a/crates/text/src/lib.rs b/crates/text/src/lib.rs
new file mode 100644
index 000000000..7fffd1084
--- /dev/null
+++ b/crates/text/src/lib.rs
@@ -0,0 +1,52 @@
+//! FilmCraft text engine (layer L1).
+//!
+//! - [`fonts`]: font database — bundled OFL fonts (Inter, JetBrains Mono, Noto Serif) plus faces
+//!   discovered by [`fonts::FontSource`]s (system font folders on native platforms; nothing on the
+//!   web unless the host registers font data), family/style resolution with synthetic bold/italic
+//!   and per-character fallback.
+//! - [`layout`]: shaping (harfrust: kerning, ligatures, complex scripts), bidi, line breaking,
+//!   paragraph layout, carets and hit testing; cached.
+//! - [`raster`]: our own anti-aliased path rasteriser (linear coverage, so compositing in linear
+//!   light is correct) and vector shapes.
+//! - [`render`]: glyph outlines and the glyph-mask cache (sub-pixel positioned), drawing layouts
+//!   under any affine transform.
+//! - [`mask`]: strokes (outer/centre/inner via a Euclidean distance transform), blur, offsets.
+
+pub mod fonts;
+pub mod layout;
+pub mod mask;
+pub mod raster;
+pub mod render;
+pub mod sfnt;
+
+pub use fonts::{FaceId, Resolved, families, resolve};
+pub use layout::{Align, Caps, Glyph, Layout, Line, ParagraphStyle, TextStyle, layout, measure};
+pub use mask::StrokeKind;
+pub use raster::{Mask, Path, Xform};
+
+#[cfg(test)]
+mod perf {
+    use super::*;
+
+    /// A three-line 1080p title: layout + rasterisation must stay far below a frame (≈ 41 ms at
+    /// 24 fps). Cold = first time (shaping + glyph rasterisation); warm = cached.
+    #[test]
+    fn three_line_title_is_fast() {
+        let text = "FILMCRAFT PRESENTS\nA Night Drive Through the City\nDirected by Nobody in Particular";
+        let st = TextStyle { size: 96.0, style: "Bold".into(), ..Default::default() };
+        let ps = ParagraphStyle { align: Align::Center, ..Default::default() };
+        let t0 = std::time::Instant::now();
+        let l = layout::layout_uncached(text, &st, &ps);
+        let (m, _, _) = render::rasterize(&l, &render::at(960.0, 400.0));
+        let cold = t0.elapsed();
+        let _ = layout(text, &st, &ps);
+        let t1 = std::time::Instant::now();
+        let l2 = layout(text, &st, &ps);
+        let (m2, _, _) = render::rasterize(&l2, &render::at(960.0, 400.0));
+        let warm = t1.elapsed();
+        assert_eq!(m.a.len(), m2.a.len());
+        eprintln!("3-line 1080p title: cold {cold:?}, warm {warm:?} (mask {}x{})", m.w, m.h);
+        // generous bound for debug builds on busy CI machines
+        assert!(warm.as_millis() < 40, "warm {warm:?}");
+    }
+}
diff --git a/crates/text/src/mask.rs b/crates/text/src/mask.rs
new file mode 100644
index 000000000..33af4e494
--- /dev/null
+++ b/crates/text/src/mask.rs
@@ -0,0 +1,213 @@
+//! Coverage-mask operations used for text and shape appearance: strokes (outer / centre / inner)
+//! from an exact Euclidean distance transform, Gaussian-like blur for shadows, offsets.
+
+use crate::raster::Mask;
+
+/// Where a stroke sits relative to the shape's edge (Premiere's stroke types).
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
+pub enum StrokeKind {
+    #[default]
+    Outer,
+    Center,
+    Inner,
+}
+
+const INF: f32 = 1e20;
+
+/// 1-D squared distance transform (Felzenszwalb & Huttenlocher) of `f` into `d`.
+fn edt_1d(f: &[f32], d: &mut [f32], v: &mut [usize], z: &mut [f32]) {
+    let n = f.len();
+    if n == 0 {
+        return;
+    }
+    let mut k = 0usize;
+    v[0] = 0;
+    z[0] = -INF;
+    z[1] = INF;
+    for q in 1..n {
+        let fq = f[q] + (q * q) as f32;
+        let mut s;
+        loop {
+            let p = v[k];
+            s = (fq - (f[p] + (p * p) as f32)) / (2.0 * (q as f32 - p as f32));
+            if s <= z[k] && k > 0 {
+                k -= 1;
+            } else {
+                break;
+            }
+        }
+        if s <= z[k] {
+            // k == 0: q dominates everything so far
+            v[0] = q;
+            z[0] = -INF;
+            z[1] = INF;
+            continue;
+        }
+        k += 1;
+        v[k] = q;
+        z[k] = s;
+        z[k + 1] = INF;
+    }
+    k = 0;
+    for q in 0..n {
+        while z[k + 1] < q as f32 {
+            k += 1;
+        }
+        let p = v[k];
+        let dq = q as f32 - p as f32;
+        d[q] = (dq * dq + f[p]).min(INF);
+    }
+}
+
+/// Euclidean distance (in pixels, between pixel centres) from every pixel to the nearest pixel
+/// where `seed` is true.
+fn edt(w: usize, h: usize, seed: impl Fn(usize) -> bool) -> Vec<f32> {
+    let mut g = vec![INF; w * h];
+    for (i, v) in g.iter_mut().enumerate() {
+        if seed(i) {
+            *v = 0.0;
+        }
+    }
+    let n = w.max(h);
+    let mut f = vec![0.0f32; n];
+    let mut d = vec![0.0f32; n];
+    let mut v = vec![0usize; n];
+    let mut z = vec![0.0f32; n + 1];
+    for x in 0..w {
+        for y in 0..h {
+            f[y] = g[y * w + x];
+        }
+        edt_1d(&f[..h], &mut d[..h], &mut v[..h], &mut z[..h + 1]);
+        for y in 0..h {
+            g[y * w + x] = d[y];
+        }
+    }
+    for y in 0..h {
+        f[..w].copy_from_slice(&g[y * w..y * w + w]);
+        edt_1d(&f[..w], &mut d[..w], &mut v[..w], &mut z[..w + 1]);
+        for x in 0..w {
+            g[y * w + x] = d[x].sqrt();
+        }
+    }
+    g
+}
+
+/// Approximate signed distance to the shape edge: negative inside, positive outside, with
+/// sub-pixel refinement from the coverage values.
+pub fn signed_distance(m: &Mask) -> Vec<f32> {
+    let (w, h) = (m.w, m.h);
+    let outside = edt(w, h, |i| m.a[i] >= 0.5);
+    let inside = edt(w, h, |i| m.a[i] < 0.5);
+    (0..w * h)
+        .map(|i| {
+            let c = m.a[i];
+            if c > 0.0 && c < 1.0 {
+                0.5 - c
+            } else if c >= 0.5 {
+                -(inside[i] - 0.5).max(0.0)
+            } else {
+                (outside[i] - 0.5).max(0.0)
+            }
+        })
+        .collect()
+}
+
+/// Stroke coverage of width `width` pixels around the shape in `m`.
+pub fn stroke(m: &Mask, width: f32, kind: StrokeKind) -> Mask {
+    let sd = signed_distance(m);
+    let a = sd
+        .iter()
+        .zip(&m.a)
+        .map(|(&d, &c)| {
+            let v = match kind {
+                StrokeKind::Outer => (width + 0.5 - d).clamp(0.0, 1.0).max(c),
+                StrokeKind::Center => (width / 2.0 + 0.5 - d.abs()).clamp(0.0, 1.0),
+                StrokeKind::Inner => (width + 0.5 + d).clamp(0.0, 1.0).min(c),
+            };
+            if kind == StrokeKind::Outer { v } else { v.min(1.0) }
+        })
+        .collect();
+    Mask { w: m.w, h: m.h, a }
+}
+
+fn box_pass(src: &[f32], dst: &mut [f32], n: usize, stride: usize, count: usize, lanes: usize, lane_stride: usize, r: usize) {
+    let norm = 1.0 / (2 * r + 1) as f32;
+    for l in 0..lanes {
+        let base = l * lane_stride;
+        let at = |i: isize| -> f32 { if i < 0 || i as usize >= count { 0.0 } else { src[base + i as usize * stride] } };
+        let mut acc = 0.0f32;
+        for i in -(r as isize)..=(r as isize) {
+            acc += at(i);
+        }
+        for i in 0..count {
+            dst[base + i * stride] = acc * norm;
+            acc += at(i as isize + r as isize + 1) - at(i as isize - r as isize);
+        }
+    }
+    let _ = n;
+}
+
+/// Blur a mask with three box passes per axis (≈ Gaussian of standard deviation `sigma`).
+pub fn blur(m: &Mask, sigma: f32) -> Mask {
+    if sigma < 0.3 || m.w == 0 || m.h == 0 {
+        return m.clone();
+    }
+    // box radius for 3 passes ≈ sigma * sqrt(3)
+    let r = ((sigma * sigma + 1.0).sqrt().round() as usize).max(1);
+    let mut a = m.a.clone();
+    let mut b = vec![0.0f32; a.len()];
+    for _ in 0..3 {
+        box_pass(&a, &mut b, 0, 1, m.w, m.h, m.w, r);
+        std::mem::swap(&mut a, &mut b);
+        box_pass(&a, &mut b, 0, m.w, m.h, m.w, 1, r);
+        std::mem::swap(&mut a, &mut b);
+    }
+    Mask { w: m.w, h: m.h, a }
+}
+
+/// Shift a mask by whole pixels (content moving out is dropped).
+pub fn offset(m: &Mask, dx: i32, dy: i32) -> Mask {
+    let mut o = Mask::new(m.w, m.h);
+    o.add(m, dx, dy);
+    o
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::raster::{Path, fill};
+
+    #[test]
+    fn distance_transform_is_euclidean() {
+        let d = edt(9, 9, |i| i == 4 * 9 + 4);
+        assert_eq!(d[4 * 9 + 4], 0.0);
+        assert!((d[4 * 9 + 7] - 3.0).abs() < 1e-5);
+        assert!((d[0] - (32.0f32).sqrt()).abs() < 1e-4);
+        let none = edt(3, 3, |_| false);
+        assert!(none.iter().all(|&v| v > 1e5));
+    }
+
+    #[test]
+    fn strokes_sit_outside_centre_and_inside() {
+        let m = fill(&Path::rect(10.0, 10.0, 30.0, 30.0), 40, 40, 0.0, 0.0);
+        let outer = stroke(&m, 4.0, StrokeKind::Outer);
+        assert!(outer.get(7, 20) > 0.99, "outer covers 3px outside");
+        assert!(outer.get(4, 20) < 0.01);
+        assert!(outer.get(20, 20) > 0.99, "outer includes the fill area");
+        let inner = stroke(&m, 4.0, StrokeKind::Inner);
+        assert!(inner.get(12, 20) > 0.99 && inner.get(7, 20) < 0.01 && inner.get(20, 20) < 0.01);
+        let centre = stroke(&m, 4.0, StrokeKind::Center);
+        assert!(centre.get(9, 20) > 0.99 && centre.get(11, 20) > 0.99 && centre.get(20, 20) < 0.01 && centre.get(5, 20) < 0.01);
+    }
+
+    #[test]
+    fn blur_keeps_mass() {
+        let m = fill(&Path::rect(20.0, 20.0, 30.0, 30.0), 50, 50, 0.0, 0.0);
+        let b = blur(&m, 3.0);
+        let (s0, s1): (f32, f32) = (m.a.iter().sum(), b.a.iter().sum());
+        assert!((s0 - s1).abs() < 0.5, "{s0} {s1}");
+        assert!(b.get(18, 25) > 0.05 && b.get(25, 25) < 1.0);
+        let o = offset(&m, 5, -5);
+        assert!(o.get(33, 18) > 0.9);
+    }
+}
diff --git a/crates/text/src/raster.rs b/crates/text/src/raster.rs
new file mode 100644
index 000000000..33bf2f4dc
--- /dev/null
+++ b/crates/text/src/raster.rs
@@ -0,0 +1,484 @@
+//! Anti-aliased path rasteriser for glyph outlines and vector shapes.
+//!
+//! Paths are flattened to closed polylines (contours). [`fill`] samples each pixel row at [`SUB`]
+//! sub-scanlines with an active-edge list and accumulates the non-zero winding spans of each
+//! sub-scanline with exact horizontal coverage at the span ends. Coverage is linear (fractional
+//! area), so compositing it in linear light gives correct anti-aliasing. Original implementation
+//! for FilmCraft (it started as the caption rasteriser).
+
+/// Vertical sub-samples per pixel row.
+pub const SUB: usize = 5;
+
+/// A 2×3 affine transform `[a, b, c, d, e, f]`: (x, y) → (a x + c y + e, b x + d y + f).
+pub type Xform = [f32; 6];
+
+pub const IDENTITY: Xform = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0];
+
+#[inline]
+pub fn apply(m: &Xform, x: f32, y: f32) -> (f32, f32) {
+    (m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5])
+}
+
+/// `a ∘ b`: apply `b` first, then `a`.
+pub fn compose(a: &Xform, b: &Xform) -> Xform {
+    [
+        a[0] * b[0] + a[2] * b[1],
+        a[1] * b[0] + a[3] * b[1],
+        a[0] * b[2] + a[2] * b[3],
+        a[1] * b[2] + a[3] * b[3],
+        a[0] * b[4] + a[2] * b[5] + a[4],
+        a[1] * b[4] + a[3] * b[5] + a[5],
+    ]
+}
+
+/// Average linear scale of a transform (for flattening tolerances and stroke widths).
+pub fn xform_scale(m: &Xform) -> f32 {
+    (m[0] * m[3] - m[1] * m[2]).abs().sqrt()
+}
+
+/// A flattened path: closed contours of points in pixel space, y down.
+#[derive(Clone, Debug, Default)]
+pub struct Path {
+    pub contours: Vec<Vec<(f32, f32)>>,
+    cur: (f32, f32),
+    open: bool,
+    /// Flattening tolerance multiplier (curves are split more finely for larger values).
+    pub detail: f32,
+}
+
+impl Path {
+    pub fn new() -> Self {
+        Self { detail: 1.0, ..Default::default() }
+    }
+    fn tol(&self) -> f32 {
+        if self.detail > 0.0 { self.detail } else { 1.0 }
+    }
+    pub fn move_to(&mut self, x: f32, y: f32) {
+        self.close();
+        self.contours.push(vec![(x, y)]);
+        self.cur = (x, y);
+        self.open = true;
+    }
+    pub fn line_to(&mut self, x: f32, y: f32) {
+        if !self.open {
+            self.move_to(self.cur.0, self.cur.1);
+        }
+        if (x, y) != self.cur {
+            self.contours.last_mut().expect("open contour").push((x, y));
+        }
+        self.cur = (x, y);
+    }
+    pub fn quad_to(&mut self, cx: f32, cy: f32, x: f32, y: f32) {
+        let (x0, y0) = self.cur;
+        let dd = ((x0 - 2.0 * cx + x).abs() + (y0 - 2.0 * cy + y).abs()).max(0.01) * self.tol();
+        let n = ((dd * 2.0).sqrt().ceil() as usize).clamp(1, 64);
+        for i in 1..=n {
+            let t = i as f32 / n as f32;
+            let u = 1.0 - t;
+            self.line_to(u * u * x0 + 2.0 * u * t * cx + t * t * x, u * u * y0 + 2.0 * u * t * cy + t * t * y);
+        }
+    }
+    pub fn cubic_to(&mut self, c1x: f32, c1y: f32, c2x: f32, c2y: f32, x: f32, y: f32) {
+        let (x0, y0) = self.cur;
+        let dd =
+            ((x0 - 2.0 * c1x + c2x).abs() + (y0 - 2.0 * c1y + c2y).abs() + (c1x - 2.0 * c2x + x).abs() + (c1y - 2.0 * c2y + y).abs()).max(0.01) * self.tol();
+        let n = ((dd * 3.0).sqrt().ceil() as usize).clamp(1, 96);
+        for i in 1..=n {
+            let t = i as f32 / n as f32;
+            let u = 1.0 - t;
+            let (a, b, c, d) = (u * u * u, 3.0 * u * u * t, 3.0 * u * t * t, t * t * t);
+            self.line_to(a * x0 + b * c1x + c * c2x + d * x, a * y0 + b * c1y + c * c2y + d * y);
+        }
+    }
+    /// Close the current contour (contours are always filled as closed polygons).
+    pub fn close(&mut self) {
+        if self.open {
+            if let Some(c) = self.contours.last()
+                && let Some(&p) = c.first()
+            {
+                self.cur = p;
+            }
+            if self.contours.last().is_some_and(|c| c.len() < 2) {
+                self.contours.pop();
+            }
+        }
+        self.open = false;
+    }
+    /// Append all contours of `o`.
+    pub fn extend(&mut self, o: &Path) {
+        self.close();
+        self.contours.extend(o.contours.iter().cloned());
+    }
+    pub fn is_empty(&self) -> bool {
+        self.contours.is_empty()
+    }
+    pub fn transform(&mut self, m: &Xform) {
+        for c in &mut self.contours {
+            for p in c.iter_mut() {
+                *p = apply(m, p.0, p.1);
+            }
+        }
+    }
+    pub fn transformed(&self, m: &Xform) -> Path {
+        let mut p = self.clone();
+        p.transform(m);
+        p
+    }
+    /// Bounding box `(x0, y0, x1, y1)` of all points.
+    pub fn bounds(&self) -> Option<(f32, f32, f32, f32)> {
+        let mut it = self.contours.iter().flatten();
+        let f = it.next()?;
+        let mut b = (f.0, f.1, f.0, f.1);
+        for p in it {
+            b = (b.0.min(p.0), b.1.min(p.1), b.2.max(p.0), b.3.max(p.1));
+        }
+        Some(b)
+    }
+    /// Signed area (shoelace, y down: positive = clockwise on screen) of all contours.
+    pub fn signed_area(&self) -> f32 {
+        self.contours.iter().map(|c| contour_area(c)).sum()
+    }
+    /// Grow (d > 0) or shrink every contour by `d` pixels along its normals (faux bold). Holes
+    /// shrink because they wind the other way.
+    pub fn embolden(&mut self, d: f32) {
+        if d == 0.0 {
+            return;
+        }
+        let sign = if self.signed_area() >= 0.0 { 1.0 } else { -1.0 };
+        for c in &mut self.contours {
+            let n = c.len();
+            if n < 3 {
+                continue;
+            }
+            let src = c.clone();
+            for i in 0..n {
+                let p0 = src[(i + n - 1) % n];
+                let p1 = src[i];
+                let p2 = src[(i + 1) % n];
+                let n1 = normal(p0, p1, sign);
+                let n2 = normal(p1, p2, sign);
+                let (mx, my) = (n1.0 + n2.0, n1.1 + n2.1);
+                let ml = (mx * mx + my * my).sqrt();
+                if ml < 1e-6 {
+                    c[i] = (p1.0 + n1.0 * d, p1.1 + n1.1 * d);
+                    continue;
+                }
+                let (mx, my) = (mx / ml, my / ml);
+                let cos = (mx * n1.0 + my * n1.1).max(0.35);
+                c[i] = (p1.0 + mx * d / cos, p1.1 + my * d / cos);
+            }
+        }
+    }
+
+    // ---- shapes ----
+
+    pub fn rect(x0: f32, y0: f32, x1: f32, y1: f32) -> Path {
+        let mut p = Path::new();
+        p.move_to(x0, y0);
+        p.line_to(x1, y0);
+        p.line_to(x1, y1);
+        p.line_to(x0, y1);
+        p.close();
+        p
+    }
+    /// Rectangle with rounded corners of radius `r` (clamped to half the shorter side).
+    pub fn round_rect(x0: f32, y0: f32, x1: f32, y1: f32, r: f32) -> Path {
+        let r = r.min((x1 - x0).abs() / 2.0).min((y1 - y0).abs() / 2.0).max(0.0);
+        if r < 0.01 {
+            return Path::rect(x0, y0, x1, y1);
+        }
+        let k = 0.552_284_8 * r;
+        let mut p = Path::new();
+        p.move_to(x0 + r, y0);
+        p.line_to(x1 - r, y0);
+        p.cubic_to(x1 - r + k, y0, x1, y0 + r - k, x1, y0 + r);
+        p.line_to(x1, y1 - r);
+        p.cubic_to(x1, y1 - r + k, x1 - r + k, y1, x1 - r, y1);
+        p.line_to(x0 + r, y1);
+        p.cubic_to(x0 + r - k, y1, x0, y1 - r + k, x0, y1 - r);
+        p.line_to(x0, y0 + r);
+        p.cubic_to(x0, y0 + r - k, x0 + r - k, y0, x0 + r, y0);
+        p.close();
+        p
+    }
+    /// Ellipse centred at (cx, cy) with radii (rx, ry), wound clockwise on screen.
+    pub fn ellipse(cx: f32, cy: f32, rx: f32, ry: f32) -> Path {
+        let (kx, ky) = (0.552_284_8 * rx, 0.552_284_8 * ry);
+        let mut p = Path::new();
+        p.move_to(cx + rx, cy);
+        p.cubic_to(cx + rx, cy + ky, cx + kx, cy + ry, cx, cy + ry);
+        p.cubic_to(cx - kx, cy + ry, cx - rx, cy + ky, cx - rx, cy);
+        p.cubic_to(cx - rx, cy - ky, cx - kx, cy - ry, cx, cy - ry);
+        p.cubic_to(cx + kx, cy - ry, cx + rx, cy - ky, cx + rx, cy);
+        p.close();
+        p
+    }
+    /// Closed polygon through `pts`.
+    pub fn polygon(pts: &[(f32, f32)]) -> Path {
+        let mut p = Path::new();
+        if let Some(&(x, y)) = pts.first() {
+            p.move_to(x, y);
+            for &(x, y) in &pts[1..] {
+                p.line_to(x, y);
+            }
+            p.close();
+        }
+        p
+    }
+}
+
+fn contour_area(c: &[(f32, f32)]) -> f32 {
+    let n = c.len();
+    let mut a = 0.0;
+    for i in 0..n {
+        let (x0, y0) = c[i];
+        let (x1, y1) = c[(i + 1) % n];
+        a += x0 * y1 - x1 * y0;
+    }
+    a / 2.0
+}
+
+/// Outward unit normal of edge p0→p1 for an outline of orientation `sign`.
+fn normal(p0: (f32, f32), p1: (f32, f32), sign: f32) -> (f32, f32) {
+    let (dx, dy) = (p1.0 - p0.0, p1.1 - p0.1);
+    let l = (dx * dx + dy * dy).sqrt();
+    if l < 1e-9 {
+        return (0.0, 0.0);
+    }
+    (sign * dy / l, -sign * dx / l)
+}
+
+/// Coverage mask (0..1), row-major.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct Mask {
+    pub w: usize,
+    pub h: usize,
+    pub a: Vec<f32>,
+}
+
+impl Mask {
+    pub fn new(w: usize, h: usize) -> Self {
+        Self { w, h, a: vec![0.0; w * h] }
+    }
+    pub fn get(&self, x: usize, y: usize) -> f32 {
+        self.a[y * self.w + x]
+    }
+    /// Add `src` placed at (`ox`, `oy`) (saturating at 1).
+    pub fn add(&mut self, src: &Mask, ox: i32, oy: i32) {
+        for y in 0..src.h {
+            let ty = oy + y as i32;
+            if ty < 0 || ty >= self.h as i32 {
+                continue;
+            }
+            let x0 = (-ox).max(0) as usize;
+            let x1 = src.w.min((self.w as i32 - ox).max(0) as usize);
+            if x0 >= x1 {
+                continue;
+            }
+            let srow = &src.a[y * src.w + x0..y * src.w + x1];
+            let d0 = ty as usize * self.w + (ox + x0 as i32) as usize;
+            for (d, s) in self.a[d0..d0 + (x1 - x0)].iter_mut().zip(srow) {
+                *d = (*d + s).min(1.0);
+            }
+        }
+    }
+    /// Per-pixel maximum with `o` (same size).
+    pub fn max_with(&mut self, o: &Mask) {
+        for (a, b) in self.a.iter_mut().zip(&o.a) {
+            *a = a.max(*b);
+        }
+    }
+}
+
+/// Fill `path` (non-zero winding) into a `w`×`h` mask, offsetting the path by `(dx, dy)`.
+pub fn fill(path: &Path, w: usize, h: usize, dx: f32, dy: f32) -> Mask {
+    let mut m = Mask::new(w, h);
+    fill_into(path, &mut m, dx, dy);
+    m
+}
+
+struct Edge {
+    ytop: f32,
+    ybot: f32,
+    x: f32,
+    slope: f32,
+    dir: i32,
+}
+
+/// Fill `path` into `m`, adding coverage (saturating at 1) — the union of what was there and the
+/// path for disjoint content.
+pub fn fill_into(path: &Path, m: &mut Mask, dx: f32, dy: f32) {
+    let (w, h) = (m.w, m.h);
+    if w == 0 || h == 0 {
+        return;
+    }
+    let mut edges: Vec<Edge> = Vec::new();
+    for c in &path.contours {
+        let n = c.len();
+        if n < 2 {
+            continue;
+        }
+        for i in 0..n {
+            let (x0, y0) = c[i];
+            let (x1, y1) = c[(i + 1) % n];
+            let (x0, y0, x1, y1) = (x0 + dx, y0 + dy, x1 + dx, y1 + dy);
+            if y0 == y1 || !(x0.is_finite() && y0.is_finite() && x1.is_finite() && y1.is_finite()) {
+                continue;
+            }
+            let (dir, xa, ya, xb, yb) = if y0 < y1 { (1, x0, y0, x1, y1) } else { (-1, x1, y1, x0, y0) };
+            if yb <= 0.0 || ya >= h as f32 {
+                continue;
+            }
+            edges.push(Edge { ytop: ya, ybot: yb, x: xa, slope: (xb - xa) / (yb - ya), dir });
+        }
+    }
+    if edges.is_empty() {
+        return;
+    }
+    edges.sort_by(|a, b| a.ytop.total_cmp(&b.ytop));
+    let ymin = edges[0].ytop.floor().max(0.0) as usize;
+    let ymax = (edges.iter().map(|e| e.ybot).fold(f32::MIN, f32::max).ceil().max(0.0) as usize).min(h);
+    let mut next = 0usize;
+    let mut active: Vec<usize> = Vec::new();
+    let mut xs: Vec<(f32, i32)> = Vec::new();
+    let mut row = vec![0.0f32; w + 1];
+    let weight = 1.0 / SUB as f32;
+    for y in ymin..ymax {
+        let mut lo = usize::MAX;
+        let mut hi = 0usize;
+        for k in 0..SUB {
+            let sy = y as f32 + (k as f32 + 0.5) / SUB as f32;
+            while next < edges.len() && edges[next].ytop <= sy {
+                active.push(next);
+                next += 1;
+            }
+            active.retain(|&i| edges[i].ybot > sy);
+            xs.clear();
+            for &i in &active {
+                let e = &edges[i];
+                if e.ytop <= sy {
+                    xs.push((e.x + (sy - e.ytop) * e.slope, e.dir));
+                }
+            }
+            if xs.len() < 2 {
+                continue;
+            }
+            xs.sort_by(|a, b| a.0.total_cmp(&b.0));
+            let mut wind = 0;
+            let mut span_start = 0.0f32;
+            for &(x, d) in &xs {
+                let before = wind;
+                wind += d;
+                if before == 0 && wind != 0 {
+                    span_start = x;
+                } else if before != 0
+                    && wind == 0
+                    && let Some((a, b)) = add_span(&mut row, span_start, x, weight, w)
+                {
+                    lo = lo.min(a);
+                    hi = hi.max(b);
+                }
+            }
+        }
+        if lo <= hi && lo < w {
+            let hi = hi.min(w - 1);
+            let out = &mut m.a[y * w..(y + 1) * w];
+            for x in lo..=hi {
+                out[x] = (out[x] + row[x]).min(1.0);
+                row[x] = 0.0;
+            }
+            row[w] = 0.0;
+        }
+    }
+}
+
+/// Add coverage `weight` over `[x0, x1)` with fractional ends; returns the touched pixel range.
+fn add_span(row: &mut [f32], x0: f32, x1: f32, weight: f32, w: usize) -> Option<(usize, usize)> {
+    let x0 = x0.clamp(0.0, w as f32);
+    let x1 = x1.clamp(0.0, w as f32);
+    if x1 <= x0 {
+        return None;
+    }
+    let i0 = x0.floor() as usize;
+    let i1 = x1.floor() as usize;
+    if i0 == i1 {
+        row[i0] += (x1 - x0) * weight;
+        return Some((i0, i0));
+    }
+    row[i0] += (i0 as f32 + 1.0 - x0) * weight;
+    for v in &mut row[i0 + 1..i1] {
+        *v += weight;
+    }
+    if i1 < w {
+        row[i1] += (x1 - i1 as f32) * weight;
+    }
+    Some((i0, i1.min(w - 1)))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn rectangle_coverage() {
+        let m = fill(&Path::rect(1.5, 2.0, 4.0, 5.0), 6, 6, 0.0, 0.0);
+        assert!((m.get(1, 3) - 0.5).abs() < 1e-5);
+        assert!((m.get(2, 3) - 1.0).abs() < 1e-5);
+        assert_eq!(m.get(4, 3), 0.0);
+        assert_eq!(m.get(2, 1), 0.0);
+        assert_eq!(m.get(2, 5), 0.0);
+        let total: f32 = m.a.iter().sum();
+        assert!((total - 2.5 * 3.0).abs() < 1e-3, "{total}");
+    }
+
+    #[test]
+    fn hole_with_opposite_winding() {
+        let mut p = Path::rect(0.0, 0.0, 10.0, 10.0);
+        p.move_to(3.0, 3.0);
+        p.line_to(3.0, 7.0);
+        p.line_to(7.0, 7.0);
+        p.line_to(7.0, 3.0);
+        p.close();
+        let m = fill(&p, 10, 10, 0.0, 0.0);
+        assert_eq!(m.get(5, 5), 0.0);
+        assert!((m.get(1, 5) - 1.0).abs() < 1e-5);
+    }
+
+    #[test]
+    fn circle_area() {
+        let (cx, cy, r) = (10.0f32, 10.0f32, 6.0f32);
+        let m = fill(&Path::ellipse(cx, cy, r, r), 20, 20, 0.0, 0.0);
+        let total: f32 = m.a.iter().sum();
+        let want = std::f32::consts::PI * r * r;
+        assert!((total - want).abs() / want < 0.02, "{total} vs {want}");
+    }
+
+    #[test]
+    fn embolden_grows_outline_and_shrinks_holes() {
+        let mut p = Path::rect(4.0, 4.0, 14.0, 14.0);
+        p.embolden(1.0);
+        let b = p.bounds().unwrap();
+        assert!((b.0 - 3.0).abs() < 1e-4 && (b.2 - 15.0).abs() < 1e-4, "{b:?}");
+        // reversed winding: still grows (orientation is taken from the whole outline)
+        let mut q = Path::polygon(&[(4.0, 4.0), (4.0, 14.0), (14.0, 14.0), (14.0, 4.0)]);
+        q.embolden(1.0);
+        assert!((q.bounds().unwrap().0 - 3.0).abs() < 1e-4);
+    }
+
+    #[test]
+    fn transforms_compose() {
+        let t = compose(&[2.0, 0.0, 0.0, 2.0, 0.0, 0.0], &[1.0, 0.0, 0.0, 1.0, 3.0, 4.0]);
+        assert_eq!(apply(&t, 1.0, 1.0), (8.0, 10.0));
+        let p = Path::rect(0.0, 0.0, 1.0, 1.0).transformed(&t);
+        assert_eq!(p.bounds(), Some((6.0, 8.0, 8.0, 10.0)));
+        assert!((xform_scale(&t) - 2.0).abs() < 1e-6);
+    }
+
+    #[test]
+    fn round_rect_area() {
+        let m = fill(&Path::round_rect(0.0, 0.0, 20.0, 10.0, 3.0), 20, 10, 0.0, 0.0);
+        let total: f32 = m.a.iter().sum();
+        let want = 200.0 - (4.0 - std::f32::consts::PI) * 9.0;
+        assert!((total - want).abs() < 1.0, "{total} {want}");
+    }
+}
diff --git a/crates/text/src/render.rs b/crates/text/src/render.rs
new file mode 100644
index 000000000..07d889305
--- /dev/null
+++ b/crates/text/src/render.rs
@@ -0,0 +1,302 @@
+//! Drawing laid-out text into coverage masks.
+//!
+//! Two paths:
+//! - **Glyph cache** (axis-aligned uniform scale, the common case for titles): each glyph is
+//!   rasterised once per (face, glyph, size, ¼-pixel horizontal phase, synthetic style) and the
+//!   cached masks are added at their pixel positions (sub-pixel positioning in x, whole pixels
+//!   in y).
+//! - **Outlines** (rotation, skew, non-uniform scale): every glyph outline is transformed into
+//!   device space and the whole run is filled once.
+//!
+//! Synthetic bold grows outlines by 2.5 % of the size per side; synthetic italic slants by 12°.
+
+use std::collections::HashMap;
+use std::sync::{Arc, Mutex, OnceLock};
+
+use skrifa::instance::{LocationRef, Size};
+use skrifa::outline::{DrawSettings, OutlinePen};
+use skrifa::{GlyphId, MetadataProvider};
+
+use crate::fonts::{self, FaceId};
+use crate::layout::{Glyph, Layout};
+use crate::raster::{IDENTITY, Mask, Path, Xform, apply, compose, fill, fill_into, xform_scale};
+
+/// Slant of synthetic italic (tan 12°).
+pub const SYNTH_ITALIC_SLANT: f32 = 0.2126;
+/// Synthetic bold outline offset as a fraction of the font size.
+pub const SYNTH_BOLD: f32 = 0.025;
+
+#[derive(Clone, Copy, Debug)]
+enum Cmd {
+    M(f32, f32),
+    L(f32, f32),
+    Q(f32, f32, f32, f32),
+    C(f32, f32, f32, f32, f32, f32),
+    Z,
+}
+
+struct Rec(Vec<Cmd>);
+
+impl OutlinePen for Rec {
+    fn move_to(&mut self, x: f32, y: f32) {
+        self.0.push(Cmd::M(x, y));
+    }
+    fn line_to(&mut self, x: f32, y: f32) {
+        self.0.push(Cmd::L(x, y));
+    }
+    fn quad_to(&mut self, cx0: f32, cy0: f32, x: f32, y: f32) {
+        self.0.push(Cmd::Q(cx0, cy0, x, y));
+    }
+    fn curve_to(&mut self, cx0: f32, cy0: f32, cx1: f32, cy1: f32, x: f32, y: f32) {
+        self.0.push(Cmd::C(cx0, cy0, cx1, cy1, x, y));
+    }
+    fn close(&mut self) {
+        self.0.push(Cmd::Z);
+    }
+}
+
+/// Outline commands in font units (y up), cached per (face, glyph).
+fn outline(face: FaceId, gid: u32) -> Option<Arc<Vec<Cmd>>> {
+    static C: OnceLock<Mutex<HashMap<(FaceId, u32), Option<Arc<Vec<Cmd>>>>>> = OnceLock::new();
+    let c = C.get_or_init(Default::default);
+    if let Some(v) = c.lock().unwrap_or_else(|e| e.into_inner()).get(&(face, gid)) {
+        return v.clone();
+    }
+    let f = fonts::face(face);
+    let v = f.font().and_then(|font| {
+        let g = font.outline_glyphs().get(GlyphId::new(gid))?;
+        let mut rec = Rec(Vec::new());
+        g.draw(DrawSettings::unhinted(Size::unscaled(), LocationRef::default()), &mut rec).ok()?;
+        Some(Arc::new(rec.0))
+    });
+    let mut m = c.lock().unwrap_or_else(|e| e.into_inner());
+    if m.len() > 20_000 {
+        m.clear();
+    }
+    m.insert((face, gid), v.clone());
+    v
+}
+
+/// The glyph's outline as a path: `m` maps glyph-local pixels (origin on the baseline, y down,
+/// at the glyph's size) to the output.
+pub fn glyph_path(g: &Glyph, m: &Xform) -> Path {
+    let mut p = Path::new();
+    let Some(cmds) = outline(g.face, g.id) else { return p };
+    let k = g.size / fonts::face(g.face).units_per_em();
+    let slant = if g.synth_italic { SYNTH_ITALIC_SLANT } else { 0.0 };
+    // font units (y up) → glyph px (y down), slanted
+    let local: Xform = [k, 0.0, slant * k, -k, 0.0, 0.0];
+    let t = compose(m, &local);
+    p.detail = xform_scale(m).max(0.05);
+    let pt = |x: f32, y: f32| apply(&t, x, y);
+    for c in cmds.iter() {
+        match *c {
+            Cmd::M(x, y) => {
+                let (a, b) = pt(x, y);
+                p.move_to(a, b)
+            }
+            Cmd::L(x, y) => {
+                let (a, b) = pt(x, y);
+                p.line_to(a, b)
+            }
+            Cmd::Q(cx, cy, x, y) => {
+                let (c0, c1) = pt(cx, cy);
+                let (a, b) = pt(x, y);
+                p.quad_to(c0, c1, a, b)
+            }
+            Cmd::C(c0x, c0y, c1x, c1y, x, y) => {
+                let (p0, p1) = pt(c0x, c0y);
+                let (q0, q1) = pt(c1x, c1y);
+                let (a, b) = pt(x, y);
+                p.cubic_to(p0, p1, q0, q1, a, b)
+            }
+            Cmd::Z => p.close(),
+        }
+    }
+    p.close();
+    if g.synth_bold {
+        p.embolden(g.size * SYNTH_BOLD * xform_scale(m));
+    }
+    p
+}
+
+/// A rasterised glyph: coverage placed with its top-left at `(left, top)` relative to the
+/// pen's whole-pixel position.
+#[derive(Debug)]
+pub struct GlyphMask {
+    pub mask: Mask,
+    pub left: i32,
+    pub top: i32,
+}
+
+type GKey = (FaceId, u32, u32, u8, bool, bool);
+
+fn glyph_cache() -> &'static Mutex<HashMap<GKey, Option<Arc<GlyphMask>>>> {
+    static C: OnceLock<Mutex<HashMap<GKey, Option<Arc<GlyphMask>>>>> = OnceLock::new();
+    C.get_or_init(Default::default)
+}
+
+/// Rasterise glyph `g` at pixel size `px` with horizontal phase `frac` (0..1, quantised to ¼).
+pub fn glyph_mask(g: &Glyph, px: f32, frac: f32) -> Option<Arc<GlyphMask>> {
+    let size_q = (px * 8.0).round().max(1.0) as u32;
+    let frac_q = ((frac.rem_euclid(1.0) * 4.0).round() as u8) % 4;
+    let key = (g.face, g.id, size_q, frac_q, g.synth_bold, g.synth_italic);
+    if let Some(v) = glyph_cache().lock().unwrap_or_else(|e| e.into_inner()).get(&key) {
+        return v.clone();
+    }
+    let px = size_q as f32 / 8.0;
+    let fq = frac_q as f32 / 4.0;
+    let gg = Glyph { x: 0.0, y: 0.0, size: px, ..*g };
+    let path = glyph_path(&gg, &[1.0, 0.0, 0.0, 1.0, fq, 0.0]);
+    let v = path.bounds().map(|(x0, y0, x1, y1)| {
+        let left = x0.floor() as i32;
+        let top = y0.floor() as i32;
+        let w = (x1.ceil() as i32 - left).max(1) as usize;
+        let h = (y1.ceil() as i32 - top).max(1) as usize;
+        Arc::new(GlyphMask { mask: fill(&path, w, h, -left as f32, -top as f32), left, top })
+    });
+    let mut m = glyph_cache().lock().unwrap_or_else(|e| e.into_inner());
+    if m.len() > 16_384 {
+        m.clear();
+    }
+    m.insert(key, v.clone());
+    v
+}
+
+/// Whether `m` is a uniform positive scale plus translation (the glyph-cache path applies).
+pub fn is_axis_uniform(m: &Xform) -> bool {
+    m[1].abs() < 1e-6 && m[2].abs() < 1e-6 && m[0] > 0.0 && (m[0] - m[3]).abs() < 1e-4 * m[0].max(1.0)
+}
+
+/// The whole layout (glyphs + underlines) as one device-space path.
+pub fn layout_path(l: &Layout, m: &Xform) -> Path {
+    let mut p = Path::new();
+    for g in &l.glyphs {
+        let gm = compose(m, &[1.0, 0.0, 0.0, 1.0, g.x, g.y]);
+        p.extend(&glyph_path(g, &gm));
+    }
+    for u in &l.underlines {
+        p.extend(&Path::rect(u[0], u[1], u[2], u[3]).transformed(m));
+    }
+    p
+}
+
+/// Device-space bounding box of the layout's ink under `m` (logical bounds padded for overhangs).
+pub fn device_bounds(l: &Layout, m: &Xform) -> [f32; 4] {
+    let b = l.bounds;
+    let pad = l.glyphs.iter().map(|g| g.size).fold(0.0f32, f32::max) * 0.35;
+    let pts = [(b[0] - pad, b[1] - pad), (b[2] + pad, b[1] - pad), (b[0] - pad, b[3] + pad), (b[2] + pad, b[3] + pad)];
+    let mut o = [f32::MAX, f32::MAX, f32::MIN, f32::MIN];
+    for (x, y) in pts {
+        let (a, c) = apply(m, x, y);
+        o = [o[0].min(a), o[1].min(c), o[2].max(a), o[3].max(c)];
+    }
+    o
+}
+
+/// Add the coverage of layout `l` under transform `m` into `out` (whose pixel (0,0) is device
+/// pixel `origin`).
+pub fn draw(l: &Layout, m: &Xform, out: &mut Mask, origin: (i32, i32)) {
+    let (ox, oy) = origin;
+    if is_axis_uniform(m) {
+        let s = m[0];
+        for g in &l.glyphs {
+            let (x, y) = apply(m, g.x, g.y);
+            let px = g.size * s;
+            if px < 0.5 {
+                continue;
+            }
+            let xi = x.floor();
+            if let Some(gm) = glyph_mask(g, px, x - xi) {
+                out.add(&gm.mask, xi as i32 + gm.left - ox, y.round() as i32 + gm.top - oy);
+            }
+        }
+        if !l.underlines.is_empty() {
+            let mut p = Path::new();
+            for u in &l.underlines {
+                p.extend(&Path::rect(u[0], u[1], u[2], u[3]).transformed(m));
+            }
+            fill_into(&p, out, -ox as f32, -oy as f32);
+        }
+    } else {
+        let p = layout_path(l, m);
+        fill_into(&p, out, -ox as f32, -oy as f32);
+    }
+}
+
+/// Rasterise a layout into a tight mask; returns `(mask, x, y)` with the mask's device position.
+pub fn rasterize(l: &Layout, m: &Xform) -> (Mask, i32, i32) {
+    let b = device_bounds(l, m);
+    let (x0, y0) = (b[0].floor() as i32 - 1, b[1].floor() as i32 - 1);
+    let (w, h) = ((b[2].ceil() as i32 + 1 - x0).max(1) as usize, (b[3].ceil() as i32 + 1 - y0).max(1) as usize);
+    let mut mask = Mask::new(w, h);
+    draw(l, m, &mut mask, (x0, y0));
+    (mask, x0, y0)
+}
+
+/// Translate-only transform helper.
+pub fn at(x: f32, y: f32) -> Xform {
+    let mut t = IDENTITY;
+    t[4] = x;
+    t[5] = y;
+    t
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::layout::{ParagraphStyle, TextStyle, layout};
+
+    fn ink(m: &Mask) -> f32 {
+        m.a.iter().sum()
+    }
+
+    #[test]
+    fn h_has_two_stems() {
+        let l = layout("H", &TextStyle { size: 40.0, ..Default::default() }, &ParagraphStyle::default());
+        let g = glyph_mask(&l.glyphs[0], 40.0, 0.0).unwrap();
+        let y = g.mask.h / 4;
+        let row: Vec<f32> = (0..g.mask.w).map(|x| g.mask.get(x, y)).collect();
+        assert!(row[1] > 0.9 && row[g.mask.w - 2] > 0.9, "{row:?}");
+        assert!(row[g.mask.w / 2] < 0.1, "{row:?}");
+        assert!(g.top < 0, "rises above the baseline");
+    }
+
+    #[test]
+    fn cached_and_outline_paths_agree() {
+        let l = layout("Title 42", &TextStyle { size: 48.0, ..Default::default() }, &ParagraphStyle::default());
+        let fast = rasterize(&l, &at(20.25, 60.0));
+        // a tiny rotation forces the outline path
+        let a = 1e-4f32;
+        let slow = rasterize(&l, &[a.cos(), a.sin(), -a.sin(), a.cos(), 20.25, 60.0]);
+        let (fi, si) = (ink(&fast.0), ink(&slow.0));
+        assert!((fi - si).abs() / fi < 0.02, "{fi} vs {si}");
+    }
+
+    #[test]
+    fn synthetic_styles() {
+        let base = TextStyle { size: 60.0, ..Default::default() };
+        let l = layout("Hello", &base, &ParagraphStyle::default());
+        let b = layout("Hello", &TextStyle { faux_bold: true, ..base.clone() }, &ParagraphStyle::default());
+        assert!(ink(&rasterize(&b, &IDENTITY).0) > ink(&rasterize(&l, &IDENTITY).0) * 1.1);
+        let i = layout("l", &TextStyle { faux_italic: true, ..base.clone() }, &ParagraphStyle::default());
+        let (mi, _, _) = rasterize(&i, &IDENTITY);
+        // the top of an italic l is further right than its bottom
+        let row_centre = |y: usize| {
+            let r: Vec<f32> = (0..mi.w).map(|x| mi.get(x, y)).collect();
+            let s: f32 = r.iter().sum();
+            r.iter().enumerate().map(|(x, v)| x as f32 * v).sum::<f32>() / s.max(1e-6)
+        };
+        let rows: Vec<usize> = (0..mi.h).filter(|&y| (0..mi.w).any(|x| mi.get(x, y) > 0.5)).collect();
+        assert!(row_centre(rows[2]) > row_centre(rows[rows.len() - 3]) + 3.0);
+    }
+
+    #[test]
+    fn rotated_text_draws() {
+        let l = layout("ROT", &TextStyle { size: 40.0, ..Default::default() }, &ParagraphStyle::default());
+        let a = 30f32.to_radians();
+        let (m, _, _) = rasterize(&l, &[a.cos(), a.sin(), -a.sin(), a.cos(), 0.0, 0.0]);
+        let (m0, _, _) = rasterize(&l, &IDENTITY);
+        assert!((ink(&m) - ink(&m0)).abs() / ink(&m0) < 0.03);
+    }
+}
diff --git a/crates/text/src/sfnt.rs b/crates/text/src/sfnt.rs
new file mode 100644
index 000000000..bb00d515f
--- /dev/null
+++ b/crates/text/src/sfnt.rs
@@ -0,0 +1,140 @@
+//! Minimal SFNT (TrueType / OpenType / collection) header reader for font discovery: reads only
+//! the table directory, `name` and `OS/2` of each face, so scanning a system font folder does not
+//! load whole files.
+
+use std::io::{Read, Seek, SeekFrom};
+
+/// Names and style attributes of one face in a font file.
+#[derive(Clone, Debug, PartialEq)]
+pub struct FaceNames {
+    pub index: u32,
+    pub family: String,
+    pub style: String,
+    pub full_name: String,
+    pub weight: u16,
+    pub italic: bool,
+}
+
+fn be16(b: &[u8], o: usize) -> Option<u16> {
+    Some(u16::from_be_bytes([*b.get(o)?, *b.get(o + 1)?]))
+}
+fn be32(b: &[u8], o: usize) -> Option<u32> {
+    Some(u32::from_be_bytes([*b.get(o)?, *b.get(o + 1)?, *b.get(o + 2)?, *b.get(o + 3)?]))
+}
+
+fn read_at<R: Read + Seek>(r: &mut R, off: u64, len: usize) -> Option<Vec<u8>> {
+    if len > 4 << 20 {
+        return None;
+    }
+    r.seek(SeekFrom::Start(off)).ok()?;
+    let mut v = vec![0u8; len];
+    r.read_exact(&mut v).ok()?;
+    Some(v)
+}
+
+/// Read the names of every face in a font file (a single font or a collection).
+pub fn read_faces<R: Read + Seek>(r: &mut R) -> Vec<FaceNames> {
+    let Some(head) = read_at(r, 0, 12) else { return Vec::new() };
+    let offsets: Vec<u32> = if &head[0..4] == b"ttcf" {
+        let n = be32(&head, 8).unwrap_or(0).min(256) as usize;
+        let Some(t) = read_at(r, 12, n * 4) else { return Vec::new() };
+        (0..n).filter_map(|i| be32(&t, i * 4)).collect()
+    } else {
+        vec![0]
+    };
+    offsets.iter().enumerate().filter_map(|(i, &o)| read_face(r, o as u64, i as u32)).collect()
+}
+
+/// Names from in-memory font data.
+pub fn read_faces_bytes(data: &[u8]) -> Vec<FaceNames> {
+    read_faces(&mut std::io::Cursor::new(data))
+}
+
+fn read_face<R: Read + Seek>(r: &mut R, off: u64, index: u32) -> Option<FaceNames> {
+    let h = read_at(r, off, 12)?;
+    let tag = &h[0..4];
+    if tag != [0, 1, 0, 0] && tag != b"OTTO" && tag != b"true" {
+        return None;
+    }
+    let n = be16(&h, 4)? as usize;
+    let dir = read_at(r, off + 12, n * 16)?;
+    let mut name = None;
+    let mut os2 = None;
+    for i in 0..n {
+        let rec = &dir[i * 16..i * 16 + 16];
+        let (o, l) = (be32(rec, 8)? as u64, be32(rec, 12)? as usize);
+        match &rec[0..4] {
+            b"name" => name = Some((o, l)),
+            b"OS/2" => os2 = Some((o, l)),
+            _ => {}
+        }
+    }
+    let (no, nl) = name?;
+    let nb = read_at(r, no, nl)?;
+    let get = |id: u16| name_string(&nb, id);
+    let family = get(16).or_else(|| get(1))?;
+    let style = get(17).or_else(|| get(2)).unwrap_or_else(|| "Regular".into());
+    let full_name = get(4).unwrap_or_else(|| format!("{family} {style}"));
+    let (mut weight, mut italic) = (400u16, false);
+    if let Some((oo, ol)) = os2
+        && let Some(ob) = read_at(r, oo, ol.min(78))
+    {
+        weight = be16(&ob, 4).unwrap_or(400);
+        italic = be16(&ob, 62).is_some_and(|fs| fs & 1 != 0);
+    }
+    let sl = style.to_ascii_lowercase();
+    italic |= sl.contains("italic") || sl.contains("oblique");
+    Some(FaceNames { index, family, style, full_name, weight, italic })
+}
+
+/// A name-table string by id, preferring Windows Unicode English, then any Unicode, then Mac Roman.
+fn name_string(b: &[u8], id: u16) -> Option<String> {
+    let count = be16(b, 2)? as usize;
+    let storage = be16(b, 4)? as usize;
+    let mut best: Option<(u8, String)> = None;
+    for i in 0..count {
+        let r = 6 + i * 12;
+        let (plat, enc, lang, nid, len, off) =
+            (be16(b, r)?, be16(b, r + 2)?, be16(b, r + 4)?, be16(b, r + 6)?, be16(b, r + 8)? as usize, be16(b, r + 10)? as usize);
+        if nid != id {
+            continue;
+        }
+        let raw = b.get(storage + off..storage + off + len)?;
+        let (rank, s) = match plat {
+            3 if enc == 1 || enc == 10 => {
+                let u: Vec<u16> = raw.chunks_exact(2).map(|c| u16::from_be_bytes([c[0], c[1]])).collect();
+                (if lang == 0x409 { 0 } else { 1 }, String::from_utf16_lossy(&u))
+            }
+            0 => {
+                let u: Vec<u16> = raw.chunks_exact(2).map(|c| u16::from_be_bytes([c[0], c[1]])).collect();
+                (2, String::from_utf16_lossy(&u))
+            }
+            1 if enc == 0 => (3, raw.iter().map(|&c| if c < 128 { c as char } else { '?' }).collect()),
+            _ => continue,
+        };
+        if best.as_ref().is_none_or(|(r0, _)| rank < *r0) {
+            best = Some((rank, s));
+        }
+    }
+    best.map(|(_, s)| s).filter(|s| !s.trim().is_empty())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn reads_bundled_names() {
+        let f = read_faces_bytes(crate::fonts::INTER_BOLD);
+        assert_eq!(f.len(), 1);
+        assert_eq!(f[0].family, "Inter");
+        assert_eq!(f[0].style, "Bold");
+        assert_eq!(f[0].weight, 700);
+        assert!(!f[0].italic);
+        let i = read_faces_bytes(crate::fonts::INTER_ITALIC);
+        assert!(i[0].italic, "{:?}", i[0]);
+        let n = read_faces_bytes(crate::fonts::NOTO_SERIF_REGULAR);
+        assert_eq!(n[0].family, "Noto Serif");
+        assert!(read_faces_bytes(b"not a font").is_empty());
+    }
+}
diff --git a/crates/ui-egui/Cargo.toml b/crates/ui-egui/Cargo.toml
index c832b76b3..bba3e4ed7 100644
--- a/crates/ui-egui/Cargo.toml
+++ b/crates/ui-egui/Cargo.toml
@@ -18,6 +18,7 @@ filmcraft-media = { workspace = true }
 filmcraft-project = { workspace = true }
 filmcraft-edit = { workspace = true }
 filmcraft-render = { workspace = true }
+filmcraft-text = { workspace = true }
 filmcraft-audio-dsp = { workspace = true }
 filmcraft-engine = { workspace = true }
 filmcraft-gpu = { workspace = true }
@@ -35,3 +36,5 @@ rustix = { version = "1", default-features = false, features = ["std", "time"] }
 [dev-dependencies]
 pollster = "0.4"
 filmcraft-codecs = { workspace = true }
+egui_kittest = { workspace = true, features = ["eframe", "wgpu"] }
+image = { version = "0.25", default-features = false, features = ["png"] }
diff --git a/crates/ui-egui/src/dock.rs b/crates/ui-egui/src/dock.rs
index 5dc96855c..c8d871d5c 100644
--- a/crates/ui-egui/src/dock.rs
+++ b/crates/ui-egui/src/dock.rs
@@ -100,10 +100,10 @@ impl PanelKind {
             PanelKind::Timeline => Some("Shift+3"),
             PanelKind::Program => Some("Shift+4"),
             PanelKind::EffectControls => Some("Shift+5"),
-            PanelKind::AudioClipMixer => Some("Shift+6"),
+            PanelKind::AudioClipMixer => Some("Shift+9"),
             PanelKind::Effects => Some("Shift+7"),
             PanelKind::MediaBrowser => Some("Shift+8"),
-            PanelKind::AudioTrackMixer => Some("Shift+9"),
+            PanelKind::AudioTrackMixer => Some("Shift+6"),
             _ => None,
         }
     }
diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index d69a5d2e8..9142652aa 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -50,6 +50,10 @@ pub struct HostHooks {
     pub pick_open_project: Option<Box<dyn FnMut() -> Option<String>>>,
     /// Save dialog with a filter: (filter name, extensions, suggested file name) → path.
     pub pick_save_as: Option<Box<dyn FnMut(&str, &[&str], &str) -> Option<String>>>,
+    /// The active keyboard shortcuts changed: update native menu key equivalents.
+    pub shortcuts_changed: Option<Box<dyn FnMut(&[menus::MenuItem])>>,
+    /// Open dialog for a JSON file (shortcut preset import): filter name, extensions → path.
+    pub pick_open_file: Option<Box<dyn FnMut(&str, &[&str]) -> Option<String>>>,
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -63,6 +67,8 @@ pub enum Dialog {
     Recovery,
     /// "Are you sure you want to discard your changes?" (File ▸ Revert).
     RevertConfirm,
+    /// Clip ▸ Audio Gain… (G).
+    AudioGain,
 }
 
 #[derive(Default)]
@@ -121,7 +127,11 @@ pub struct FilmcraftApp {
     pub last_timeline_width: f32,
     pub fps: f32,
     last_time: f64,
-    bindings: Vec<(egui::Modifiers, egui::Key, String)>,
+    bindings: Vec<menus::KeyBinding>,
+    /// Shortcut-set revision `bindings` (and the native menu) were built from.
+    bindings_rev: u64,
+    /// Keyboard Shortcuts dialog state.
+    pub shortcut_editor: panels::shortcuts_dialog::EditorState,
     pub toast: Option<(String, f64)>,
     pub tl: panels::timeline::TlState,
     /// Commands from outside the UI (native menu bar), invoked on the UI thread.
@@ -177,7 +187,8 @@ impl FilmcraftApp {
 }
 
 impl FilmcraftApp {
-    pub fn new(session: Session) -> Self {
+    pub fn new(mut session: Session) -> Self {
+        session.shortcuts.register_external(menus::external_commands());
         let recovery = !session.recovery_candidates().is_empty();
         let frames = Arc::new(FrameServer::new(session.media.clone(), session.services.clone(), session.previews.clone(), FrameServer::default_workers()));
         Self {
@@ -209,7 +220,9 @@ impl FilmcraftApp {
             last_timeline_width: 1000.0,
             fps: 60.0,
             last_time: 0.0,
-            bindings: menus::bindings(),
+            bindings: Vec::new(),
+            bindings_rev: 0,
+            shortcut_editor: Default::default(),
             toast: None,
             tl: Default::default(),
             command_inbox: None,
@@ -318,6 +331,11 @@ impl FilmcraftApp {
         self.playback.anchor_time = now;
         self.playback.anchor_tick = self.session.playhead();
         self.start_audio();
+        // Audio Track Mixer: an automation pass runs while playing forward in real time
+        if (self.playback.speed - 1.0).abs() < 1e-9 && !self.session.mixrec.active() {
+            let t = self.session.playhead();
+            let _ = self.session.execute("mixer.recordStart", json!({"time": t.0}));
+        }
     }
 
     pub fn stop(&mut self) {
@@ -329,6 +347,12 @@ impl FilmcraftApp {
             a.stop();
         }
         self.playback.audio_clock = false;
+        if self.session.mixrec.active() {
+            let t = self.session.playhead();
+            if let Err(e) = self.session.execute("mixer.recordStop", json!({"time": t.0})) {
+                self.ui.status = e.to_string();
+            }
+        }
     }
 
     fn start_audio(&mut self) {
@@ -347,7 +371,10 @@ impl FilmcraftApp {
         let Some(a) = self.audio.as_mut() else { return };
         let sr = a.sample_rate();
         let mut cursor = start_tick.to_units_floor(sr as i64);
+        previews.live.publish_project(project.clone());
         let fill = Box::new(move |buf: &mut [f32], ch: usize| {
+            // the newest project snapshot: mixer moves and other edits are heard while playing
+            let project = previews.live.project().filter(|p| p.sequence(seq_id).is_some()).unwrap_or_else(|| project.clone());
             let Some(seq) = project.sequence(seq_id) else { return };
             let n = buf.len() / ch.max(1);
             // Mix at the sequence rate; convert when the device rate differs (nearest sample).
@@ -553,12 +580,28 @@ impl FilmcraftApp {
     // ---------------------------------------------------------------- input
 
     fn handle_shortcuts(&mut self, ctx: &egui::Context) {
-        if ctx.egui_wants_keyboard_input() {
+        if self.bindings_rev != self.session.shortcuts.revision {
+            self.bindings = menus::bindings(self);
+            self.bindings_rev = self.session.shortcuts.revision;
+            if let Some(hook) = self.hooks.shortcuts_changed.as_mut() {
+                let items = menus::menu_items_for(&self.session);
+                hook(&items);
+            }
+        }
+        if ctx.egui_wants_keyboard_input() || self.dialog == Some(Dialog::Shortcuts) {
             return;
         }
+        // Esc cancels a dynamic trim in progress
+        if self.session.trim_play.dynamic.is_some() && ctx.input_mut(|i| i.consume_key(egui::Modifiers::NONE, egui::Key::Escape)) {
+            let _ = self.session.execute("trim.cancelDynamic", json!({}));
+        }
+        // Panel shortcuts of the focused panel first: they override application shortcuts.
+        let focused = self.ui.focused.title();
         let mut fire = Vec::new();
         ctx.input_mut(|i| {
-            for (m, k, id) in &self.bindings {
+            let panel = self.bindings.iter().filter(|b| b.3.as_deref() == Some(focused));
+            let app_wide = self.bindings.iter().filter(|b| b.3.is_none());
+            for (m, k, id, _) in panel.chain(app_wide) {
                 if i.consume_key(*m, *k) {
                     fire.push(id.clone());
                 }
@@ -681,6 +724,7 @@ impl FilmcraftApp {
         self.auto.begin_frame();
         self.frames.set_context(&ctx);
         self.session.poll_persistence();
+        panels::trim_monitor::advance(self, &ctx);
         if self.session.persistence.is_some() && self.session.is_dirty() {
             // Keep polling the auto-save worker (status, "also save the project" results).
             ctx.request_repaint_after(std::time::Duration::from_secs(1));
diff --git a/crates/ui-egui/src/menus.rs b/crates/ui-egui/src/menus.rs
index ef10d0013..482119a56 100644
--- a/crates/ui-egui/src/menus.rs
+++ b/crates/ui-egui/src/menus.rs
@@ -26,6 +26,9 @@ pub const UI_COMMANDS: &[UiCommand] = &[
     uic!("playback.forward", "Shuttle Right", [], Some("L")),
     uic!("playback.stop", "Shuttle Stop", [], Some("K")),
     uic!("playback.reverse", "Shuttle Left", [], Some("J")),
+    uic!("playback.slowForward", "Shuttle Slow Right", [], None),
+    uic!("playback.slowReverse", "Shuttle Slow Left", [], None),
+    uic!("playback.playAround", "Play Around", [], None),
     uic!("playback.inToOut", "Play In to Out", [], Some("Shift+Space")),
     uic!("playback.loop", "Loop", [], None),
     uic!("view.zoomIn", "Zoom In", ["View"], Some("=")),
@@ -64,7 +67,7 @@ pub const UI_COMMANDS: &[UiCommand] = &[
     uic!("mode.edit", "Edit", [], None),
     uic!("mode.export", "Export", ["File", "Export"], Some("Cmd+M")),
     uic!("app.about", "About FilmCraft", ["Help"], None),
-    uic!("help.shortcuts", "Keyboard Shortcuts", ["Help"], None),
+    uic!("app.keyboardShortcuts", "Keyboard Shortcuts…", ["Edit"], Some("Cmd+Alt+K")),
     uic!("app.preferences.autoSave", "Auto Save…", ["Edit", "Preferences"], Some("Cmd+,")),
 ];
 
@@ -94,7 +97,14 @@ pub fn invoke(app: &mut FilmcraftApp, ctx: &egui::Context, id: &str, params: Val
         app.ui.tool = tool;
         return Ok(json!({"tool": tool}));
     }
+    if let Some(r) = crate::panels::trim_monitor::route_transport(app, ctx, id) {
+        return r;
+    }
     match id {
+        "playback.slowForward" | "playback.slowReverse" => {
+            app.play(if id == "playback.slowForward" { 0.25 } else { -0.25 });
+            return Ok(json!({"speed": app.playback.speed}));
+        }
         "playback.toggle" => {
             app.toggle_play(1.0);
             return Ok(json!({"playing": app.playback.playing}));
@@ -154,8 +164,8 @@ pub fn invoke(app: &mut FilmcraftApp, ctx: &egui::Context, id: &str, params: Val
             app.dialog = Some(crate::Dialog::About);
             return Ok(Value::Null);
         }
-        "help.shortcuts" => {
-            app.dialog = Some(crate::Dialog::Shortcuts);
+        "help.shortcuts" | "app.keyboardShortcuts" => {
+            crate::panels::shortcuts_dialog::open(app);
             return Ok(Value::Null);
         }
         "app.preferences" | "app.preferences.autoSave" => {
@@ -163,6 +173,15 @@ pub fn invoke(app: &mut FilmcraftApp, ctx: &egui::Context, id: &str, params: Val
             app.dialog = Some(crate::Dialog::Preferences);
             return Ok(Value::Null);
         }
+        // Audio Gain from the menu or G opens the dialog; with params it applies directly.
+        "clip.audioGain" if params.as_object().is_none_or(|m| m.is_empty()) => {
+            filmcraft_engine::find_command("clip.audioGain").map_or(Ok(()), |c| (c.enabled)(&app.session))?;
+            if app.ui.audio_gain.mode.is_empty() {
+                app.ui.audio_gain.mode = "adjust".into();
+            }
+            app.dialog = Some(crate::Dialog::AudioGain);
+            return Ok(json!({"dialog": "audioGain"}));
+        }
         // From menus/shortcuts (no params) these ask first; agents pass params to act directly.
         "file.revert" if params.as_object().is_none_or(|m| m.is_empty()) && app.session.is_dirty() => {
             if app.session.path.is_none() {
@@ -227,6 +246,11 @@ pub struct MenuItem {
 pub const MENUS: [&str; 9] = ["File", "Edit", "Clip", "Sequence", "Markers", "Graphics and Titles", "View", "Window", "Help"];
 
 pub fn menu_items(app: &FilmcraftApp) -> Vec<MenuItem> {
+    menu_items_for(&app.session)
+}
+
+/// Menu entries with their live shortcuts and enablement.
+pub fn menu_items_for(session: &filmcraft_engine::Session) -> Vec<MenuItem> {
     let mut out = Vec::new();
     for c in filmcraft_engine::command_specs() {
         if c.menu.is_empty() {
@@ -236,8 +260,8 @@ pub fn menu_items(app: &FilmcraftApp) -> Vec<MenuItem> {
             id: c.id.into(),
             label: c.label.into(),
             path: c.menu.iter().map(|s| s.to_string()).collect(),
-            shortcut: c.shortcut.map(Into::into),
-            enabled: app.session.is_enabled(c.id),
+            shortcut: session.shortcuts.primary(c.id),
+            enabled: session.is_enabled(c.id),
         });
     }
     for c in UI_COMMANDS {
@@ -248,7 +272,7 @@ pub fn menu_items(app: &FilmcraftApp) -> Vec<MenuItem> {
             id: c.id.into(),
             label: c.label.into(),
             path: c.menu.iter().map(|s| s.to_string()).collect(),
-            shortcut: c.shortcut.map(Into::into),
+            shortcut: session.shortcuts.primary(c.id),
             enabled: true,
         });
     }
@@ -257,20 +281,17 @@ pub fn menu_items(app: &FilmcraftApp) -> Vec<MenuItem> {
             id: panel_command_id(p),
             label: p.title().into(),
             path: vec!["Window".into()],
-            shortcut: p.window_shortcut().map(Into::into),
+            shortcut: session.shortcuts.primary(&panel_command_id(p)),
             enabled: true,
         });
     }
     out
 }
 
-/// Pretty shortcut text for menus (macOS glyphs).
+/// Shortcut text for menus in this OS's notation (`⇧⌘K` on macOS, `Ctrl+Shift+K` elsewhere).
 pub fn shortcut_text(s: &str) -> String {
-    if cfg!(target_os = "macos") {
-        s.replace("Cmd+", "⌘").replace("Shift+", "⇧").replace("Alt+", "⌥").replace("Ctrl+", "⌃").replace("Backspace", "⌫").replace("Delete", "⌦")
-    } else {
-        s.replace("Cmd+", "Ctrl+")
-    }
+    use filmcraft_engine::shortcuts::{Chord, Platform};
+    Chord::parse(s).map(|c| c.display(Platform::current())).unwrap_or_else(|_| s.to_string())
 }
 
 /// Parse "Cmd+Shift+K" into modifiers + key.
@@ -303,26 +324,26 @@ pub fn parse_shortcut(s: &str) -> Option<(egui::Modifiers, egui::Key)> {
     key.map(|k| (m, k))
 }
 
-/// All shortcut bindings: (modifiers, key, command id).
-pub fn bindings() -> Vec<(egui::Modifiers, egui::Key, String)> {
-    let mut v = Vec::new();
-    for c in UI_COMMANDS {
-        if let Some((m, k)) = c.shortcut.and_then(parse_shortcut) {
-            v.push((m, k, c.id.to_string()));
-        }
-    }
-    for c in filmcraft_engine::command_specs() {
-        if let Some((m, k)) = c.shortcut.and_then(parse_shortcut) {
-            v.push((m, k, c.id.to_string()));
-        }
-    }
+/// One active key binding for the input loop: (modifiers, key, command id, panel or None).
+pub type KeyBinding = (egui::Modifiers, egui::Key, String, Option<String>);
+
+/// The active key bindings (from the engine's shortcut set), most specific first so Shift+I
+/// doesn't also fire I.
+pub fn bindings(app: &FilmcraftApp) -> Vec<KeyBinding> {
+    let mut v: Vec<KeyBinding> =
+        app.session.shortcuts.bindings.iter().filter_map(|b| parse_shortcut(&b.keys).map(|(m, k)| (m, k, b.command.clone(), b.panel.clone()))).collect();
+    v.sort_by_key(|(m, ..)| std::cmp::Reverse(m.command as u8 + m.shift as u8 + m.alt as u8 + m.ctrl as u8));
+    v
+}
+
+/// Frontend-owned commands, registered with the engine's shortcut set so they can be listed,
+/// rebound and resolved alongside engine commands (the `shortcuts.` commands).
+pub fn external_commands() -> Vec<filmcraft_engine::shortcuts::CommandInfo> {
+    use filmcraft_engine::shortcuts::CommandInfo;
+    let mut v: Vec<CommandInfo> = UI_COMMANDS.iter().map(|c| CommandInfo::new(c.id, c.label, c.menu, c.shortcut)).collect();
     for p in PanelKind::ALL {
-        if let Some((m, k)) = p.window_shortcut().and_then(parse_shortcut) {
-            v.push((m, k, panel_command_id(p)));
-        }
+        v.push(CommandInfo::new(&panel_command_id(p), p.title(), &["Window"], p.window_shortcut()));
     }
-    // Most specific (more modifiers) first so Shift+I doesn't also fire I.
-    v.sort_by_key(|(m, _, _)| std::cmp::Reverse(m.command as u8 + m.shift as u8 + m.alt as u8 + m.ctrl as u8));
     v
 }
 
diff --git a/crates/ui-egui/src/panels/dialogs.rs b/crates/ui-egui/src/panels/dialogs.rs
index 73436d25e..43b7b8fea 100644
--- a/crates/ui-egui/src/panels/dialogs.rs
+++ b/crates/ui-egui/src/panels/dialogs.rs
@@ -1,4 +1,5 @@
-//! Modal dialogs (About, Keyboard Shortcuts; Preferences/Recovery/Revert in `file_dialogs`).
+//! Modal dialogs (About; Keyboard Shortcuts in `shortcuts_dialog`; Preferences/Recovery/Revert in
+//! `file_dialogs`).
 
 use crate::{Dialog, FilmcraftApp};
 
@@ -21,22 +22,16 @@ pub fn show(app: &mut FilmcraftApp, ctx: &egui::Context) {
             });
         }
         Dialog::Shortcuts => {
-            egui::Window::new("Keyboard Shortcuts").open(&mut open).default_size([520.0, 520.0]).show(ctx, |ui| {
-                egui::ScrollArea::vertical().show(ui, |ui| {
-                    egui::Grid::new("shortcuts").striped(true).show(ui, |ui| {
-                        for c in filmcraft_engine::command_specs().iter().filter(|c| c.shortcut.is_some()) {
-                            ui.label(c.label);
-                            ui.monospace(crate::menus::shortcut_text(c.shortcut.unwrap_or("")));
-                            ui.end_row();
-                        }
-                        for c in crate::menus::UI_COMMANDS.iter().filter(|c| c.shortcut.is_some()) {
-                            ui.label(c.label);
-                            ui.monospace(crate::menus::shortcut_text(c.shortcut.unwrap_or("")));
-                            ui.end_row();
-                        }
-                    });
-                });
-            });
+            if !crate::panels::shortcuts_dialog::show(app, ctx) && app.dialog == Some(d) {
+                app.dialog = None;
+            }
+            return;
+        }
+        Dialog::AudioGain => {
+            if !audio_gain(app, ctx) {
+                app.dialog = None;
+            }
+            return;
         }
         Dialog::NewSequence | Dialog::Preferences | Dialog::Recovery | Dialog::RevertConfirm => {}
     }
@@ -44,3 +39,84 @@ pub fn show(app: &mut FilmcraftApp, ctx: &egui::Context) {
         app.dialog = None;
     }
 }
+
+/// Clip ▸ Audio Gain…: Set Gain to / Adjust Gain by / Normalize Max Peak to / Normalize All Peaks to,
+/// with the selection's peak amplitude. Returns whether the dialog stays open.
+///
+/// Automation ids: `audioGain.<set|adjust|normalizeMax|normalizeAll>` (radio buttons),
+/// `audioGain.<mode>.value` (dB fields), `audioGain.peak`, `audioGain.ok`, `audioGain.cancel`.
+fn audio_gain(app: &mut FilmcraftApp, ctx: &egui::Context) -> bool {
+    let peak_id = egui::Id::new("audio-gain-peak");
+    let rev = app.session.revision;
+    let cached: Option<(u64, Option<f64>)> = ctx.data(|d| d.get_temp(peak_id));
+    let peak = match cached {
+        Some((r, p)) if r == rev => p,
+        _ => {
+            let p = app.session.execute("clip.audioPeak", serde_json::json!({})).ok().and_then(|v| v["peakDb"].as_f64());
+            ctx.data_mut(|d| d.insert_temp(peak_id, (rev, p)));
+            p
+        }
+    };
+    let mut draft = app.ui.audio_gain.clone();
+    let mut keep = true;
+    let mut apply = false;
+    let mut elems: Vec<(String, egui::Rect, String)> = Vec::new();
+    egui::Window::new("Audio Gain").collapsible(false).resizable(false).anchor(egui::Align2::CENTER_CENTER, [0.0, 0.0]).show(ctx, |ui| {
+        ui.add_space(6.0);
+        egui::Grid::new("audio-gain").num_columns(2).spacing([12.0, 10.0]).show(ui, |ui| {
+            let rows: [(&str, &str, &mut f64); 4] = [
+                ("set", "Set Gain to:", &mut draft.set_db),
+                ("adjust", "Adjust Gain by:", &mut draft.adjust_db),
+                ("normalizeMax", "Normalize Max Peak to:", &mut draft.max_peak_db),
+                ("normalizeAll", "Normalize All Peaks to:", &mut draft.all_peaks_db),
+            ];
+            for (id, label, v) in rows {
+                let r = ui.radio(draft.mode == id, label);
+                elems.push((format!("audioGain.{id}"), r.rect, label.to_string()));
+                if r.clicked() {
+                    draft.mode = id.to_string();
+                }
+                let f = ui.add_enabled(draft.mode == id, egui::DragValue::new(v).speed(0.1).range(-96.0..=96.0).suffix(" dB"));
+                elems.push((format!("audioGain.{id}.value"), f.rect, format!("{v:.1} dB")));
+                ui.end_row();
+            }
+        });
+        ui.add_space(8.0);
+        let pk_text = format!("Peak Amplitude: {}", peak.map(|p| format!("{p:.1} dB")).unwrap_or_else(|| "—".into()));
+        let pk = ui.label(&pk_text);
+        elems.push(("audioGain.peak".into(), pk.rect, pk_text));
+        ui.add_space(8.0);
+        ui.horizontal(|ui| {
+            let c = ui.button("Cancel");
+            elems.push(("audioGain.cancel".into(), c.rect, "Cancel".into()));
+            if c.clicked() {
+                keep = false;
+            }
+            let o = ui.add(egui::Button::new(egui::RichText::new("OK").color(egui::Color32::WHITE)).fill(app.tokens.accent));
+            elems.push(("audioGain.ok".into(), o.rect, "OK".into()));
+            if o.clicked() {
+                apply = true;
+            }
+        });
+    });
+    for (id, r, l) in elems {
+        app.auto.add(&id, r, &l);
+    }
+    if ctx.input(|i| i.key_pressed(egui::Key::Escape)) {
+        keep = false;
+    }
+    if apply {
+        let db = match draft.mode.as_str() {
+            "set" => draft.set_db,
+            "normalizeMax" => draft.max_peak_db,
+            "normalizeAll" => draft.all_peaks_db,
+            _ => draft.adjust_db,
+        };
+        if let Err(e) = app.session.execute("clip.audioGain", serde_json::json!({"mode": draft.mode, "db": db})) {
+            app.ui.status = e.to_string();
+        }
+        keep = false;
+    }
+    app.ui.audio_gain = draft;
+    keep
+}
diff --git a/crates/ui-egui/src/panels/graphics.rs b/crates/ui-egui/src/panels/graphics.rs
new file mode 100644
index 000000000..14976a2f9
--- /dev/null
+++ b/crates/ui-egui/src/panels/graphics.rs
@@ -0,0 +1,1243 @@
+//! Graphics UI (M10.2): the Program-monitor overlay for graphic clips and the graphic sections of
+//! the Properties / Essential Graphics panels.
+//!
+//! Monitor overlay:
+//! - **Type tool (T):** click on empty picture → a new text layer (in the selected graphic clip
+//!   under the playhead, else a new graphic clip) with a caret; click on a text layer → caret at
+//!   the click. Typing edits the text (one undo step per typing session); arrows, Home/End,
+//!   Shift-selection, ⌘A, ⌘C/⌘X/⌘V, Return (new line) and Esc (stop editing) work as in a text
+//!   field. Double-clicking a text layer with the Selection tool also edits it.
+//! - **Selection tool:** click selects a layer (bounding box with handles); drag moves it; drag a
+//!   corner handle scales it.
+//! - **Rectangle / Ellipse tools:** drag out a shape. **Pen tool:** click points; click the first
+//!   point again (or press Return) to close the path; Esc cancels.
+//!
+//! All edits go through `graphics.*` commands. Automation ids: `program.layer.<clip>.<layer>`,
+//! `program.layer.<clip>.<layer>.handle.<n>`, `program.textEdit`, `graphics.*` in the panels.
+
+use egui::{Align2, Color32, Pos2, Rect, Sense, Stroke, StrokeKind, pos2, vec2};
+use filmcraft_geom::{Affine, Vec2};
+use filmcraft_project::graphic::{self, LayerContent, LayerSpec, eval_layer, layer_display_name, layer_indices};
+use filmcraft_project::{ClipId, EffectInstance, ItemKind, ParamValue, TrackItem};
+use filmcraft_render::graphic_clip::{layer_local_bounds, layer_matrix, text_layout};
+use filmcraft_time::Tick;
+use serde_json::{Value, json};
+
+use crate::FilmcraftApp;
+use crate::icons::{self, Icon};
+use crate::state::{GfxEdit, Tool};
+use crate::theme::Tokens;
+
+/// A graphic layer visible at the playhead, with its layer→screen transform.
+pub struct LayerView {
+    pub clip: ClipId,
+    pub layer: usize,
+    pub spec: LayerSpec,
+    pub to_screen: Affine,
+    /// Graphic canvas → screen (the clip's Motion and the monitor fit).
+    pub canvas_to_screen: Affine,
+    pub local: [f32; 4],
+}
+
+impl LayerView {
+    pub fn quad(&self) -> [Pos2; 4] {
+        let b = self.local;
+        [(b[0], b[1]), (b[2], b[1]), (b[2], b[3]), (b[0], b[3])].map(|(x, y)| sp(&self.to_screen, x, y))
+    }
+    fn to_local(&self, p: Pos2) -> Option<(f32, f32)> {
+        let v = self.to_screen.inverse()?.apply(Vec2::new(p.x as f64, p.y as f64));
+        Some((v.x as f32, v.y as f32))
+    }
+    fn hit(&self, p: Pos2) -> bool {
+        let pad = 4.0 / screen_scale(&self.to_screen).max(1e-6);
+        self.to_local(p).is_some_and(|(x, y)| x >= self.local[0] - pad && x <= self.local[2] + pad && y >= self.local[1] - pad && y <= self.local[3] + pad)
+    }
+    fn is_text(&self) -> bool {
+        matches!(self.spec.content, LayerContent::Text(_))
+    }
+}
+
+fn sp(a: &Affine, x: f32, y: f32) -> Pos2 {
+    let v = a.apply(Vec2::new(x as f64, y as f64));
+    pos2(v.x as f32, v.y as f32)
+}
+
+fn screen_scale(a: &Affine) -> f32 {
+    (a.a * a.d - a.b * a.c).abs().sqrt() as f32
+}
+
+/// Whether a clip id is a graphic clip in the active sequence.
+pub fn is_graphic_clip(app: &FilmcraftApp, c: ClipId) -> bool {
+    app.session
+        .active_sequence()
+        .and_then(|q| q.find_item(c))
+        .and_then(|(_, it)| app.session.project.item(it.item))
+        .is_some_and(|p| matches!(p.kind, ItemKind::Graphic { .. }))
+}
+
+/// The selected graphic clip, if any.
+pub fn selected_graphic(app: &FilmcraftApp) -> Option<(ClipId, TrackItem)> {
+    let q = app.session.active_sequence()?;
+    app.session.state.selection.iter().copied().find(|c| is_graphic_clip(app, *c)).and_then(|c| q.find_item(c).map(|(_, it)| (c, it.clone())))
+}
+
+/// Layers of the graphic clips visible at the playhead, front-most first.
+pub fn visible_layers(app: &FilmcraftApp, pic: Rect, frame: (u32, u32)) -> Vec<LayerView> {
+    let Some(seq) = app.session.active_sequence() else { return Vec::new() };
+    let t = app.session.playhead();
+    let k = pic.width() as f64 / frame.0.max(1) as f64;
+    let screen = Affine::translate(pic.min.x as f64, pic.min.y as f64).then_apply(&Affine::scale(k, k));
+    let mut out = Vec::new();
+    for tr in seq.video_tracks.iter().rev() {
+        if !tr.enabled {
+            continue;
+        }
+        let Some(it) = tr.item_at(t) else { continue };
+        if !it.enabled {
+            continue;
+        }
+        let Some(ItemKind::Graphic { width, height, .. }) = app.session.project.item(it.item).map(|p| &p.kind) else { continue };
+        let size = (*width, *height);
+        let mt = it.source_time_at(t);
+        let base = screen.then_apply(&filmcraft_render::motion_matrix(seq, it, size, mt));
+        let idx = layer_indices(&it.effects);
+        for (li, &ei) in idx.iter().enumerate().rev() {
+            if let Some(spec) = eval_layer(&it.effects[ei], mt, size) {
+                let local = layer_local_bounds(&spec);
+                out.push(LayerView { clip: it.id, layer: li, to_screen: base.then_apply(&layer_matrix(&spec)), canvas_to_screen: base, spec, local });
+            }
+        }
+    }
+    out
+}
+
+/// Screen → graphic-canvas mapping for new layers: the selected graphic clip under the playhead
+/// (its Motion applies), else the sequence frame.
+fn canvas_target(app: &FilmcraftApp, pic: Rect, frame: (u32, u32)) -> (Option<ClipId>, Affine) {
+    let k = pic.width() as f64 / frame.0.max(1) as f64;
+    let screen = Affine::translate(pic.min.x as f64, pic.min.y as f64).then_apply(&Affine::scale(k, k));
+    let t = app.session.playhead();
+    if let Some((c, it)) = selected_graphic(app)
+        && it.range().contains(t)
+        && let Some(seq) = app.session.active_sequence()
+        && let Some(ItemKind::Graphic { width, height, .. }) = app.session.project.item(it.item).map(|p| &p.kind)
+    {
+        let m = screen.then_apply(&filmcraft_render::motion_matrix(seq, &it, (*width, *height), it.source_time_at(t)));
+        return (Some(c), m);
+    }
+    (None, screen)
+}
+
+fn to_canvas(m: &Affine, p: Pos2) -> Vec2 {
+    m.inverse().map(|i| i.apply(Vec2::new(p.x as f64, p.y as f64))).unwrap_or_default()
+}
+
+fn text_of(spec: &LayerSpec) -> Option<&filmcraft_project::graphic::TextProps> {
+    match &spec.content {
+        LayerContent::Text(t) => Some(t),
+        _ => None,
+    }
+}
+
+fn prev_boundary(s: &str, i: usize) -> usize {
+    s[..i.min(s.len())].char_indices().next_back().map_or(0, |(b, _)| b)
+}
+fn next_boundary(s: &str, i: usize) -> usize {
+    let i = i.min(s.len());
+    s[i..].chars().next().map_or(i, |c| i + c.len_utf8())
+}
+
+#[derive(Clone, Copy, Debug)]
+enum DragKind {
+    Move,
+    /// A corner handle: scales about the layer's anchor.
+    Scale,
+    NewShape,
+    TextSelect,
+}
+
+#[derive(Clone, Copy, Debug)]
+struct DragState {
+    kind: DragKind,
+    clip: ClipId,
+    layer: usize,
+    start: Pos2,
+}
+
+const TEXT_EDIT_ID: &str = "gfx-text-edit";
+
+fn end_edit(app: &mut FilmcraftApp, ui: &egui::Ui) {
+    app.ui.gfx_edit = None;
+    ui.memory_mut(|m| m.surrender_focus(egui::Id::new(TEXT_EDIT_ID)));
+}
+
+/// Draw the overlay and handle graphics tools on the Program monitor picture `pic`.
+pub fn monitor_overlay(app: &mut FilmcraftApp, ui: &mut egui::Ui, pic: Rect, frame: (u32, u32)) {
+    let t = app.tokens;
+    let views = visible_layers(app, pic, frame);
+    let tool = app.ui.tool;
+    let accent = t.accent;
+    let painter = ui.painter().with_clip_rect(pic.expand(12.0));
+    for v in &views {
+        let q = v.quad();
+        let r = Rect::from_points(&q);
+        let name = layer_display_name_view(app, v);
+        app.auto.add(&format!("program.layer.{}.{}", v.clip.0, v.layer), r, &name);
+    }
+    let sel_clip = selected_graphic(app).map(|(c, _)| c);
+    let sel_layers = app.session.state.graphic_layers.clone();
+    let editing = app.ui.gfx_edit.clone();
+    // ---- boxes and handles
+    let graphics_tool = matches!(tool, Tool::Selection | Tool::Type | Tool::Rectangle | Tool::Ellipse | Tool::Pen);
+    if graphics_tool {
+        for v in views.iter().filter(|v| Some(v.clip) == sel_clip) {
+            let q = v.quad();
+            let selected = sel_layers.contains(&v.layer);
+            let is_edit = editing.as_ref().is_some_and(|e| e.clip == v.clip.0 && e.layer == v.layer);
+            let col = if selected || is_edit { accent } else { Color32::from_white_alpha(70) };
+            painter.add(egui::Shape::closed_line(q.to_vec(), Stroke::new(1.0, col)));
+            if selected && !is_edit {
+                for (n, c) in q.iter().enumerate() {
+                    let hr = Rect::from_center_size(*c, vec2(7.0, 7.0));
+                    painter.rect_filled(hr, 0.0, Color32::WHITE);
+                    painter.rect_stroke(hr, 0.0, Stroke::new(1.0, accent), StrokeKind::Middle);
+                    app.auto.add(&format!("program.layer.{}.{}.handle.{n}", v.clip.0, v.layer), hr.expand(3.0), "scale handle");
+                }
+                for i in 0..4 {
+                    let m = q[i] + (q[(i + 1) % 4] - q[i]) * 0.5;
+                    painter.rect_filled(Rect::from_center_size(m, vec2(5.0, 5.0)), 0.0, Color32::WHITE);
+                }
+                // anchor point
+                let a = sp(&v.to_screen, v.spec.transform.anchor.x as f32, v.spec.transform.anchor.y as f32);
+                painter.circle_stroke(a, 4.0, Stroke::new(1.0, accent));
+                painter.line_segment([a - vec2(6.0, 0.0), a + vec2(6.0, 0.0)], Stroke::new(1.0, accent));
+                painter.line_segment([a - vec2(0.0, 6.0), a + vec2(0.0, 6.0)], Stroke::new(1.0, accent));
+            }
+        }
+    }
+    let id = egui::Id::new("gfx-overlay");
+    let resp = ui.interact(pic, id, if graphics_tool { Sense::click_and_drag() } else { Sense::hover() });
+    let hover = resp.hover_pos();
+    let mut actions: Vec<(String, Value)> = Vec::new();
+    let drag_id = id.with("drag");
+    let mut drag: Option<DragState> = ui.data(|d| d.get_temp(drag_id));
+
+    // cursors
+    if let Some(p) = hover {
+        match tool {
+            Tool::Type => ui.ctx().set_cursor_icon(egui::CursorIcon::Text),
+            Tool::Rectangle | Tool::Ellipse | Tool::Pen => ui.ctx().set_cursor_icon(egui::CursorIcon::Crosshair),
+            Tool::Selection => {
+                if editing.as_ref().is_some_and(|e| views.iter().any(|v| v.clip.0 == e.clip && v.layer == e.layer && v.hit(p))) {
+                    ui.ctx().set_cursor_icon(egui::CursorIcon::Text);
+                } else if views.iter().any(|v| v.hit(p)) {
+                    ui.ctx().set_cursor_icon(egui::CursorIcon::Move);
+                }
+            }
+            _ => {}
+        }
+    }
+
+    // ---- text editing
+    if let Some(ed) = editing.clone() {
+        match views.iter().find(|v| v.clip.0 == ed.clip && v.layer == ed.layer && v.is_text()) {
+            Some(v) => text_edit(app, ui, v, ed, &resp, &mut actions),
+            None => end_edit(app, ui),
+        }
+    }
+    let editing = app.ui.gfx_edit.clone();
+    let edit_view = editing.as_ref().and_then(|e| views.iter().find(|v| v.clip.0 == e.clip && v.layer == e.layer));
+
+    // ---- presses
+    if graphics_tool && resp.drag_started() {
+        let p = resp.interact_pointer_pos().unwrap_or(pic.center());
+        let shift = ui.input(|i| i.modifiers.shift);
+        let in_edit = edit_view.is_some_and(|v| v.hit(p));
+        drag = None;
+        if in_edit {
+            if let (Some(v), Some(mut ed)) = (edit_view, editing.clone()) {
+                let l = text_layout(text_of(&v.spec).expect("text"));
+                if let Some((x, y)) = v.to_local(p) {
+                    ed.caret = l.hit(x, y);
+                    if !shift {
+                        ed.anchor = ed.caret;
+                    }
+                    app.ui.gfx_edit = Some(ed);
+                }
+                drag = Some(DragState { kind: DragKind::TextSelect, clip: v.clip, layer: v.layer, start: p });
+            }
+        } else {
+            match tool {
+                Tool::Selection | Tool::Type => {
+                    // handles of the selected layers first
+                    let handle = views
+                        .iter()
+                        .filter(|v| Some(v.clip) == sel_clip && sel_layers.contains(&v.layer))
+                        .find_map(|v| v.quad().iter().position(|c| (*c - p).length() <= 7.0).map(|_| (v.clip, v.layer)));
+                    if let Some((c, l)) = handle {
+                        drag = Some(DragState { kind: DragKind::Scale, clip: c, layer: l, start: p });
+                    } else if tool == Tool::Selection
+                        && let Some(v) = views.iter().find(|v| v.hit(p))
+                    {
+                        if editing.is_some() {
+                            end_edit(app, ui);
+                        }
+                        if !(Some(v.clip) == sel_clip && sel_layers.contains(&v.layer)) {
+                            actions.push(("graphics.selectLayer".into(), json!({"clip": v.clip.0, "layers": [v.layer]})));
+                        }
+                        drag = Some(DragState { kind: DragKind::Move, clip: v.clip, layer: v.layer, start: p });
+                    }
+                }
+                Tool::Rectangle | Tool::Ellipse => {
+                    drag = Some(DragState { kind: DragKind::NewShape, clip: ClipId(0), layer: 0, start: p });
+                }
+                _ => {}
+            }
+        }
+        ui.data_mut(|dd| {
+            if let Some(d) = drag {
+                dd.insert_temp(drag_id, d);
+            } else {
+                dd.remove::<DragState>(drag_id);
+            }
+        });
+    }
+    // ---- drag feedback / commit
+    if let Some(d) = drag {
+        let cur = resp.interact_pointer_pos().or(hover).unwrap_or(d.start);
+        let v = views.iter().find(|v| v.clip == d.clip && v.layer == d.layer);
+        match d.kind {
+            DragKind::Move => {
+                if let Some(v) = v {
+                    let off = cur - d.start;
+                    painter.add(egui::Shape::closed_line(v.quad().iter().map(|q| *q + off).collect(), Stroke::new(1.0, Color32::WHITE)));
+                }
+            }
+            DragKind::Scale => {
+                if let Some(v) = v {
+                    let a = sp(&v.to_screen, v.spec.transform.anchor.x as f32, v.spec.transform.anchor.y as f32);
+                    let f = ((cur - a).length() / (d.start - a).length().max(1.0)).max(0.01);
+                    painter.add(egui::Shape::closed_line(v.quad().iter().map(|q| a + (*q - a) * f).collect(), Stroke::new(1.0, Color32::WHITE)));
+                }
+            }
+            DragKind::NewShape => {
+                let r = Rect::from_two_pos(d.start, cur);
+                if tool == Tool::Ellipse {
+                    painter.add(egui::Shape::ellipse_stroke(r.center(), r.size() / 2.0, Stroke::new(1.0, Color32::WHITE)));
+                } else {
+                    painter.rect_stroke(r, 0.0, Stroke::new(1.0, Color32::WHITE), StrokeKind::Middle);
+                }
+            }
+            DragKind::TextSelect => {
+                if let (Some(v), Some(mut ed)) = (v, app.ui.gfx_edit.clone()) {
+                    let l = text_layout(text_of(&v.spec).expect("text"));
+                    if let Some((x, y)) = v.to_local(cur) {
+                        ed.caret = l.hit(x, y);
+                        app.ui.gfx_edit = Some(ed);
+                    }
+                }
+            }
+        }
+        if resp.drag_stopped() {
+            ui.data_mut(|dd| dd.remove::<DragState>(drag_id));
+            let moved = (cur - d.start).length() > 2.0;
+            match d.kind {
+                DragKind::Move if moved => {
+                    if let Some(v) = v {
+                        let lin = Affine { e: 0.0, f: 0.0, ..v.canvas_to_screen };
+                        let delta = lin.inverse().map(|i| i.apply(Vec2::new((cur.x - d.start.x) as f64, (cur.y - d.start.y) as f64))).unwrap_or_default();
+                        let p0 = v.spec.transform.position;
+                        actions.push((
+                            "graphics.set".into(),
+                            json!({"clip": v.clip.0, "layer": v.layer, "props": {"position": [p0.x + delta.x, p0.y + delta.y]}}),
+                        ));
+                    }
+                }
+                DragKind::Scale if moved => {
+                    if let Some(v) = v {
+                        let a = sp(&v.to_screen, v.spec.transform.anchor.x as f32, v.spec.transform.anchor.y as f32);
+                        let f = ((cur - a).length() / (d.start - a).length().max(1.0)).max(0.01) as f64;
+                        let s = v.spec.transform.scale;
+                        actions.push((
+                            "graphics.set".into(),
+                            json!({"clip": v.clip.0, "layer": v.layer, "props": {"scale": s.y * 100.0 * f, "scale_width": s.x * 100.0 * f}}),
+                        ));
+                    }
+                }
+                DragKind::NewShape if moved => {
+                    let (into, m) = canvas_target(app, pic, frame);
+                    let (a, b) = (to_canvas(&m, d.start), to_canvas(&m, cur));
+                    let c = Vec2::new((a.x + b.x) / 2.0, (a.y + b.y) / 2.0);
+                    let mut p = json!({
+                        "shape": if tool == Tool::Ellipse { "ellipse" } else { "rectangle" },
+                        "position": [c.x, c.y],
+                        "size": [(b.x - a.x).abs(), (b.y - a.y).abs()],
+                    });
+                    if let Some(cl) = into {
+                        p["clip"] = json!(cl.0);
+                    }
+                    actions.push(("graphics.newShape".into(), p));
+                }
+                _ => {}
+            }
+        }
+    }
+    // ---- clicks
+    if graphics_tool && resp.clicked() && drag.is_none_or(|d| !matches!(d.kind, DragKind::TextSelect)) {
+        let p = resp.interact_pointer_pos().unwrap_or(pic.center());
+        let in_edit = edit_view.is_some_and(|v| v.hit(p));
+        match tool {
+            _ if in_edit => {}
+            Tool::Type => {
+                if let Some(v) = views.iter().find(|v| v.is_text() && v.hit(p)) {
+                    start_edit_at(app, ui, v, p, &mut actions);
+                } else {
+                    end_edit(app, ui);
+                    let (into, m) = canvas_target(app, pic, frame);
+                    let c = to_canvas(&m, p);
+                    let size = 100.0 * frame.1 as f64 / 1080.0;
+                    let mut prm = json!({"text": "", "position": [c.x, c.y], "size": size.round()});
+                    if let Some(cl) = into {
+                        prm["clip"] = json!(cl.0);
+                    }
+                    actions.push(("graphics.newText#edit".into(), prm));
+                }
+            }
+            Tool::Selection => {
+                if resp.double_clicked() {
+                    if let Some(v) = views.iter().find(|v| v.is_text() && v.hit(p)) {
+                        start_edit_at(app, ui, v, p, &mut actions);
+                    }
+                } else if let Some(v) = views.iter().find(|v| v.hit(p)) {
+                    if app.ui.gfx_edit.is_some() {
+                        end_edit(app, ui);
+                    }
+                    actions.push(("graphics.selectLayer".into(), json!({"clip": v.clip.0, "layers": [v.layer]})));
+                } else if app.ui.gfx_edit.is_some() {
+                    end_edit(app, ui);
+                } else if sel_clip.is_some() && !sel_layers.is_empty() {
+                    app.session.state.graphic_layers.clear();
+                }
+            }
+            Tool::Pen => {
+                let (_, m) = canvas_target(app, pic, frame);
+                let c = to_canvas(&m, p);
+                let close = app.ui.pen_points.len() >= 3
+                    && app.ui.pen_points.first().is_some_and(|f| {
+                        let fs = m.apply(Vec2::new(f[0], f[1]));
+                        (pos2(fs.x as f32, fs.y as f32) - p).length() <= 8.0
+                    });
+                if close {
+                    finish_pen(app, pic, frame, &mut actions);
+                } else {
+                    app.ui.pen_points.push([c.x, c.y]);
+                }
+            }
+            _ => {}
+        }
+    }
+    // ---- pen path in progress
+    if tool == Tool::Pen && !app.ui.pen_points.is_empty() {
+        let (_, m) = canvas_target(app, pic, frame);
+        let pts: Vec<Pos2> = app.ui.pen_points.iter().map(|q| m.apply(Vec2::new(q[0], q[1]))).map(|v| pos2(v.x as f32, v.y as f32)).collect();
+        painter.add(egui::Shape::line(pts.clone(), Stroke::new(1.0, accent)));
+        if let (Some(last), Some(h)) = (pts.last(), hover) {
+            painter.line_segment([*last, h], Stroke::new(1.0, accent.gamma_multiply(0.5)));
+        }
+        for (i, q) in pts.iter().enumerate() {
+            painter.rect_filled(Rect::from_center_size(*q, vec2(6.0, 6.0)), 0.0, if i == 0 { accent } else { Color32::WHITE });
+        }
+        let (enter, esc) = ui.input(|i| (i.key_pressed(egui::Key::Enter), i.key_pressed(egui::Key::Escape)));
+        if enter && app.ui.pen_points.len() >= 3 {
+            finish_pen(app, pic, frame, &mut actions);
+        } else if esc {
+            app.ui.pen_points.clear();
+        }
+    } else if tool != Tool::Pen && !app.ui.pen_points.is_empty() {
+        app.ui.pen_points.clear();
+    }
+    // ---- caret / selection drawing
+    if let Some(ed) = app.ui.gfx_edit.clone()
+        && let Some(v) = views.iter().find(|v| v.clip.0 == ed.clip && v.layer == ed.layer)
+        && let Some(tp) = text_of(&v.spec)
+    {
+        let l = text_layout(tp);
+        let caret = ed.caret.min(tp.text.len());
+        for r in l.selection_rects(ed.anchor.min(tp.text.len()), caret) {
+            let q = [(r[0], r[1]), (r[2], r[1]), (r[2], r[3]), (r[0], r[3])].map(|(x, y)| sp(&v.to_screen, x, y));
+            painter.add(egui::Shape::convex_polygon(q.to_vec(), Color32::from_rgba_unmultiplied(80, 140, 255, 90), Stroke::NONE));
+        }
+        let (x, base, li) = l.caret(caret);
+        let line = &l.lines[li.min(l.lines.len() - 1)];
+        let (a, b) = (sp(&v.to_screen, x, base - line.ascent), sp(&v.to_screen, x, base + line.descent));
+        painter.line_segment([a, b], Stroke::new(1.5, Color32::WHITE));
+        painter.line_segment([a + vec2(1.0, 0.0), b + vec2(1.0, 0.0)], Stroke::new(0.5, Color32::BLACK));
+        let er = Rect::from_points(&v.quad()).union(Rect::from_two_pos(a, b));
+        app.auto.add("program.textEdit", er, &tp.text);
+        ui.ctx().output_mut(|o| {
+            o.ime = Some(egui::output::IMEOutput {
+                purpose: Default::default(),
+                rect: er,
+                cursor_rect: Rect::from_two_pos(a, b),
+                should_interrupt_composition: false,
+            })
+        });
+    }
+    // ---- run
+    for (cmd, p) in actions {
+        let (cmd, then_edit) = match cmd.strip_suffix("#edit") {
+            Some(c) => (c.to_string(), true),
+            None => (cmd, false),
+        };
+        match app.session.execute(&cmd, p) {
+            Ok(r) => {
+                if then_edit && let (Some(c), Some(l)) = (r["clip"].as_u64(), r["layer"].as_u64()) {
+                    app.ui.gfx_edit = Some(GfxEdit { clip: c, layer: l as usize, caret: 0, anchor: 0 });
+                    app.ui.focused = crate::dock::PanelKind::Program;
+                }
+            }
+            Err(e) => app.ui.status = e.to_string(),
+        }
+    }
+}
+
+fn layer_display_name_view(app: &FilmcraftApp, v: &LayerView) -> String {
+    app.session
+        .active_sequence()
+        .and_then(|q| q.find_item(v.clip))
+        .and_then(|(_, it)| layer_indices(&it.effects).get(v.layer).map(|&e| layer_display_name(&it.effects[e], v.layer)))
+        .unwrap_or_default()
+}
+
+fn finish_pen(app: &mut FilmcraftApp, pic: Rect, frame: (u32, u32), actions: &mut Vec<(String, Value)>) {
+    let pts = std::mem::take(&mut app.ui.pen_points);
+    if pts.len() < 3 {
+        return;
+    }
+    let n = pts.len() as f64;
+    let (cx, cy) = (pts.iter().map(|p| p[0]).sum::<f64>() / n, pts.iter().map(|p| p[1]).sum::<f64>() / n);
+    let (into, _) = canvas_target(app, pic, frame);
+    let mut p = json!({
+        "shape": "path",
+        "position": [cx, cy],
+        "points": pts.iter().map(|q| [q[0] - cx, q[1] - cy]).collect::<Vec<_>>(),
+    });
+    if let Some(c) = into {
+        p["clip"] = json!(c.0);
+    }
+    actions.push(("graphics.newShape".into(), p));
+}
+
+fn start_edit_at(app: &mut FilmcraftApp, ui: &egui::Ui, v: &LayerView, p: Pos2, actions: &mut Vec<(String, Value)>) {
+    let Some(tp) = text_of(&v.spec) else { return };
+    let l = text_layout(tp);
+    let caret = v.to_local(p).map_or(tp.text.len(), |(x, y)| l.hit(x, y));
+    app.ui.gfx_edit = Some(GfxEdit { clip: v.clip.0, layer: v.layer, caret, anchor: caret });
+    app.ui.focused = crate::dock::PanelKind::Program;
+    let _ = ui;
+    actions.push(("graphics.selectLayer".into(), json!({"clip": v.clip.0, "layers": [v.layer]})));
+}
+
+/// Keyboard handling while a text layer is being edited.
+fn text_edit(app: &mut FilmcraftApp, ui: &mut egui::Ui, v: &LayerView, mut ed: GfxEdit, resp: &egui::Response, actions: &mut Vec<(String, Value)>) {
+    let _ = resp;
+    let eid = egui::Id::new(TEXT_EDIT_ID);
+    // a real (non-clickable) widget holds keyboard focus so shortcuts pause while typing
+    let fr = ui.interact(Rect::from_points(&v.quad()), eid, Sense::focusable_noninteractive());
+    fr.widget_info(|| egui::WidgetInfo::labeled(egui::WidgetType::TextEdit, true, "Text layer"));
+    ui.memory_mut(|m| {
+        m.request_focus(eid);
+        m.set_focus_lock_filter(eid, egui::EventFilter { tab: true, horizontal_arrows: true, vertical_arrows: true, escape: true });
+    });
+    let Some(tp) = text_of(&v.spec) else { return };
+    let mut text = tp.text.clone();
+    ed.caret = ed.caret.min(text.len());
+    ed.anchor = ed.anchor.min(text.len());
+    let l = text_layout(tp);
+    let events = ui.input(|i| i.events.clone());
+    let mut changed = false;
+    let mut stop = false;
+    let sel = |ed: &GfxEdit| (ed.caret.min(ed.anchor), ed.caret.max(ed.anchor));
+    let delete_sel = |text: &mut String, ed: &mut GfxEdit| -> bool {
+        let (a, b) = sel(ed);
+        if a == b {
+            return false;
+        }
+        text.replace_range(a..b, "");
+        ed.caret = a;
+        ed.anchor = a;
+        true
+    };
+    for ev in events {
+        match ev {
+            egui::Event::Text(s) | egui::Event::Paste(s) => {
+                let s: String = s.chars().filter(|c| !c.is_control() || *c == '\n').collect();
+                if s.is_empty() {
+                    continue;
+                }
+                delete_sel(&mut text, &mut ed);
+                text.insert_str(ed.caret, &s);
+                ed.caret += s.len();
+                ed.anchor = ed.caret;
+                changed = true;
+            }
+            egui::Event::Copy | egui::Event::Cut => {
+                let (a, b) = sel(&ed);
+                if a < b {
+                    ui.ctx().copy_text(text[a..b].to_string());
+                    if matches!(ev, egui::Event::Cut) {
+                        changed |= delete_sel(&mut text, &mut ed);
+                    }
+                }
+            }
+            egui::Event::Key { key, pressed: true, modifiers, .. } => {
+                let shift = modifiers.shift;
+                let mut moved = None;
+                match key {
+                    egui::Key::Escape => stop = true,
+                    egui::Key::Enter => {
+                        delete_sel(&mut text, &mut ed);
+                        text.insert(ed.caret, '\n');
+                        ed.caret += 1;
+                        ed.anchor = ed.caret;
+                        changed = true;
+                    }
+                    egui::Key::Backspace => {
+                        if !delete_sel(&mut text, &mut ed) && ed.caret > 0 {
+                            let p = if modifiers.alt || modifiers.command { word_left(&text, ed.caret) } else { prev_boundary(&text, ed.caret) };
+                            text.replace_range(p..ed.caret, "");
+                            ed.caret = p;
+                            ed.anchor = p;
+                        }
+                        changed = true;
+                    }
+                    egui::Key::Delete => {
+                        if !delete_sel(&mut text, &mut ed) && ed.caret < text.len() {
+                            let n = next_boundary(&text, ed.caret);
+                            text.replace_range(ed.caret..n, "");
+                        }
+                        changed = true;
+                    }
+                    egui::Key::A if modifiers.command => {
+                        ed.anchor = 0;
+                        ed.caret = text.len();
+                    }
+                    egui::Key::ArrowLeft => {
+                        let (a, _) = sel(&ed);
+                        moved = Some(if !shift && ed.caret != ed.anchor {
+                            a
+                        } else if modifiers.command {
+                            l.lines[l.caret(ed.caret).2].range.start
+                        } else if modifiers.alt {
+                            word_left(&text, ed.caret)
+                        } else {
+                            prev_boundary(&text, ed.caret)
+                        });
+                    }
+                    egui::Key::ArrowRight => {
+                        let (_, b) = sel(&ed);
+                        moved = Some(if !shift && ed.caret != ed.anchor {
+                            b
+                        } else if modifiers.command {
+                            l.lines[l.caret(ed.caret).2].range.end
+                        } else if modifiers.alt {
+                            word_right(&text, ed.caret)
+                        } else {
+                            next_boundary(&text, ed.caret)
+                        });
+                    }
+                    egui::Key::ArrowUp | egui::Key::ArrowDown => {
+                        let (x, _, li) = l.caret(ed.caret);
+                        let target = if key == egui::Key::ArrowUp { li.checked_sub(1) } else { Some(li + 1).filter(|n| *n < l.lines.len()) };
+                        moved = Some(match target {
+                            Some(n) => l.hit(x, l.lines[n].baseline),
+                            None if key == egui::Key::ArrowUp => 0,
+                            None => text.len(),
+                        });
+                    }
+                    egui::Key::Home => moved = Some(l.lines[l.caret(ed.caret).2].range.start),
+                    egui::Key::End => moved = Some(l.lines[l.caret(ed.caret).2].range.end),
+                    _ => {}
+                }
+                if let Some(m) = moved {
+                    ed.caret = m.min(text.len());
+                    if !shift {
+                        ed.anchor = ed.caret;
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+    if changed && text != tp.text {
+        actions.push(("graphics.setText".into(), json!({"clip": ed.clip, "layer": ed.layer, "text": text, "merge": true})));
+    }
+    if stop {
+        end_edit(app, ui);
+    } else {
+        app.ui.gfx_edit = Some(ed);
+    }
+}
+
+fn word_left(s: &str, i: usize) -> usize {
+    let mut j = i;
+    let b: Vec<(usize, char)> = s[..i].char_indices().collect();
+    let mut k = b.len();
+    while k > 0 && b[k - 1].1.is_whitespace() {
+        k -= 1;
+    }
+    while k > 0 && !b[k - 1].1.is_whitespace() {
+        k -= 1;
+    }
+    if k < b.len() {
+        j = b[k].0;
+    }
+    if k == 0 { 0 } else { j }
+}
+
+fn word_right(s: &str, i: usize) -> usize {
+    let mut it = s[i..].char_indices().peekable();
+    while it.peek().is_some_and(|(_, c)| c.is_whitespace()) {
+        it.next();
+    }
+    while it.peek().is_some_and(|(_, c)| !c.is_whitespace()) {
+        it.next();
+    }
+    it.peek().map_or(s.len(), |(b, _)| i + b)
+}
+
+// ---------------------------------------------------------------------------------------------
+// Properties / Essential Graphics
+// ---------------------------------------------------------------------------------------------
+
+const ROW: f32 = 28.0;
+
+fn pv(e: &EffectInstance, id: &str, mt: Tick) -> ParamValue {
+    e.params.get(id).map(|p| p.value_at(mt)).or_else(|| e.def().and_then(|d| d.param(id)).map(|d| d.default.clone())).unwrap_or(ParamValue::Float(0.0))
+}
+
+fn color32(c: [f32; 4]) -> Color32 {
+    let q = |v: f32| (v.clamp(0.0, 1.0) * 255.0).round() as u8;
+    Color32::from_rgba_unmultiplied(q(c[0]), q(c[1]), q(c[2]), q(c[3]))
+}
+
+struct Ctx<'a> {
+    clip: ClipId,
+    layer: usize,
+    e: &'a EffectInstance,
+    mt: Tick,
+    t: Tokens,
+    actions: Vec<(String, Value)>,
+    autos: Vec<(String, Rect, String)>,
+}
+
+impl Ctx<'_> {
+    fn set(&mut self, id: &str, v: Value) {
+        self.actions.push(("graphics.set".into(), json!({"clip": self.clip.0, "layer": self.layer, "props": {id: v}})));
+    }
+    fn auto(&mut self, id: &str, r: Rect, label: &str) {
+        self.autos.push((format!("graphics.prop.{id}"), r, label.to_string()));
+    }
+    fn row(&self, ui: &mut egui::Ui, label: &str) -> (Rect, egui::Ui) {
+        let (r, _) = ui.allocate_exact_size(vec2(ui.available_width(), ROW), Sense::hover());
+        ui.painter().text(pos2(r.min.x + 18.0, r.center().y), Align2::LEFT_CENTER, label, Tokens::ui(12.0), self.t.text_dim);
+        let v = ui.new_child(
+            egui::UiBuilder::new()
+                .max_rect(Rect::from_min_max(pos2(r.min.x + 130.0, r.min.y + 3.0), pos2(r.max.x - 6.0, r.max.y - 3.0)))
+                .layout(egui::Layout::left_to_right(egui::Align::Center)),
+        );
+        (r, v)
+    }
+    fn number(&mut self, ui: &mut egui::Ui, label: &str, id: &str, speed: f64, range: (f64, f64), dec: usize, unit: &str) {
+        let v = pv(self.e, id, self.mt).as_f64().unwrap_or(0.0);
+        let (r, mut vui) = self.row(ui, label);
+        let (resp, nv) = crate::widgets::hot_number(&mut vui, egui::Id::new(("gfxp", self.clip.0, self.layer, id)), v, speed, range, dec, unit, &self.t);
+        self.auto(id, resp.rect, label);
+        let _ = r;
+        if let Some(nv) = nv {
+            self.set(id, json!(nv));
+        }
+    }
+    fn number_in(&mut self, vui: &mut egui::Ui, id: &str, speed: f64, range: (f64, f64), dec: usize, unit: &str) {
+        let v = pv(self.e, id, self.mt).as_f64().unwrap_or(0.0);
+        let (resp, nv) = crate::widgets::hot_number(vui, egui::Id::new(("gfxp", self.clip.0, self.layer, id)), v, speed, range, dec, unit, &self.t);
+        self.auto(id, resp.rect, id);
+        if let Some(nv) = nv {
+            self.set(id, json!(nv));
+        }
+    }
+    fn point(&mut self, ui: &mut egui::Ui, label: &str, id: &str) {
+        let v = pv(self.e, id, self.mt).as_vec2().unwrap_or_default();
+        let (_, mut vui) = self.row(ui, label);
+        let (rx, nx) = crate::widgets::hot_number(
+            &mut vui,
+            egui::Id::new(("gfxp", self.clip.0, self.layer, id, "x")),
+            v.x,
+            1.0,
+            (-100_000.0, 100_000.0),
+            1,
+            " X",
+            &self.t,
+        );
+        vui.add_space(10.0);
+        let (ry, ny) = crate::widgets::hot_number(
+            &mut vui,
+            egui::Id::new(("gfxp", self.clip.0, self.layer, id, "y")),
+            v.y,
+            1.0,
+            (-100_000.0, 100_000.0),
+            1,
+            " Y",
+            &self.t,
+        );
+        self.auto(&format!("{id}.x"), rx.rect, label);
+        self.auto(&format!("{id}.y"), ry.rect, label);
+        if nx.is_some() || ny.is_some() {
+            self.set(id, json!([nx.unwrap_or(v.x), ny.unwrap_or(v.y)]));
+        }
+    }
+    fn check(&mut self, vui: &mut egui::Ui, id: &str, label: &str) -> bool {
+        let mut b = pv(self.e, id, self.mt).as_bool().unwrap_or(false);
+        let r = vui.checkbox(&mut b, label);
+        self.auto(id, r.rect, label);
+        if r.changed() {
+            self.set(id, json!(b));
+        }
+        b
+    }
+    fn color(&mut self, vui: &mut egui::Ui, id: &str) {
+        let c = pv(self.e, id, self.mt).as_color().unwrap_or([1.0; 4]);
+        let mut c32 = color32(c);
+        let r = egui::color_picker::color_edit_button_srgba(vui, &mut c32, egui::color_picker::Alpha::Opaque);
+        self.auto(id, r.rect, id);
+        if r.changed() {
+            let [r8, g8, b8, _] = c32.to_srgba_unmultiplied();
+            self.set(id, json!(format!("#{r8:02x}{g8:02x}{b8:02x}")));
+        }
+    }
+    fn choice(&mut self, vui: &mut egui::Ui, id: &str, opts: &[&str], width: f32) {
+        let cur = match pv(self.e, id, self.mt) {
+            ParamValue::Choice(c) => c as usize,
+            _ => 0,
+        };
+        let mut sel = cur;
+        let r = egui::ComboBox::from_id_salt(("gfxc", self.clip.0, self.layer, id)).selected_text(opts.get(cur).copied().unwrap_or("")).width(width).show_ui(
+            vui,
+            |ui| {
+                for (i, o) in opts.iter().enumerate() {
+                    ui.selectable_value(&mut sel, i, *o);
+                }
+            },
+        );
+        self.auto(id, r.response.rect, id);
+        if sel != cur {
+            self.set(id, json!(sel));
+        }
+    }
+}
+
+fn section(ui: &mut egui::Ui, app: &mut FilmcraftApp, name: &str, t: &Tokens) -> bool {
+    ui.add_space(4.0);
+    let key = format!("gfx:{name}");
+    let open = !app.ui.collapsed_fx.contains(&key);
+    let (r, resp) = ui.allocate_exact_size(vec2(ui.available_width(), 30.0), Sense::click());
+    ui.painter().line_segment([r.left_top(), r.right_top()], Stroke::new(1.0, t.separator));
+    icons::paint(
+        ui.painter(),
+        Rect::from_center_size(pos2(r.min.x + 6.0, r.center().y), vec2(10.0, 10.0)),
+        if open { Icon::ChevronDown } else { Icon::ChevronRight },
+        t.text_dim,
+    );
+    ui.painter().text(pos2(r.min.x + 18.0, r.center().y), Align2::LEFT_CENTER, name, Tokens::semibold(13.0), t.text);
+    app.auto.add(&format!("graphics.section.{}", name.replace(' ', "")), r, name);
+    if resp.clicked() {
+        if open {
+            app.ui.collapsed_fx.push(key);
+        } else {
+            app.ui.collapsed_fx.retain(|k| *k != key);
+        }
+    }
+    open
+}
+
+/// A small code-drawn alignment glyph (original artwork: bars against an edge line).
+fn align_glyph(p: &egui::Painter, r: Rect, how: &str, c: Color32) {
+    let s = Stroke::new(1.2, c);
+    let (x0, x1, y0, y1) = (r.min.x + 2.0, r.max.x - 2.0, r.min.y + 2.0, r.max.y - 2.0);
+    let (cx, cy) = ((x0 + x1) / 2.0, (y0 + y1) / 2.0);
+    let bar = |a: Pos2, b: Pos2| p.rect_filled(Rect::from_two_pos(a, b), 0.0, c);
+    match how {
+        "left" => {
+            p.line_segment([pos2(x0, y0), pos2(x0, y1)], s);
+            bar(pos2(x0 + 2.0, y0 + 2.0), pos2(x1, y0 + 5.0));
+            bar(pos2(x0 + 2.0, y1 - 5.0), pos2(cx + 1.0, y1 - 2.0));
+        }
+        "right" => {
+            p.line_segment([pos2(x1, y0), pos2(x1, y1)], s);
+            bar(pos2(x0, y0 + 2.0), pos2(x1 - 2.0, y0 + 5.0));
+            bar(pos2(cx - 1.0, y1 - 5.0), pos2(x1 - 2.0, y1 - 2.0));
+        }
+        "hcenter" => {
+            p.line_segment([pos2(cx, y0), pos2(cx, y1)], s);
+            bar(pos2(x0 + 1.0, y0 + 2.0), pos2(x1 - 1.0, y0 + 5.0));
+            bar(pos2(cx - 3.0, y1 - 5.0), pos2(cx + 3.0, y1 - 2.0));
+        }
+        "top" => {
+            p.line_segment([pos2(x0, y0), pos2(x1, y0)], s);
+            bar(pos2(x0 + 2.0, y0 + 2.0), pos2(x0 + 5.0, y1));
+            bar(pos2(x1 - 5.0, y0 + 2.0), pos2(x1 - 2.0, cy + 1.0));
+        }
+        "bottom" => {
+            p.line_segment([pos2(x0, y1), pos2(x1, y1)], s);
+            bar(pos2(x0 + 2.0, y0), pos2(x0 + 5.0, y1 - 2.0));
+            bar(pos2(x1 - 5.0, cy - 1.0), pos2(x1 - 2.0, y1 - 2.0));
+        }
+        "vcenter" => {
+            p.line_segment([pos2(x0, cy), pos2(x1, cy)], s);
+            bar(pos2(x0 + 2.0, y0 + 1.0), pos2(x0 + 5.0, y1 - 1.0));
+            bar(pos2(x1 - 5.0, cy - 3.0), pos2(x1 - 2.0, cy + 3.0));
+        }
+        "dh" => {
+            for x in [x0 + 1.0, cx - 1.5, x1 - 4.0] {
+                bar(pos2(x, y0 + 3.0), pos2(x + 3.0, y1 - 3.0));
+            }
+        }
+        "dv" => {
+            for y in [y0 + 1.0, cy - 1.5, y1 - 4.0] {
+                bar(pos2(x0 + 3.0, y), pos2(x1 - 3.0, y + 3.0));
+            }
+        }
+        // paragraph alignment: four text lines
+        a @ ("pl" | "pc" | "pr" | "pj") => {
+            for (i, w) in [1.0f32, 0.6, 0.85, 0.5].iter().enumerate() {
+                let w = if a == "pj" && i < 3 { 1.0 } else { *w } * (x1 - x0);
+                let y = y0 + 1.0 + i as f32 * 3.2;
+                let xa = match a {
+                    "pc" => cx - w / 2.0,
+                    "pr" => x1 - w,
+                    _ => x0,
+                };
+                p.line_segment([pos2(xa, y), pos2(xa + w, y)], s);
+            }
+        }
+        _ => {}
+    }
+}
+
+fn glyph_button(ui: &mut egui::Ui, how: &str, tip: &str, on: bool, t: &Tokens) -> egui::Response {
+    let (r, resp) = ui.allocate_exact_size(vec2(24.0, 22.0), Sense::click());
+    if on {
+        ui.painter().rect_filled(r, 3.0, Color32::from_rgb(0x4b, 0x4b, 0x4b));
+    } else if resp.hovered() {
+        ui.painter().rect_filled(r, 3.0, t.hover);
+    }
+    align_glyph(ui.painter(), Rect::from_center_size(r.center(), vec2(16.0, 14.0)), how, if resp.hovered() || on { t.text } else { t.text_dim });
+    resp.on_hover_text(tip)
+}
+
+fn letter_button(ui: &mut egui::Ui, text: &str, tip: &str, on: bool, t: &Tokens, font: egui::FontId) -> egui::Response {
+    let (r, resp) = ui.allocate_exact_size(vec2(26.0, 22.0), Sense::click());
+    if on {
+        ui.painter().rect_filled(r, 3.0, Color32::from_rgb(0x4b, 0x4b, 0x4b));
+    } else if resp.hovered() {
+        ui.painter().rect_filled(r, 3.0, t.hover);
+    }
+    ui.painter().text(r.center(), Align2::CENTER_CENTER, text, font, if on || resp.hovered() { t.text } else { t.text_dim });
+    resp.on_hover_text(tip)
+}
+
+/// Whether the Properties panel should show the graphic editor.
+pub fn graphic_selected(app: &FilmcraftApp) -> bool {
+    selected_graphic(app).is_some()
+}
+
+/// The graphic editor (Properties panel / Essential Graphics ▸ Edit).
+pub fn properties(app: &mut FilmcraftApp, ui: &mut egui::Ui, rect: Rect) {
+    let t = app.tokens;
+    let Some((clip, it)) = selected_graphic(app) else {
+        crate::dock::placeholder(ui, rect, &t, "Select a graphic clip, or use the Type tool (T) on the Program monitor");
+        let br = Rect::from_center_size(rect.center() + vec2(0.0, 30.0), vec2(150.0, 26.0));
+        let resp = ui.put(br, egui::Button::new("Create new graphic"));
+        app.auto.add("graphics.createNew", br, "Create new graphic");
+        if resp.clicked()
+            && let Err(e) = app.session.execute("graphics.newText", json!({"text": "New Text"}))
+        {
+            app.ui.status = e.to_string();
+        }
+        return;
+    };
+    let ph = app.session.playhead();
+    let mt = it.source_time_at(ph.clamp(it.start, it.end() - Tick(1)));
+    let idx = layer_indices(&it.effects);
+    let sel = app.session.state.graphic_layers.first().copied().filter(|l| *l < idx.len());
+    let mut actions: Vec<(String, Value)> = Vec::new();
+    let mut autos: Vec<(String, Rect, String)> = Vec::new();
+    let mut bui = ui.new_child(egui::UiBuilder::new().max_rect(rect.shrink2(vec2(12.0, 6.0))).id_salt("gfx-props"));
+    bui.set_clip_rect(rect);
+    egui::ScrollArea::vertical().id_salt("gfx-props-scroll").auto_shrink([false, false]).show(&mut bui, |ui| {
+        // header
+        let (hr, _) = ui.allocate_exact_size(vec2(ui.available_width(), 30.0), Sense::hover());
+        let lc = it.label.rgb();
+        ui.painter().rect_filled(Rect::from_center_size(pos2(hr.min.x + 8.0, hr.center().y), vec2(12.0, 12.0)), 2.0, Color32::from_rgb(lc[0], lc[1], lc[2]));
+        ui.painter().text(pos2(hr.min.x + 22.0, hr.center().y), Align2::LEFT_CENTER, &it.name, Tokens::semibold(12.5), t.text);
+        // ---- layers (front first)
+        if section(ui, app, "Layers", &t) {
+            ui.horizontal(|ui| {
+                ui.add_space(14.0);
+                for (label, tip, cmd, p) in [
+                    ("T", "New Text Layer", "graphics.newText", json!({"clip": clip.0, "text": "New Text"})),
+                    ("", "New Rectangle", "graphics.newShape", json!({"clip": clip.0, "shape": "rectangle"})),
+                    ("", "New Ellipse", "graphics.newShape", json!({"clip": clip.0, "shape": "ellipse", "size": [200, 200]})),
+                ] {
+                    let r = letter_button(ui, label, tip, false, &t, Tokens::semibold(13.0));
+                    if label.is_empty() {
+                        let ir = Rect::from_center_size(r.rect.center(), vec2(14.0, 14.0));
+                        icons::paint(ui.painter(), ir, if tip == "New Rectangle" { Icon::Rectangle } else { Icon::Ellipse }, t.text_dim);
+                    }
+                    autos.push((format!("graphics.{}", tip.replace(' ', "")), r.rect, tip.into()));
+                    if r.clicked() {
+                        actions.push((cmd.into(), p));
+                    }
+                }
+                ui.add_space(8.0);
+                if let Some(l) = sel {
+                    for (label, tip, to) in [("↑", "Bring Forward", "forward"), ("↓", "Send Backward", "backward")] {
+                        let r = letter_button(ui, label, tip, false, &t, Tokens::ui(13.0));
+                        autos.push((format!("graphics.arrange.{to}"), r.rect, tip.into()));
+                        if r.clicked() {
+                            actions.push(("graphics.arrangeLayer".into(), json!({"clip": clip.0, "layer": l, "to": to})));
+                        }
+                    }
+                    let (dr, dresp) = ui.allocate_exact_size(vec2(24.0, 22.0), Sense::click());
+                    icons::paint(ui.painter(), dr.shrink(4.0), Icon::Trash, if dresp.hovered() { t.text } else { t.text_dim });
+                    autos.push(("graphics.deleteLayer".into(), dr, "Delete Layer".into()));
+                    if dresp.on_hover_text("Delete Layer").clicked() {
+                        actions.push(("graphics.deleteLayer".into(), json!({"clip": clip.0, "layer": l})));
+                    }
+                }
+            });
+            for (li, &ei) in idx.iter().enumerate().rev() {
+                let e = &it.effects[ei];
+                let (r, resp) = ui.allocate_exact_size(vec2(ui.available_width(), 26.0), Sense::click());
+                let on = sel == Some(li);
+                if on {
+                    ui.painter().rect_filled(r, 2.0, Color32::from_rgb(0x2e, 0x3d, 0x55));
+                } else if resp.hovered() {
+                    ui.painter().rect_filled(r, 2.0, t.hover);
+                }
+                let kind = if e.effect == graphic::TEXT_LAYER { "T" } else { "◆" };
+                ui.painter().text(pos2(r.min.x + 22.0, r.center().y), Align2::CENTER_CENTER, kind, Tokens::semibold(12.0), t.text_dim);
+                ui.painter().text(pos2(r.min.x + 38.0, r.center().y), Align2::LEFT_CENTER, layer_display_name(e, li), Tokens::ui(12.0), t.text);
+                // visibility
+                let er = Rect::from_center_size(pos2(r.max.x - 14.0, r.center().y), vec2(16.0, 16.0));
+                let eresp = ui.interact(er, egui::Id::new(("gfx-eye", clip.0, li)), Sense::click());
+                icons::paint(ui.painter(), er.shrink(2.0), if e.enabled { Icon::Eye } else { Icon::EyeOff }, t.text_dim);
+                autos.push((format!("graphics.layers.{li}.visible"), er, "Toggle visibility".into()));
+                autos.push((format!("graphics.layers.{li}"), r, layer_display_name(e, li)));
+                if eresp.clicked() {
+                    actions.push(("graphics.set".into(), json!({"clip": clip.0, "layer": li, "props": {"enabled": !e.enabled}})));
+                } else if resp.clicked() {
+                    actions.push(("graphics.selectLayer".into(), json!({"clip": clip.0, "layers": [li]})));
+                }
+            }
+        }
+        let Some(l) = sel else {
+            ui.add_space(12.0);
+            ui.label(egui::RichText::new("Select a layer to edit its properties.").color(t.text_faint));
+            return;
+        };
+        let e = &it.effects[idx[l]];
+        let mut cx = Ctx { clip, layer: l, e, mt, t, actions: Vec::new(), autos: Vec::new() };
+        // ---- align and transform
+        if section(ui, app, "Align and Transform", &t) {
+            ui.horizontal(|ui| {
+                ui.add_space(14.0);
+                for (how, tip) in [
+                    ("left", "Align Left"),
+                    ("hcenter", "Align Center Horizontally"),
+                    ("right", "Align Right"),
+                    ("top", "Align Top"),
+                    ("vcenter", "Align Center Vertically"),
+                    ("bottom", "Align Bottom"),
+                ] {
+                    let r = glyph_button(ui, how, tip, false, &t);
+                    cx.autos.push((format!("graphics.align.{how}"), r.rect, tip.into()));
+                    if r.clicked() {
+                        cx.actions.push(("graphics.align".into(), json!({"clip": clip.0, "align": how})));
+                    }
+                }
+                ui.add_space(6.0);
+                for (how, axis, tip) in [("dh", "horizontal", "Distribute Horizontally"), ("dv", "vertical", "Distribute Vertically")] {
+                    let r = glyph_button(ui, how, tip, false, &t);
+                    cx.autos.push((format!("graphics.distribute.{axis}"), r.rect, tip.into()));
+                    if r.clicked() {
+                        cx.actions.push(("graphics.distribute".into(), json!({"clip": clip.0, "axis": axis, "layers": (0..idx.len()).collect::<Vec<_>>()})));
+                    }
+                }
+            });
+            cx.point(ui, "Position", "position");
+            cx.point(ui, "Anchor point", "anchor");
+            cx.number(ui, "Scale", "scale", 0.5, (0.0, 100_000.0), 0, " %");
+            cx.number(ui, "Rotation", "rotation", 0.5, (-36_000.0, 36_000.0), 1, " °");
+            cx.number(ui, "Opacity", "opacity", 0.5, (0.0, 100.0), 0, " %");
+        }
+        // ---- text
+        if e.effect == graphic::TEXT_LAYER && section(ui, app, "Text", &t) {
+            // source text (multi-line), committed as it is typed
+            let mut s = match pv(e, "text", mt) {
+                ParamValue::Text(s) => s,
+                _ => String::new(),
+            };
+            let before = s.clone();
+            ui.horizontal(|ui| {
+                ui.add_space(14.0);
+                let r = ui.add(egui::TextEdit::multiline(&mut s).desired_rows(2).desired_width(ui.available_width() - 8.0).font(Tokens::ui(12.0)));
+                cx.autos.push(("graphics.sourceText".into(), r.rect, "Source Text".into()));
+            });
+            if s != before {
+                cx.actions.push(("graphics.setText".into(), json!({"clip": clip.0, "layer": l, "text": s, "merge": true})));
+            }
+            let family = match pv(e, "font", mt) {
+                ParamValue::Text(f) => f,
+                _ => String::new(),
+            };
+            let style = match pv(e, "font_style", mt) {
+                ParamValue::Text(f) => f,
+                _ => String::new(),
+            };
+            let fams = filmcraft_text::families();
+            let (_, mut vui) = cx.row(ui, "Font");
+            let r = egui::ComboBox::from_id_salt(("gfx-font", clip.0, l)).selected_text(&family).width(170.0).height(400.0).show_ui(&mut vui, |ui| {
+                if !filmcraft_text::fonts::system_scanned() {
+                    filmcraft_text::fonts::scan_system();
+                }
+                for (f, _) in &fams {
+                    if ui.selectable_label(*f == family, f).clicked() {
+                        cx.set("font", json!(f));
+                    }
+                }
+            });
+            cx.auto("font", r.response.rect, "Font");
+            let styles: Vec<String> = fams.iter().find(|(f, _)| f.eq_ignore_ascii_case(&family)).map(|(_, s)| s.clone()).unwrap_or_default();
+            let (_, mut vui) = cx.row(ui, "Font Style");
+            let r = egui::ComboBox::from_id_salt(("gfx-style", clip.0, l)).selected_text(&style).width(170.0).show_ui(&mut vui, |ui| {
+                for st in styles.iter().map(String::as_str).chain(["Bold", "Italic", "Bold Italic"]).filter({
+                    let mut seen = Vec::new();
+                    move |x: &&str| {
+                        if seen.contains(x) {
+                            false
+                        } else {
+                            seen.push(*x);
+                            true
+                        }
+                    }
+                }) {
+                    if ui.selectable_label(st == style, st).clicked() {
+                        cx.set("font_style", json!(st));
+                    }
+                }
+            });
+            cx.auto("font_style", r.response.rect, "Font Style");
+            cx.number(ui, "Font Size", "size", 0.5, (1.0, 2000.0), 0, "");
+            let align = match pv(e, "align", mt) {
+                ParamValue::Choice(c) => c,
+                _ => 0,
+            };
+            let (_, mut vui) = cx.row(ui, "Alignment");
+            for (i, (how, tip)) in [("pl", "Left Align Text"), ("pc", "Center Align Text"), ("pr", "Right Align Text"), ("pj", "Justify")].iter().enumerate() {
+                let r = glyph_button(&mut vui, how, tip, align == i as u32, &t);
+                cx.auto(&format!("align.{i}"), r.rect, tip);
+                if r.clicked() {
+                    cx.set("align", json!(i));
+                }
+            }
+            cx.number(ui, "Tracking", "tracking", 1.0, (-1000.0, 10_000.0), 0, "");
+            cx.number(ui, "Leading", "leading", 0.5, (-5000.0, 5000.0), 0, "");
+            cx.number(ui, "Baseline Shift", "baseline_shift", 0.5, (-5000.0, 5000.0), 0, "");
+            cx.number(ui, "Text Box Width", "box_width", 2.0, (0.0, 100_000.0), 0, "");
+            let (_, mut vui) = cx.row(ui, "Style");
+            let flag = |id: &str| pv(e, id, mt).as_bool().unwrap_or(false);
+            let caps = match pv(e, "caps", mt) {
+                ParamValue::Choice(c) => c,
+                _ => 0,
+            };
+            for (id, label, tip, on, font) in [
+                ("faux_bold", "T", "Faux Bold", flag("faux_bold"), Tokens::semibold(14.0)),
+                ("faux_italic", "T", "Faux Italic", flag("faux_italic"), egui::FontId::new(14.0, egui::FontFamily::Proportional)),
+                ("all_caps", "TT", "All Caps", caps == 1, Tokens::ui(12.0)),
+                ("small_caps", "Tt", "Small Caps", caps == 2, Tokens::ui(12.0)),
+                ("underline", "U", "Underline", flag("underline"), Tokens::ui(13.0)),
+            ] {
+                let r = letter_button(&mut vui, label, tip, on, &t, font);
+                if id == "faux_italic" {
+                    // slanted stroke to read as italic
+                    let c = r.rect.center();
+                    vui.painter().line_segment([c + vec2(-5.0, 6.0), c + vec2(5.0, -6.0)], Stroke::new(0.8, t.text_faint));
+                }
+                cx.auto(id, r.rect, tip);
+                if r.clicked() {
+                    match id {
+                        "all_caps" => cx.set("caps", json!(if caps == 1 { 0 } else { 1 })),
+                        "small_caps" => cx.set("caps", json!(if caps == 2 { 0 } else { 2 })),
+                        _ => cx.set(id, json!(!on)),
+                    }
+                }
+            }
+            let (_, mut vui) = cx.row(ui, "OpenType");
+            cx.check(&mut vui, "kerning", "Kerning");
+            cx.check(&mut vui, "ligatures", "Ligatures");
+        }
+        if e.effect == graphic::SHAPE_LAYER && section(ui, app, "Shape", &t) {
+            let (_, mut vui) = cx.row(ui, "Shape");
+            cx.choice(&mut vui, "shape", graphic::SHAPE_OPTS, 120.0);
+            cx.point(ui, "Size", "size");
+            cx.number(ui, "Corner Radius", "corner_radius", 0.5, (0.0, 10_000.0), 0, "");
+            cx.number(ui, "Polygon Sides", "sides", 0.05, (3.0, 64.0), 0, "");
+        }
+        // ---- appearance
+        if section(ui, app, "Appearance", &t) {
+            let (_, mut vui) = cx.row(ui, "Fill");
+            cx.check(&mut vui, "fill", "");
+            cx.color(&mut vui, "fill_color");
+            for (on, col, w, kind, label) in
+                [("stroke", "stroke_color", "stroke_width", "stroke_type", "Stroke"), ("stroke2", "stroke2_color", "stroke2_width", "stroke2_type", "Stroke 2")]
+            {
+                let (_, mut vui) = cx.row(ui, label);
+                cx.check(&mut vui, on, "");
+                cx.color(&mut vui, col);
+                vui.add_space(6.0);
+                cx.number_in(&mut vui, w, 0.2, (0.0, 1000.0), 1, "");
+                vui.add_space(6.0);
+                cx.choice(&mut vui, kind, graphic::STROKE_OPTS, 70.0);
+            }
+            let (_, mut vui) = cx.row(ui, "Background");
+            let bg = cx.check(&mut vui, "background", "");
+            cx.color(&mut vui, "background_color");
+            if bg {
+                cx.number(ui, "   Opacity", "background_opacity", 0.5, (0.0, 100.0), 0, " %");
+                cx.number(ui, "   Size", "background_size", 0.5, (0.0, 1000.0), 0, "");
+                cx.number(ui, "   Corner Radius", "background_radius", 0.5, (0.0, 1000.0), 0, "");
+            }
+            let (_, mut vui) = cx.row(ui, "Shadow");
+            let sh = cx.check(&mut vui, "shadow", "");
+            cx.color(&mut vui, "shadow_color");
+            if sh {
+                cx.number(ui, "   Opacity", "shadow_opacity", 0.5, (0.0, 100.0), 0, " %");
+                cx.number(ui, "   Angle", "shadow_angle", 0.5, (-36_000.0, 36_000.0), 0, " °");
+                cx.number(ui, "   Distance", "shadow_distance", 0.5, (0.0, 1000.0), 0, "");
+                cx.number(ui, "   Size", "shadow_size", 0.5, (0.0, 1000.0), 0, "");
+                cx.number(ui, "   Blur", "shadow_blur", 0.5, (0.0, 1000.0), 0, "");
+            }
+        }
+        actions.append(&mut cx.actions);
+        autos.append(&mut cx.autos);
+    });
+    for (id, r, label) in autos {
+        app.auto.add(&id, r, &label);
+    }
+    for (cmd, p) in actions {
+        if let Err(e) = app.session.execute(&cmd, p) {
+            app.ui.status = e.to_string();
+        }
+    }
+}
diff --git a/crates/ui-egui/src/panels/meters.rs b/crates/ui-egui/src/panels/meters.rs
index cc3db6d3c..00cd45506 100644
--- a/crates/ui-egui/src/panels/meters.rs
+++ b/crates/ui-egui/src/panels/meters.rs
@@ -1,29 +1,14 @@
-//! Audio Meters (stereo peak meters with dB scale and peak hold) and a basic Audio Track Mixer.
-//! Levels are measured from the mixed sequence audio around the playhead.
+//! Audio Meters: stereo peak meters of the Mix (dB scale, peak hold) fed by the playing mixer
+//! graph, plus the BS.1770 loudness readout.
 
-use egui::{Align2, Rect, Sense, pos2, vec2};
-use serde_json::json;
+use egui::{Align2, Rect, pos2, vec2};
 
 use crate::FilmcraftApp;
 use crate::theme::Tokens;
 
-fn levels(app: &FilmcraftApp) -> [f32; 2] {
-    let Some(seq) = app.session.active_sequence() else { return [-90.0; 2] };
-    if !app.playback.playing {
-        return [-90.0; 2];
-    }
-    let sr = seq.settings.sample_rate as i64;
-    let s0 = app.session.playhead().to_units_floor(sr);
-    let provider = app.session.media.provider(app.session.project.clone(), app.session.services.clone());
-    let Some(seq_id) = app.session.state.active_sequence else { return [-90.0; 2] };
-    let buf = app.session.previews.mix(&app.session.project, seq_id, s0, 1024, &provider);
-    let p = buf.peaks();
-    [20.0 * p.first().copied().unwrap_or(0.0).max(1e-6).log10(), 20.0 * p.get(1).copied().unwrap_or(0.0).max(1e-6).log10()]
-}
-
 /// Feed the loudness meter with exactly the programme audio played since the last frame
 /// (consecutive, non-overlapping blocks, so gating and integration are correct). Seeks reset it.
-fn feed_loudness(app: &mut FilmcraftApp) {
+pub(crate) fn feed_loudness(app: &mut FilmcraftApp) {
     if !app.playback.playing {
         return;
     }
@@ -62,18 +47,8 @@ fn lufs_text(v: f64) -> String {
 
 pub fn show(app: &mut FilmcraftApp, ui: &mut egui::Ui, rect: Rect) {
     let t = app.tokens;
-    feed_loudness(app);
-    let lv = levels(app);
-    let id = egui::Id::new("meter-state");
-    let now = ui.input(|i| i.time);
-    let mut st: [f32; 4] = ui.data(|d| d.get_temp(id)).unwrap_or([-90.0; 4]);
-    for c in 0..2 {
-        // fast attack, 20 dB/s release; peak hold decays after 1.5 s
-        st[c] = if lv[c] > st[c] { lv[c] } else { (st[c] - 20.0 * ui.input(|i| i.stable_dt)).max(-90.0) };
-        st[c + 2] = if lv[c] > st[c + 2] { lv[c] } else { st[c + 2] - 6.0 * ui.input(|i| i.stable_dt) };
-    }
-    ui.data_mut(|d| d.insert_temp(id, st));
-    let _ = now;
+    // levels of the Mix as it plays (fast attack, 20 dB/s release, peak hold)
+    let st = super::mixer::poll_meters(app, ui).get(&filmcraft_render::mixer::MASTER.0).copied().unwrap_or([-90.0; 4]);
     // Premiere: black meter area, scale 0 … −57 dB in 3 dB steps on the right, "dB" at the foot.
     // Loudness readout (BS.1770 / EBU R128) under the bars.
     let lufs_h = if rect.height() > 260.0 { 64.0 } else { 0.0 };
@@ -128,46 +103,3 @@ pub fn show(app: &mut FilmcraftApp, ui: &mut egui::Ui, rect: Rect) {
     }
     app.auto.add("audioMeters", area, "Audio Meters");
 }
-
-pub fn track_mixer(app: &mut FilmcraftApp, ui: &mut egui::Ui, rect: Rect) {
-    let t = app.tokens;
-    let Some(seq) = app.session.active_sequence().cloned() else {
-        crate::dock::placeholder(ui, rect, &t, "(no sequence)");
-        return;
-    };
-    let strip_w = 86.0;
-    let mut actions = Vec::new();
-    for (i, tr) in seq.audio_tracks.iter().enumerate().chain(std::iter::empty()) {
-        let x = rect.min.x + 8.0 + i as f32 * (strip_w + 4.0);
-        if x + strip_w > rect.max.x {
-            break;
-        }
-        let strip = Rect::from_min_max(pos2(x, rect.min.y + 6.0), pos2(x + strip_w, rect.max.y - 6.0));
-        ui.painter().rect_filled(strip, 4.0, t.tl_header_bg);
-        ui.painter().text(pos2(strip.center().x, strip.min.y + 12.0), Align2::CENTER_CENTER, format!("A{}", i + 1), Tokens::semibold(11.0), t.text);
-        // pan knob as hot number
-        let mut pan_ui = ui.new_child(egui::UiBuilder::new().max_rect(Rect::from_min_size(pos2(strip.min.x + 20.0, strip.min.y + 26.0), vec2(60.0, 18.0))));
-        let (_, np) = crate::widgets::hot_number(&mut pan_ui, egui::Id::new(("pan", tr.id.0)), tr.pan, 1.0, (-100.0, 100.0), 0, "", &t);
-        if let Some(np) = np {
-            actions.push(json!({"track": tr.id.0, "pan": np}));
-        }
-        // fader
-        let fader = Rect::from_min_max(pos2(strip.center().x - 3.0, strip.min.y + 54.0), pos2(strip.center().x + 3.0, strip.max.y - 40.0));
-        ui.painter().rect_filled(fader, 3.0, t.field_bg);
-        let norm = ((tr.volume_db + 60.0) / 66.0).clamp(0.0, 1.0) as f32;
-        let ky = fader.max.y - norm * fader.height();
-        let knob = Rect::from_center_size(pos2(fader.center().x, ky), vec2(26.0, 10.0));
-        let resp = ui.interact(knob.expand(4.0), egui::Id::new(("fader", tr.id.0)), Sense::drag());
-        ui.painter().rect_filled(knob, 2.0, if resp.dragged() { t.accent } else { egui::Color32::from_rgb(160, 160, 160) });
-        if resp.dragged() {
-            let nn = (norm - resp.drag_delta().y / fader.height()).clamp(0.0, 1.0);
-            actions.push(json!({"track": tr.id.0, "volumeDb": nn as f64 * 66.0 - 60.0}));
-        }
-        app.auto.add(&format!("mixer.A{}.fader", i + 1), knob, "volume");
-        ui.painter().text(pos2(strip.center().x, strip.max.y - 26.0), Align2::CENTER_CENTER, format!("{:.1}", tr.volume_db), Tokens::ui(11.0), t.hot_text);
-        ui.painter().text(pos2(strip.center().x, strip.max.y - 10.0), Align2::CENTER_CENTER, &tr.name, Tokens::ui(10.0), t.text_dim);
-    }
-    for a in actions {
-        let _ = app.session.execute("timeline.setTrack", a);
-    }
-}
diff --git a/crates/ui-egui/src/panels/mixer.rs b/crates/ui-egui/src/panels/mixer.rs
new file mode 100644
index 000000000..1a1cfbf39
--- /dev/null
+++ b/crates/ui-egui/src/panels/mixer.rs
@@ -0,0 +1,802 @@
+//! Audio Track Mixer and Audio Clip Mixer.
+//!
+//! Track Mixer strips (audio tracks, submixes, Mix): effect and send slots (behind the ▸
+//! disclosure), input mapping, output assignment, pan knob, automation mode, M / S / R, fader with
+//! a dB scale, stereo meters fed by the playing mix, the fader value and the strip name. Every
+//! control goes through `mixer.*` commands: fader and knob drags are `mixer.touch` while held and
+//! `mixer.release` when let go, so they are heard live during playback and recorded as automation
+//! in Latch / Touch / Write mode.
+//!
+//! Automation ids: `mixer.<A1|S1|Mix>.<fader|value|pan|panValue|mode|mute|solo|record|output|input|
+//! fx.<slot>|send.<slot>|meter|name>`, popup entries below them (`mixer.A1.mode.Touch`…), the
+//! effects disclosure `mixer.showEffects`, and the footer transport `mixer.transport.<command>`.
+//! The Clip Mixer uses `clipMixer.A1.<fader|value|pan|mute|solo|keyframe>`.
+
+use std::collections::HashMap;
+
+use egui::{Align2, Color32, Rect, Sense, Stroke, StrokeKind, pos2, vec2};
+use filmcraft_engine::mixer::strip_label;
+use filmcraft_project::mixer::{FADER_MAX_DB, FADER_MIN_DB, LANE_MUTE, LANE_PAN, LANE_VOLUME, MASTER_STRIP};
+use filmcraft_project::{AutomationMode, InputMap, Sequence, Track, TrackId};
+use filmcraft_time::{TimeDisplay, format_time};
+use serde_json::{Value, json};
+
+use crate::FilmcraftApp;
+use crate::icons::{self, Icon};
+use crate::theme::Tokens;
+
+// ------------------------------------------------------------------------------------- fader law
+
+/// Fader taper: (dB, position 0 … 1). Our own law: most of the travel around unity gain.
+const TAPER: [(f64, f32); 10] =
+    [(-96.0, 0.0), (-60.0, 0.05), (-40.0, 0.14), (-30.0, 0.24), (-20.0, 0.38), (-12.0, 0.52), (-6.0, 0.64), (0.0, 0.76), (6.0, 0.88), (15.0, 1.0)];
+/// Labels on the fader scale.
+const SCALE: [f64; 10] = [15.0, 6.0, 0.0, -6.0, -12.0, -20.0, -30.0, -40.0, -60.0, -96.0];
+const STRIP_W: f32 = 98.0;
+const SLOT_H: f32 = 15.0;
+const RED: Color32 = Color32::from_rgb(0xd8, 0x50, 0x3f);
+const MUTE_ON: Color32 = Color32::from_rgb(0x2d, 0x9d, 0x78);
+const SOLO_ON: Color32 = Color32::from_rgb(0xf0, 0xf0, 0x4f);
+
+/// Fader position (0 bottom … 1 top) of a dB value.
+pub fn db_to_pos(db: f64) -> f32 {
+    if db <= TAPER[0].0 {
+        return 0.0;
+    }
+    for w in TAPER.windows(2) {
+        let ((d0, p0), (d1, p1)) = (w[0], w[1]);
+        if db <= d1 {
+            return p0 + (p1 - p0) * ((db - d0) / (d1 - d0)) as f32;
+        }
+    }
+    1.0
+}
+
+/// dB value of a fader position.
+pub fn pos_to_db(p: f32) -> f64 {
+    let p = p.clamp(0.0, 1.0);
+    for w in TAPER.windows(2) {
+        let ((d0, p0), (d1, p1)) = (w[0], w[1]);
+        if p <= p1 {
+            let db = d0 + (d1 - d0) * ((p - p0) / (p1 - p0)) as f64;
+            return if db <= FADER_MIN_DB + 0.5 { FADER_MIN_DB } else { db };
+        }
+    }
+    FADER_MAX_DB
+}
+
+fn db_text(db: f64) -> String {
+    if db <= FADER_MIN_DB { "-∞".into() } else { format!("{db:.1}") }
+}
+
+// ------------------------------------------------------------------------------------- meters
+
+/// Per-strip meter state, `strip id → [level L, level R, peak L, peak R]` (dBFS), fed by the playing
+/// mix ([`filmcraft_render::mixer::LiveMix`]) with fast attack and a 20 dB/s fall.
+pub fn poll_meters(app: &mut FilmcraftApp, ui: &egui::Ui) -> HashMap<u64, [f32; 4]> {
+    let id = egui::Id::new("mixer-meters");
+    let frame = ui.ctx().cumulative_frame_nr();
+    let (last, mut st): (u64, HashMap<u64, [f32; 4]>) = ui.data(|d| d.get_temp(id)).unwrap_or_default();
+    if last == frame && frame != 0 {
+        return st;
+    }
+    // without an audio device, the loudness feed is what mixes the programme (and posts meters)
+    super::meters::feed_loudness(app);
+    let fresh = app.session.previews.live.take_meters();
+    let dt = ui.input(|i| i.stable_dt).min(0.1);
+    for v in st.values_mut() {
+        v[0] = (v[0] - 20.0 * dt).max(-90.0);
+        v[1] = (v[1] - 20.0 * dt).max(-90.0);
+        v[2] = (v[2] - 6.0 * dt).max(-90.0);
+        v[3] = (v[3] - 6.0 * dt).max(-90.0);
+    }
+    if app.playback.playing {
+        for (k, p) in fresh {
+            let e = st.entry(k.0).or_insert([-90.0; 4]);
+            for c in 0..2 {
+                let l = 20.0 * p[c].max(1e-6).log10();
+                e[c] = e[c].max(l);
+                e[c + 2] = e[c + 2].max(l);
+            }
+        }
+        ui.ctx().request_repaint();
+    }
+    ui.data_mut(|d| d.insert_temp(id, (frame, st.clone())));
+    st
+}
+
+fn draw_meters(ui: &egui::Ui, r: Rect, m: [f32; 4], t: &Tokens) {
+    let p = ui.painter();
+    p.rect_filled(r, 0.0, Color32::BLACK);
+    let w = (r.width() - 2.0) / 2.0;
+    for c in 0..2 {
+        let br = Rect::from_min_size(pos2(r.min.x + c as f32 * (w + 2.0), r.min.y + 6.0), vec2(w, r.height() - 6.0));
+        crate::widgets::meter_bar(p, br, m[c], m[c + 2], t);
+        // clip light
+        let lr = Rect::from_min_size(pos2(br.min.x, r.min.y), vec2(w, 4.0));
+        p.rect_filled(lr, 0.0, if m[c + 2] >= -0.1 { RED } else { Color32::from_gray(0x30) });
+    }
+}
+
+// ------------------------------------------------------------------------------------- helpers
+
+struct Ctx<'a> {
+    t: Tokens,
+    seq: &'a Sequence,
+    now: filmcraft_time::Tick,
+    recording: bool,
+    acts: Vec<(String, Value)>,
+}
+
+impl Ctx<'_> {
+    fn cmd(&mut self, id: &str, p: Value) {
+        self.acts.push((id.to_string(), p));
+    }
+}
+
+/// The value a control shows: a held override, else the automation (or static value) at the playhead.
+fn shown(app: &FilmcraftApp, tr: &Track, lane: &str, now: filmcraft_time::Tick) -> f64 {
+    app.session.previews.live.get(tr.id, lane).map(|o| o.value).unwrap_or_else(|| tr.lane_value(lane, now))
+}
+
+fn small_text(ui: &egui::Ui, pos: egui::Pos2, align: Align2, s: &str, size: f32, c: Color32) {
+    ui.painter().text(pos, align, s, Tokens::ui(size), c);
+}
+
+fn slot_box(ui: &mut egui::Ui, r: Rect, text: &str, filled: bool, dim: bool, t: &Tokens, id: egui::Id) -> egui::Response {
+    let resp = ui.interact(r, id, Sense::click());
+    ui.painter().rect_filled(r, 2.0, if resp.hovered() { t.hover } else { t.field_bg });
+    ui.painter().rect_stroke(r, 2.0, Stroke::new(1.0, t.field_border), StrokeKind::Inside);
+    let col = if !filled || dim { t.text_faint } else { t.text };
+    let galley = ui.painter().layout_no_wrap(text.to_string(), Tokens::ui(10.0), col);
+    let clip = ui.painter().with_clip_rect(r.shrink(1.0).intersect(ui.clip_rect()));
+    clip.galley(pos2(r.min.x + 4.0, r.center().y - galley.size().y / 2.0), galley, col);
+    icons::paint(ui.painter(), Rect::from_center_size(pos2(r.max.x - 7.0, r.center().y), vec2(7.0, 7.0)), Icon::ChevronDown, t.text_dim);
+    resp
+}
+
+/// The DSP-backed audio effects that can go in an insert slot.
+fn insert_effects() -> Vec<&'static filmcraft_project::EffectDef> {
+    filmcraft_project::effect_defs()
+        .iter()
+        .filter(|d| d.kind == filmcraft_project::EffectKind::Audio && !d.intrinsic && filmcraft_render::audio_fx::supported(d.id))
+        .collect()
+}
+
+/// Submixes a strip may route to (all of them for tracks; only later ones for submixes).
+fn targets(seq: &Sequence, id: TrackId) -> Vec<&Track> {
+    let me = seq.submix_tracks.iter().position(|t| t.id == id);
+    seq.submix_tracks.iter().enumerate().filter(|(i, _)| me.is_none_or(|m| *i > m)).map(|(_, t)| t).collect()
+}
+
+// ------------------------------------------------------------------------------------- track mixer
+
+pub fn track_mixer(app: &mut FilmcraftApp, ui: &mut egui::Ui, rect: Rect) {
+    let t = app.tokens;
+    let Some(seq) = app.session.active_sequence().cloned() else {
+        crate::dock::placeholder(ui, rect, &t, "(no sequence)");
+        return;
+    };
+    let meters = poll_meters(app, ui);
+    let mut cx = Ctx { t, seq: &seq, now: app.session.playhead(), recording: app.session.mixrec.active(), acts: Vec::new() };
+    let footer = Rect::from_min_max(pos2(rect.min.x, rect.max.y - 34.0), rect.max);
+    let body = Rect::from_min_max(pos2(rect.min.x, rect.min.y + 2.0), pos2(rect.max.x, footer.min.y));
+    // effects / sends disclosure at the left edge
+    let arrow = Rect::from_min_size(pos2(body.min.x + 2.0, body.min.y + 4.0), vec2(14.0, 18.0));
+    let aresp = ui.interact(arrow, egui::Id::new("mixer-fx-toggle"), Sense::click()).on_hover_text("Show/Hide Effects and Sends");
+    icons::paint(ui.painter(), arrow.shrink(2.0), if app.ui.mixer_fx_open { Icon::ChevronDown } else { Icon::ChevronRight }, t.icon);
+    app.auto.add("mixer.showEffects", arrow, "Show/Hide Effects and Sends");
+    if aresp.clicked() {
+        app.ui.mixer_fx_open = !app.ui.mixer_fx_open;
+    }
+    let strips = seq.strip_ids();
+    let x0 = body.min.x + 18.0;
+    let total = strips.len() as f32 * (STRIP_W + 2.0);
+    let avail = body.max.x - x0 - 2.0;
+    let max_off = (total - avail).max(0.0);
+    let off_id = egui::Id::new("mixer-hscroll");
+    let mut off: f32 = ui.data(|d| d.get_temp(off_id)).unwrap_or(0.0);
+    if ui.rect_contains_pointer(body) {
+        let sd = ui.input(|i| i.smooth_scroll_delta);
+        off -= sd.x + if ui.input(|i| i.modifiers.shift) { sd.y } else { 0.0 };
+    }
+    off = off.clamp(0.0, max_off);
+    let sb_h = if max_off > 0.0 { 12.0 } else { 0.0 };
+    // strips never get shorter than their controls plus a usable fader: scroll vertically instead
+    let need = 4.0 + if app.ui.mixer_fx_open { 10.0 * SLOT_H + 10.0 } else { 0.0 } + 112.0 + 26.0 + 24.0 + 6.0 + 170.0 + 42.0;
+    let clip = Rect::from_min_max(pos2(x0, body.min.y), pos2(body.max.x - 8.0, body.max.y - sb_h));
+    let voff_id = egui::Id::new("mixer-vscroll");
+    let max_voff = (need - (clip.height() - 4.0)).max(0.0);
+    let mut voff: f32 = ui.data(|d| d.get_temp(voff_id)).unwrap_or(0.0);
+    if ui.rect_contains_pointer(body) && !ui.input(|i| i.modifiers.shift) {
+        voff -= ui.input(|i| i.smooth_scroll_delta.y);
+    }
+    voff = voff.clamp(0.0, max_voff);
+    if max_voff > 0.0 {
+        let bar = Rect::from_min_max(pos2(body.max.x - 7.0, clip.min.y + 2.0), pos2(body.max.x - 2.0, clip.max.y - 2.0));
+        ui.painter().rect_filled(bar, 3.0, t.field_bg);
+        let kh = (bar.height() * clip.height() / (need + 4.0)).max(20.0);
+        let ky = bar.min.y + (bar.height() - kh) * voff / max_voff;
+        let knob = Rect::from_min_size(pos2(bar.min.x, ky), vec2(bar.width(), kh));
+        let kr = ui.interact(knob, egui::Id::new("mixer-vscroll-knob"), Sense::drag());
+        ui.painter().rect_filled(knob, 3.0, if kr.dragged() { t.accent } else { Color32::from_gray(0x5a) });
+        if kr.dragged() {
+            voff = (voff + kr.drag_delta().y * (need + 4.0) / bar.height()).clamp(0.0, max_voff);
+        }
+        app.auto.add("mixer.vscroll", knob, "Scroll strips vertically");
+    }
+    ui.data_mut(|d| d.insert_temp(voff_id, voff));
+    if max_off > 0.0 {
+        let bar = Rect::from_min_max(pos2(x0, body.max.y - 10.0), pos2(body.max.x - 4.0, body.max.y - 2.0));
+        ui.painter().rect_filled(bar, 4.0, t.field_bg);
+        let kw = (bar.width() * avail / total).max(20.0);
+        let kx = bar.min.x + (bar.width() - kw) * off / max_off;
+        let knob = Rect::from_min_size(pos2(kx, bar.min.y), vec2(kw, bar.height()));
+        let kr = ui.interact(knob, egui::Id::new("mixer-hscroll-knob"), Sense::drag());
+        ui.painter().rect_filled(knob, 4.0, if kr.dragged() { t.accent } else { Color32::from_gray(0x5a) });
+        if kr.dragged() {
+            off = (off + kr.drag_delta().x * total / bar.width()).clamp(0.0, max_off);
+        }
+        app.auto.add("mixer.scroll", knob, "Scroll strips");
+    }
+    ui.data_mut(|d| d.insert_temp(off_id, off));
+    let mut cui = ui.new_child(egui::UiBuilder::new().max_rect(clip));
+    cui.set_clip_rect(clip.intersect(ui.clip_rect()));
+    for (i, id) in strips.iter().enumerate() {
+        let sx = x0 + i as f32 * (STRIP_W + 2.0) - off;
+        if sx + STRIP_W < clip.min.x || sx > clip.max.x {
+            continue;
+        }
+        let sr = Rect::from_min_size(pos2(sx, clip.min.y + 2.0 - voff), vec2(STRIP_W, (clip.height() - 4.0).max(need)));
+        let m = meters.get(&id.0).copied().unwrap_or([-90.0; 4]);
+        strip(app, &mut cui, &mut cx, *id, sr, m);
+    }
+    transport(app, ui, footer, &mut cx);
+    let acts = std::mem::take(&mut cx.acts);
+    run_actions(app, &ui.ctx().clone(), acts);
+}
+
+fn run_actions(app: &mut FilmcraftApp, ctx: &egui::Context, acts: Vec<(String, Value)>) {
+    for (id, p) in acts {
+        let r = if filmcraft_engine::find_command(&id).is_some() {
+            app.session.execute(&id, p).map(|_| ()).map_err(|e| e.to_string())
+        } else {
+            crate::menus::invoke(app, ctx, &id, p).map(|_| ())
+        };
+        if let Err(e) = r {
+            app.ui.status = e;
+        }
+    }
+}
+
+fn strip(app: &mut FilmcraftApp, ui: &mut egui::Ui, cx: &mut Ctx, id: TrackId, sr: Rect, meter: [f32; 4]) {
+    let t = cx.t;
+    let seq = cx.seq;
+    let Some(tr) = seq.strip(id).map(|c| c.into_owned()) else { return };
+    let label = strip_label(seq, id);
+    let ap = format!("mixer.{label}");
+    let is_master = id == MASTER_STRIP;
+    let sid = json!(id.0);
+    ui.painter().rect_filled(sr, 3.0, Color32::from_gray(0x24));
+    ui.painter().line_segment([pos2(sr.max.x + 1.0, sr.min.y), pos2(sr.max.x + 1.0, sr.max.y)], Stroke::new(1.0, t.separator));
+    let x = sr.min.x;
+    let w = sr.width();
+    let mut y = sr.min.y + 4.0;
+
+    // ---- effect and send slots
+    if app.ui.mixer_fx_open {
+        for k in 0..filmcraft_project::mixer::MAX_INSERTS {
+            let r = Rect::from_min_size(pos2(x + 4.0, y), vec2(w - 8.0, SLOT_H - 2.0));
+            let fx = tr.effects.get(k);
+            let text = match fx {
+                Some(e) => format!("{}{}", if e.post_fader { "▸ " } else { "" }, e.def().map(|d| d.name).unwrap_or(&e.effect)),
+                None => String::new(),
+            };
+            let resp = slot_box(ui, r, &text, fx.is_some(), fx.is_some_and(|e| !e.enabled), &t, egui::Id::new((&ap, "fx", k)));
+            app.auto.add(&format!("{ap}.fx.{k}"), r, &if text.is_empty() { format!("Effect slot {}", k + 1) } else { text.clone() });
+            let can_add = fx.is_none() && k == tr.effects.len();
+            egui::Popup::menu(&resp).show(|ui| {
+                ui.set_min_width(180.0);
+                match fx {
+                    Some(e) => {
+                        let on = e.enabled;
+                        let r1 = ui.selectable_label(!on, "Bypass");
+                        app.auto.add(&format!("{ap}.fx.{k}.bypass"), r1.rect, "Bypass");
+                        if r1.clicked() {
+                            cx.cmd("mixer.setInsert", json!({"strip": sid, "slot": k, "enabled": !on}));
+                        }
+                        let r2 = ui.selectable_label(e.post_fader, "Post-Fader");
+                        app.auto.add(&format!("{ap}.fx.{k}.postFader"), r2.rect, "Post-Fader");
+                        if r2.clicked() {
+                            cx.cmd("mixer.setInsert", json!({"strip": sid, "slot": k, "postFader": !e.post_fader}));
+                        }
+                        ui.separator();
+                        let r3 = ui.button("Remove Effect");
+                        app.auto.add(&format!("{ap}.fx.{k}.remove"), r3.rect, "Remove Effect");
+                        if r3.clicked() {
+                            cx.cmd("mixer.removeInsert", json!({"strip": sid, "slot": k}));
+                        }
+                    }
+                    None if can_add => {
+                        for d in insert_effects() {
+                            let r = ui.button(d.name);
+                            app.auto.add(&format!("{ap}.fx.{k}.{}", d.id), r.rect, d.name);
+                            if r.clicked() {
+                                cx.cmd("mixer.addInsert", json!({"strip": sid, "effect": d.id}));
+                            }
+                        }
+                    }
+                    None => {
+                        ui.label("Fill the slots above first");
+                    }
+                }
+            });
+            y += SLOT_H;
+        }
+        y += 4.0;
+        for k in 0..filmcraft_project::mixer::MAX_SENDS {
+            let r = Rect::from_min_size(pos2(x + 4.0, y), vec2(w - 8.0, SLOT_H - 2.0));
+            let snd = tr.mixer.sends.get(k);
+            let text = match snd {
+                Some(s) => format!("{}{} {}", if s.pre_fader { "pre " } else { "" }, strip_label(seq, s.target), db_text(s.level_db)),
+                None => String::new(),
+            };
+            if is_master {
+                y += SLOT_H;
+                continue;
+            }
+            let resp = slot_box(ui, r, &text, snd.is_some(), snd.is_some_and(|s| s.muted), &t, egui::Id::new((&ap, "send", k)));
+            app.auto.add(&format!("{ap}.send.{k}"), r, &if text.is_empty() { format!("Send slot {}", k + 1) } else { text.clone() });
+            let can_add = snd.is_none() && k == tr.mixer.sends.len();
+            let tg = targets(seq, id);
+            egui::Popup::menu(&resp).show(|ui| {
+                ui.set_min_width(180.0);
+                match snd {
+                    Some(s) => {
+                        let mut lvl = s.level_db;
+                        let sl = ui.add(egui::Slider::new(&mut lvl, FADER_MIN_DB..=FADER_MAX_DB).text("dB"));
+                        app.auto.add(&format!("{ap}.send.{k}.level"), sl.rect, "Send level");
+                        if sl.changed() {
+                            cx.cmd("mixer.setSend", json!({"strip": sid, "send": k, "levelDb": lvl}));
+                        }
+                        let r1 = ui.selectable_label(s.pre_fader, "Pre-Fader");
+                        app.auto.add(&format!("{ap}.send.{k}.preFader"), r1.rect, "Pre-Fader");
+                        if r1.clicked() {
+                            cx.cmd("mixer.setSend", json!({"strip": sid, "send": k, "preFader": !s.pre_fader}));
+                        }
+                        let r2 = ui.selectable_label(s.muted, "Mute Send");
+                        app.auto.add(&format!("{ap}.send.{k}.mute"), r2.rect, "Mute Send");
+                        if r2.clicked() {
+                            cx.cmd("mixer.setSend", json!({"strip": sid, "send": k, "muted": !s.muted}));
+                        }
+                        ui.separator();
+                        let r3 = ui.button("Remove Send");
+                        app.auto.add(&format!("{ap}.send.{k}.remove"), r3.rect, "Remove Send");
+                        if r3.clicked() {
+                            cx.cmd("mixer.removeSend", json!({"strip": sid, "send": k}));
+                        }
+                    }
+                    None if can_add => {
+                        for s in &tg {
+                            let lbl = format!("{} ({})", strip_label(seq, s.id), s.name);
+                            let r = ui.button(&lbl);
+                            app.auto.add(&format!("{ap}.send.{k}.{}", strip_label(seq, s.id)), r.rect, &lbl);
+                            if r.clicked() {
+                                cx.cmd("mixer.addSend", json!({"strip": sid, "target": s.id.0}));
+                            }
+                        }
+                        if seq.submix_tracks.iter().all(|s| s.id != id) {
+                            let r = ui.button("New Submix");
+                            app.auto.add(&format!("{ap}.send.{k}.newSubmix"), r.rect, "New Submix");
+                            if r.clicked() {
+                                let n = seq.submix_tracks.len();
+                                cx.cmd("mixer.addSubmix", json!({}));
+                                cx.cmd("mixer.addSend", json!({"strip": sid, "target": format!("S{}", n + 1)}));
+                            }
+                        }
+                    }
+                    None => {
+                        ui.label("Fill the slots above first");
+                    }
+                }
+            });
+            y += SLOT_H;
+        }
+        y += 6.0;
+    }
+
+    // ---- input / output
+    if !is_master {
+        let ir = Rect::from_min_size(pos2(x + 4.0, y), vec2(w - 8.0, 20.0));
+        let iresp = crate::widgets::dropdown_text(ui, ir, tr.mixer.input_map.label(), &t, egui::Id::new((&ap, "input")));
+        app.auto.add(&format!("{ap}.input"), ir, "Input channel mapping");
+        egui::Popup::menu(&iresp).show(|ui| {
+            for m in InputMap::ALL {
+                let r = ui.selectable_label(m == tr.mixer.input_map, m.label());
+                app.auto.add(&format!("{ap}.input.{}", m.label()), r.rect, m.label());
+                if r.clicked() {
+                    cx.cmd("mixer.setStrip", json!({"strip": sid, "inputMap": m.label()}));
+                }
+            }
+        });
+        y += 24.0;
+        let or = Rect::from_min_size(pos2(x + 4.0, y), vec2(w - 8.0, 20.0));
+        let out_label = tr.mixer.output.map(|o| seq.mix_track(o).map(|s| s.name.clone()).unwrap_or_else(|| "Mix".into())).unwrap_or_else(|| "Mix".into());
+        let oresp = crate::widgets::dropdown_text(ui, or, &out_label, &t, egui::Id::new((&ap, "output")));
+        app.auto.add(&format!("{ap}.output"), or, "Track output assignment");
+        let tg = targets(seq, id);
+        egui::Popup::menu(&oresp).show(|ui| {
+            let r = ui.selectable_label(tr.mixer.output.is_none(), "Mix");
+            app.auto.add(&format!("{ap}.output.Mix"), r.rect, "Mix");
+            if r.clicked() {
+                cx.cmd("mixer.setStrip", json!({"strip": sid, "output": "Mix"}));
+            }
+            for s in &tg {
+                let r = ui.selectable_label(tr.mixer.output == Some(s.id), &s.name);
+                app.auto.add(&format!("{ap}.output.{}", strip_label(seq, s.id)), r.rect, &s.name);
+                if r.clicked() {
+                    cx.cmd("mixer.setStrip", json!({"strip": sid, "output": s.id.0}));
+                }
+            }
+        });
+        y += 26.0;
+        // ---- pan knob
+        let pan = shown(app, &tr, LANE_PAN, cx.now);
+        let kc = pos2(sr.center().x, y + 20.0);
+        let kr = Rect::from_center_size(kc, vec2(38.0, 38.0));
+        let kresp = ui.interact(kr, egui::Id::new((&ap, "pan")), Sense::click_and_drag()).on_hover_text("Pan / balance (drag; double-click: centre)");
+        let ring = if kresp.hovered() || kresp.dragged() { t.tab_text_active } else { Color32::from_gray(0xb0) };
+        ui.painter().circle_stroke(kc, 16.0, Stroke::new(2.0, ring));
+        let ang = (pan / 100.0) as f32 * 135f32.to_radians();
+        ui.painter().line_segment([kc, kc + vec2(ang.sin(), -ang.cos()) * 14.0], Stroke::new(2.0, ring));
+        small_text(ui, pos2(kc.x - 22.0, kc.y + 17.0), Align2::CENTER_CENTER, "L", 11.0, t.hot_text);
+        small_text(ui, pos2(kc.x + 22.0, kc.y + 17.0), Align2::CENTER_CENTER, "R", 11.0, t.hot_text);
+        app.auto.add(&format!("{ap}.pan"), kr, "Pan");
+        if kresp.dragged() {
+            let d = kresp.drag_delta();
+            let np = (pan + (d.x - d.y) as f64).clamp(-100.0, 100.0);
+            if np != pan {
+                cx.cmd("mixer.touch", json!({"strip": sid, "lane": LANE_PAN, "value": np, "time": cx.now.0}));
+            }
+        }
+        if kresp.drag_stopped() {
+            cx.cmd("mixer.release", json!({"strip": sid, "lane": LANE_PAN, "time": cx.now.0}));
+        }
+        if kresp.double_clicked() {
+            cx.cmd("mixer.setValue", json!({"strip": sid, "lane": LANE_PAN, "value": 0.0}));
+        }
+        let vr = Rect::from_center_size(pos2(kc.x, y + 48.0), vec2(56.0, 16.0));
+        let mut vui = ui.new_child(egui::UiBuilder::new().max_rect(vr).layout(egui::Layout::top_down(egui::Align::Center)));
+        let (vresp, nv) = crate::widgets::hot_number(&mut vui, egui::Id::new((&ap, "panValue")), pan, 1.0, (-100.0, 100.0), 1, "", &t);
+        app.auto.add(&format!("{ap}.panValue"), vresp.rect, &format!("{pan:.1}"));
+        if let Some(v) = nv {
+            cx.cmd("mixer.setValue", json!({"strip": sid, "lane": LANE_PAN, "value": v}));
+        }
+        y += 62.0;
+    } else {
+        y += 112.0;
+    }
+
+    // ---- automation mode
+    let mr = Rect::from_min_size(pos2(x + 4.0, y), vec2(w - 8.0, 20.0));
+    let mode = tr.mixer.mode;
+    let mresp = crate::widgets::dropdown_text(ui, mr, mode.label(), &t, egui::Id::new((&ap, "mode")));
+    if cx.recording && mode.writes() {
+        ui.painter().rect_stroke(mr, 4.0, Stroke::new(1.0, RED), StrokeKind::Inside);
+    }
+    app.auto.add(&format!("{ap}.mode"), mr, &format!("Automation mode: {}", mode.label()));
+    egui::Popup::menu(&mresp).show(|ui| {
+        for m in AutomationMode::ALL {
+            let r = ui.selectable_label(m == mode, m.label());
+            app.auto.add(&format!("{ap}.mode.{}", m.label()), r.rect, m.label());
+            if r.clicked() {
+                cx.cmd("mixer.setStrip", json!({"strip": sid, "mode": m.label()}));
+            }
+        }
+    });
+    y += 26.0;
+
+    // ---- M / S / R
+    if !is_master {
+        let muted = shown(app, &tr, LANE_MUTE, cx.now) >= 0.5;
+        let bw = 18.0;
+        let bx = sr.center().x - bw * 1.5 - 6.0;
+        let b = |i: f32| Rect::from_min_size(pos2(bx + i * (bw + 6.0), y), vec2(bw, 16.0));
+        let m_r = crate::widgets::letter_toggle(ui, b(0.0), "M", muted, MUTE_ON, &t, egui::Id::new((&ap, "M")));
+        app.auto.add(&format!("{ap}.mute"), b(0.0), "Mute Track");
+        if m_r.clicked() {
+            if cx.recording && mode.writes() {
+                let v = if muted { 0.0 } else { 1.0 };
+                cx.cmd("mixer.touch", json!({"strip": sid, "lane": LANE_MUTE, "value": v, "time": cx.now.0}));
+                cx.cmd("mixer.release", json!({"strip": sid, "lane": LANE_MUTE, "time": cx.now.0}));
+            } else {
+                cx.cmd("mixer.setStrip", json!({"strip": sid, "muted": !tr.muted}));
+            }
+        }
+        let s_r = crate::widgets::letter_toggle(ui, b(1.0), "S", tr.solo, SOLO_ON, &t, egui::Id::new((&ap, "S")));
+        app.auto.add(&format!("{ap}.solo"), b(1.0), "Solo Track");
+        if s_r.clicked() {
+            cx.cmd("mixer.setStrip", json!({"strip": sid, "solo": !tr.solo}));
+        }
+        let is_sub = seq.submix_tracks.iter().any(|s| s.id == id);
+        if is_sub {
+            let r_r = crate::widgets::letter_toggle(ui, b(2.0), "◆", tr.mixer.solo_safe, Color32::from_gray(0xc8), &t, egui::Id::new((&ap, "safe")))
+                .on_hover_text("Solo safe");
+            app.auto.add(&format!("{ap}.soloSafe"), b(2.0), "Solo Safe");
+            if r_r.clicked() {
+                cx.cmd("mixer.setStrip", json!({"strip": sid, "soloSafe": !tr.mixer.solo_safe}));
+            }
+        } else {
+            let r_r = crate::widgets::letter_toggle(ui, b(2.0), "R", tr.mixer.record_arm, RED, &t, egui::Id::new((&ap, "R")))
+                .on_hover_text("Enable track for recording");
+            app.auto.add(&format!("{ap}.record"), b(2.0), "Enable Track for Recording");
+            if r_r.clicked() {
+                cx.cmd("mixer.setStrip", json!({"strip": sid, "recordArm": !tr.mixer.record_arm}));
+            }
+        }
+    }
+    y += 24.0;
+
+    // ---- fader + meters
+    let name_h = 20.0;
+    let value_h = 18.0;
+    let area = Rect::from_min_max(pos2(x, y + 6.0), pos2(sr.max.x, sr.max.y - name_h - value_h - 4.0));
+    if area.height() > 40.0 {
+        let track = Rect::from_min_max(pos2(x + 33.0, area.min.y + 8.0), pos2(x + 37.0, area.max.y - 8.0));
+        let ypos = |db: f64| track.max.y - db_to_pos(db) * track.height();
+        let tall = track.height() > 150.0;
+        // scale
+        small_text(ui, pos2(x + 26.0, area.min.y - 2.0), Align2::RIGHT_CENTER, "dB", 9.0, t.text_dim);
+        for d in SCALE.iter().copied().filter(|d| tall || [15.0, 0.0, -12.0, -30.0, -96.0].contains(d)) {
+            let yy = ypos(d);
+            let s = if d <= FADER_MIN_DB { "-∞".to_string() } else { format!("{}", d as i32) };
+            small_text(ui, pos2(x + 26.0, yy), Align2::RIGHT_CENTER, &s, 9.0, t.text_dim);
+            ui.painter().line_segment([pos2(x + 28.0, yy), pos2(x + 31.0, yy)], Stroke::new(1.0, t.text_faint));
+        }
+        ui.painter().rect_filled(track, 2.0, Color32::from_gray(0x10));
+        ui.painter().rect_stroke(track, 2.0, Stroke::new(1.0, Color32::from_gray(0x50)), StrokeKind::Inside);
+        let vol = shown(app, &tr, LANE_VOLUME, cx.now);
+        let cy = ypos(vol);
+        let cap = Rect::from_center_size(pos2(track.center().x, cy), vec2(18.0, 26.0));
+        let fresp = ui.interact(cap.expand(3.0), egui::Id::new((&ap, "fader")), Sense::click_and_drag()).on_hover_text("Volume (drag; double-click: 0 dB)");
+        let held = app.session.previews.live.get(id, LANE_VOLUME).is_some();
+        let col = if fresp.dragged() || held { t.accent } else { Color32::from_gray(0xe0) };
+        ui.painter().rect_filled(cap, 3.0, Color32::from_gray(0x2a));
+        ui.painter().rect_stroke(cap, 3.0, Stroke::new(2.0, col), StrokeKind::Inside);
+        ui.painter().line_segment([pos2(cap.min.x + 5.0, cy), pos2(cap.max.x - 5.0, cy)], Stroke::new(2.0, col));
+        app.auto.add(&format!("{ap}.fader"), cap, &format!("Volume {}", db_text(vol)));
+        if fresp.dragged() {
+            let dy = fresp.drag_delta().y;
+            if dy != 0.0 {
+                let fine = if ui.input(|i| i.modifiers.command) { 0.1 } else { 1.0 };
+                let nv = pos_to_db(db_to_pos(vol) - dy * fine / track.height());
+                cx.cmd("mixer.touch", json!({"strip": sid, "lane": LANE_VOLUME, "value": nv, "time": cx.now.0}));
+            } else if fresp.drag_started() {
+                cx.cmd("mixer.touch", json!({"strip": sid, "lane": LANE_VOLUME, "value": vol, "time": cx.now.0}));
+            }
+        }
+        if fresp.drag_stopped() {
+            cx.cmd("mixer.release", json!({"strip": sid, "lane": LANE_VOLUME, "time": cx.now.0}));
+        }
+        if fresp.double_clicked() {
+            cx.cmd("mixer.setValue", json!({"strip": sid, "lane": LANE_VOLUME, "value": 0.0}));
+        }
+        // meters with their own scale (0 … −54 dB)
+        let mrect = Rect::from_min_max(pos2(x + 46.0, area.min.y), pos2(x + 70.0, area.max.y));
+        draw_meters(ui, mrect, meter, &t);
+        app.auto.add(&format!("{ap}.meter"), mrect, &format!("Meter {:.1} / {:.1} dB", meter[0], meter[1]));
+        let bar_top = mrect.min.y + 6.0;
+        let bar_h = mrect.height() - 6.0;
+        let mut d = 0;
+        let step = if tall { 6 } else { 18 };
+        while d >= -54 {
+            let yy = bar_top + bar_h * (-d as f32 / 60.0);
+            small_text(ui, pos2(x + 91.0, yy), Align2::RIGHT_CENTER, &format!("{d}"), 8.5, t.text_dim);
+            ui.painter().line_segment([pos2(x + 71.0, yy), pos2(x + 74.0, yy)], Stroke::new(1.0, t.text_faint));
+            d -= step;
+        }
+        small_text(ui, pos2(x + 91.0, mrect.max.y + 6.0), Align2::RIGHT_CENTER, "dB", 8.5, t.text_dim);
+        // fader value (hot text)
+        let vr = Rect::from_min_size(pos2(x + 4.0, sr.max.y - name_h - value_h), vec2(56.0, value_h));
+        let mut vui = ui.new_child(egui::UiBuilder::new().max_rect(vr));
+        let (vresp, nv) = crate::widgets::hot_number(&mut vui, egui::Id::new((&ap, "value")), vol.max(-96.0), 0.1, (FADER_MIN_DB, FADER_MAX_DB), 1, "", &t);
+        app.auto.add(&format!("{ap}.value"), vresp.rect, &db_text(vol));
+        if let Some(v) = nv {
+            cx.cmd("mixer.setValue", json!({"strip": sid, "lane": LANE_VOLUME, "value": v}));
+        }
+    }
+    // ---- name
+    let nr = Rect::from_min_max(pos2(x, sr.max.y - name_h), sr.max);
+    ui.painter().line_segment([pos2(nr.min.x + 4.0, nr.min.y), pos2(nr.max.x - 4.0, nr.min.y)], Stroke::new(1.0, t.separator));
+    if is_master {
+        small_text(ui, nr.center(), Align2::CENTER_CENTER, "Mix", 12.0, t.text);
+    } else {
+        small_text(ui, pos2(nr.min.x + 6.0, nr.center().y), Align2::LEFT_CENTER, &label, 12.0, t.text);
+        let name = ui.painter().with_clip_rect(Rect::from_min_max(pos2(nr.min.x + 26.0, nr.min.y), nr.max).intersect(ui.clip_rect()));
+        name.text(pos2(nr.min.x + 30.0, nr.center().y), Align2::LEFT_CENTER, &tr.name, Tokens::ui(12.0), t.text);
+    }
+    app.auto.add(&format!("{ap}.name"), nr, &tr.name);
+}
+
+fn transport(app: &mut FilmcraftApp, ui: &mut egui::Ui, row: Rect, cx: &mut Ctx) {
+    let t = cx.t;
+    let seq = cx.seq;
+    ui.painter().line_segment([pos2(row.min.x, row.min.y + 0.5), pos2(row.max.x, row.min.y + 0.5)], Stroke::new(1.0, t.separator));
+    let tc = format_time(cx.now, seq.settings.frame_rate, seq.settings.drop_frame, TimeDisplay::Timecode, seq.settings.sample_rate as i64);
+    ui.painter().text(pos2(row.min.x + 12.0, row.center().y), Align2::LEFT_CENTER, tc, Tokens::mono(13.0), t.timecode);
+    let dur = format_time(seq.duration(), seq.settings.frame_rate, seq.settings.drop_frame, TimeDisplay::Timecode, seq.settings.sample_rate as i64);
+    ui.painter().text(pos2(row.max.x - 12.0, row.center().y), Align2::RIGHT_CENTER, dur, Tokens::mono(12.0), t.text_dim);
+    let playing = app.playback.playing;
+    let buttons: [(Icon, &str, &str); 6] = [
+        (Icon::GoToIn, "markers.goToIn", "Go to In Point"),
+        (Icon::GoToOut, "markers.goToOut", "Go to Out Point"),
+        (if playing { Icon::Pause } else { Icon::Play }, "playback.toggle", "Play-Stop Toggle (Space)"),
+        (Icon::Play, "playback.inToOut", "Play In to Out"),
+        (Icon::Loop, "playback.loop", "Loop"),
+        (Icon::Mic, "record", "Record (voice-over recording is not available yet)"),
+    ];
+    let bw = 30.0;
+    let mut x = row.center().x - bw * buttons.len() as f32 / 2.0;
+    for (icon, cmd, tip) in buttons {
+        let r = Rect::from_min_size(pos2(x, row.min.y + 4.0), vec2(bw - 2.0, 26.0));
+        let resp = ui.interact(r, egui::Id::new(("mixer-transport", cmd)), Sense::click()).on_hover_text(tip);
+        app.auto.add(&format!("mixer.transport.{cmd}"), r, tip);
+        if resp.hovered() {
+            ui.painter().rect_filled(r, 4.0, t.hover);
+        }
+        let on = cmd == "playback.loop" && app.playback.looping;
+        let col = if on {
+            t.accent
+        } else if resp.hovered() {
+            t.tab_text_active
+        } else {
+            t.icon
+        };
+        if cmd == "record" {
+            ui.painter().circle_filled(r.center(), 6.0, if cx.recording { RED } else { RED.gamma_multiply(0.55) });
+        } else {
+            icons::paint(ui.painter(), Rect::from_center_size(r.center(), vec2(14.0, 14.0)), icon, col);
+            if cmd == "playback.inToOut" {
+                // braces around the play triangle
+                let c = r.center();
+                for s in [-1.0f32, 1.0] {
+                    ui.painter().line_segment([pos2(c.x + s * 10.0, c.y - 6.0), pos2(c.x + s * 10.0, c.y + 6.0)], Stroke::new(1.5, col));
+                }
+            }
+        }
+        if resp.clicked() && cmd != "record" {
+            cx.cmd(cmd, json!({}));
+        }
+        x += bw;
+    }
+}
+
+// ------------------------------------------------------------------------------------- clip mixer
+
+/// Audio Clip Mixer: one strip per audio track, controlling the clip under the playhead (clip
+/// Volume and Panner). With the keyframe button on, changes add keyframes at the playhead.
+pub fn clip_mixer(app: &mut FilmcraftApp, ui: &mut egui::Ui, rect: Rect) {
+    let t = app.tokens;
+    let Some(seq) = app.session.active_sequence().cloned() else {
+        crate::dock::placeholder(ui, rect, &t, "(no sequence)");
+        return;
+    };
+    let meters = poll_meters(app, ui);
+    let now = app.session.playhead();
+    let mut acts: Vec<(String, Value)> = Vec::new();
+    let kf_id = egui::Id::new("clip-mixer-keyframes");
+    let mut write_kf: HashMap<u64, bool> = ui.data(|d| d.get_temp(kf_id)).unwrap_or_default();
+    for (i, tr) in seq.audio_tracks.iter().enumerate() {
+        let x = rect.min.x + 6.0 + i as f32 * (STRIP_W + 2.0);
+        if x + STRIP_W > rect.max.x {
+            break;
+        }
+        let sr = Rect::from_min_max(pos2(x, rect.min.y + 4.0), pos2(x + STRIP_W, rect.max.y - 4.0));
+        let label = format!("A{}", i + 1);
+        let ap = format!("clipMixer.{label}");
+        ui.painter().rect_filled(sr, 3.0, Color32::from_gray(0x24));
+        let clip = tr.item_at(now).filter(|c| c.enabled);
+        let active = clip.is_some();
+        let dimc = |c: Color32| if active { c } else { c.gamma_multiply(0.4) };
+        let mt = clip.map(|c| c.source_time_at(now));
+        let vol = clip.and_then(|c| c.effect("volume")).map(|e| e.f64_at("level", mt.unwrap_or_default())).unwrap_or(0.0);
+        let pan = clip.and_then(|c| c.effect("panner")).map(|e| e.f64_at("balance", mt.unwrap_or_default())).unwrap_or(0.0);
+        let kf = *write_kf.get(&tr.id.0).unwrap_or(&false);
+        let set = |acts: &mut Vec<(String, Value)>, effect: &str, param: &str, v: f64, begin: bool| {
+            if let Some(c) = clip {
+                acts.push(("clipMixer.set".into(), json!({"clip": c.id.0, "effect": effect, "param": param, "value": v, "keyframe": kf, "begin": begin})));
+            }
+        };
+        // pan knob
+        let kc = pos2(sr.center().x, sr.min.y + 26.0);
+        let kr = Rect::from_center_size(kc, vec2(34.0, 34.0));
+        let kresp = ui.interact(kr, egui::Id::new((&ap, "pan")), Sense::click_and_drag());
+        ui.painter().circle_stroke(kc, 14.0, Stroke::new(2.0, dimc(Color32::from_gray(0xb0))));
+        let ang = (pan / 100.0) as f32 * 135f32.to_radians();
+        ui.painter().line_segment([kc, kc + vec2(ang.sin(), -ang.cos()) * 12.0], Stroke::new(2.0, dimc(Color32::from_gray(0xb0))));
+        small_text(ui, pos2(kc.x - 18.0, kc.y + 16.0), Align2::CENTER_CENTER, "L", 11.0, dimc(t.hot_text));
+        small_text(ui, pos2(kc.x + 18.0, kc.y + 16.0), Align2::CENTER_CENTER, "R", 11.0, dimc(t.hot_text));
+        small_text(ui, pos2(kc.x, kc.y + 32.0), Align2::CENTER_CENTER, &format!("{pan:.1}"), 11.5, dimc(t.hot_text));
+        app.auto.add(&format!("{ap}.pan"), kr, "Clip pan");
+        if kresp.dragged() && active {
+            let d = kresp.drag_delta();
+            set(&mut acts, "panner", "balance", (pan + (d.x - d.y) as f64).clamp(-100.0, 100.0), kresp.drag_started());
+        }
+        if kresp.double_clicked() {
+            set(&mut acts, "panner", "balance", 0.0, true);
+        }
+        // M S ◇
+        let y = sr.min.y + 72.0;
+        let b = |k: f32| Rect::from_min_size(pos2(sr.center().x - 33.0 + k * 24.0, y), vec2(18.0, 16.0));
+        let mr = crate::widgets::letter_toggle(ui, b(0.0), "M", tr.muted, MUTE_ON, &t, egui::Id::new((&ap, "M")));
+        app.auto.add(&format!("{ap}.mute"), b(0.0), "Mute Track");
+        if mr.clicked() {
+            acts.push(("mixer.setStrip".into(), json!({"strip": tr.id.0, "muted": !tr.muted})));
+        }
+        let so = crate::widgets::letter_toggle(ui, b(1.0), "S", tr.solo, SOLO_ON, &t, egui::Id::new((&ap, "S")));
+        app.auto.add(&format!("{ap}.solo"), b(1.0), "Solo Track");
+        if so.clicked() {
+            acts.push(("mixer.setStrip".into(), json!({"strip": tr.id.0, "solo": !tr.solo})));
+        }
+        let kresp =
+            crate::widgets::icon_toggle(ui, b(2.0), Icon::Keyframe, kf, &t, egui::Id::new((&ap, "kf")), Some(t.accent)).on_hover_text("Write keyframes");
+        app.auto.add(&format!("{ap}.keyframe"), b(2.0), "Write Keyframes");
+        if kresp.clicked() {
+            write_kf.insert(tr.id.0, !kf);
+        }
+        // fader + meter
+        let area = Rect::from_min_max(pos2(sr.min.x, y + 30.0), pos2(sr.max.x, sr.max.y - 46.0));
+        if area.height() > 40.0 {
+            let track = Rect::from_min_max(pos2(sr.min.x + 33.0, area.min.y + 8.0), pos2(sr.min.x + 37.0, area.max.y - 8.0));
+            let ypos = |db: f64| track.max.y - db_to_pos(db) * track.height();
+            for d in SCALE {
+                let s = if d <= FADER_MIN_DB { "-∞".to_string() } else { format!("{}", d as i32) };
+                small_text(ui, pos2(sr.min.x + 26.0, ypos(d)), Align2::RIGHT_CENTER, &s, 9.0, t.text_dim);
+            }
+            ui.painter().rect_filled(track, 2.0, Color32::from_gray(0x10));
+            let cy = ypos(vol);
+            let cap = Rect::from_center_size(pos2(track.center().x, cy), vec2(18.0, 26.0));
+            let fresp = ui.interact(cap.expand(3.0), egui::Id::new((&ap, "fader")), Sense::click_and_drag());
+            ui.painter().rect_filled(cap, 3.0, Color32::from_gray(0x2a));
+            ui.painter().rect_stroke(cap, 3.0, Stroke::new(2.0, dimc(Color32::from_gray(0xe0))), StrokeKind::Inside);
+            ui.painter().line_segment([pos2(cap.min.x + 5.0, cy), pos2(cap.max.x - 5.0, cy)], Stroke::new(2.0, dimc(Color32::from_gray(0xe0))));
+            app.auto.add(&format!("{ap}.fader"), cap, &format!("Clip volume {}", db_text(vol)));
+            if fresp.dragged() && active && fresp.drag_delta().y != 0.0 {
+                set(&mut acts, "volume", "level", pos_to_db(db_to_pos(vol) - fresp.drag_delta().y / track.height()), fresp.drag_started());
+            }
+            if fresp.double_clicked() {
+                set(&mut acts, "volume", "level", 0.0, true);
+            }
+            let mrect = Rect::from_min_max(pos2(sr.min.x + 46.0, area.min.y), pos2(sr.max.x - 6.0, area.max.y));
+            draw_meters(ui, mrect, meters.get(&tr.id.0).copied().unwrap_or([-90.0; 4]), &t);
+        }
+        small_text(ui, pos2(sr.min.x + 8.0, sr.max.y - 34.0), Align2::LEFT_CENTER, &db_text(vol), 11.5, dimc(t.hot_text));
+        app.auto.add(&format!("{ap}.value"), Rect::from_min_size(pos2(sr.min.x + 4.0, sr.max.y - 42.0), vec2(50.0, 16.0)), &db_text(vol));
+        small_text(ui, pos2(sr.min.x + 6.0, sr.max.y - 10.0), Align2::LEFT_CENTER, &label, 12.0, t.text);
+        small_text(ui, pos2(sr.min.x + 30.0, sr.max.y - 10.0), Align2::LEFT_CENTER, &tr.name, 12.0, t.text);
+    }
+    ui.data_mut(|d| d.insert_temp(kf_id, write_kf));
+    run_actions(app, &ui.ctx().clone(), acts);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn taper_roundtrips_and_is_monotonic() {
+        let mut last = f64::NEG_INFINITY;
+        for i in 0..=100 {
+            let p = i as f32 / 100.0;
+            let db = pos_to_db(p);
+            assert!(db >= last - 1e-9);
+            last = db;
+            if db > FADER_MIN_DB {
+                assert!((db_to_pos(db) - p).abs() < 1e-4, "{p} → {db}");
+            }
+        }
+        assert_eq!(db_to_pos(0.0), 0.76);
+        assert_eq!(pos_to_db(1.0), 15.0);
+        assert_eq!(pos_to_db(0.0), FADER_MIN_DB);
+    }
+}
diff --git a/crates/ui-egui/src/panels/mod.rs b/crates/ui-egui/src/panels/mod.rs
index 560d6a361..ccb6ec9b2 100644
--- a/crates/ui-egui/src/panels/mod.rs
+++ b/crates/ui-egui/src/panels/mod.rs
@@ -6,16 +6,21 @@ pub mod effect_controls;
 pub mod effects;
 pub mod export_mode;
 pub mod file_dialogs;
+pub mod graphics;
 pub mod import_mode;
 pub mod lumetri;
 pub mod meters;
 pub mod misc;
+pub mod mixer;
 pub mod monitor;
 pub mod project;
+pub mod shortcuts_dialog;
 pub mod text;
 pub mod timeline;
+pub mod timeline_automation;
 pub mod timeline_captions;
 pub mod tools;
+pub mod trim_monitor;
 
 use egui::{Align2, Color32, Rect};
 use filmcraft_project::ItemId;
@@ -26,6 +31,7 @@ use crate::theme::Tokens;
 
 pub fn show(app: &mut FilmcraftApp, ui: &mut egui::Ui, p: PanelKind, rect: Rect) {
     match p {
+        PanelKind::Program if !app.session.state.edit_points.is_empty() => trim_monitor::show(app, ui, rect),
         PanelKind::Program => monitor::show(app, ui, rect, monitor::Which::Program),
         PanelKind::Source => monitor::show(app, ui, rect, monitor::Which::Source),
         PanelKind::Timeline => timeline::show(app, ui, rect),
@@ -35,12 +41,15 @@ pub fn show(app: &mut FilmcraftApp, ui: &mut egui::Ui, p: PanelKind, rect: Rect)
         PanelKind::EffectControls => effect_controls::show(app, ui, rect),
         PanelKind::AudioMeters => meters::show(app, ui, rect),
         PanelKind::LumetriColor => lumetri::show(app, ui, rect),
+        PanelKind::Properties if graphics::graphic_selected(app) => graphics::properties(app, ui, rect),
         PanelKind::Properties => effect_controls::properties_panel(app, ui, rect),
+        PanelKind::EssentialGraphics => graphics::properties(app, ui, rect),
         PanelKind::History => misc::history(app, ui, rect),
         PanelKind::Markers => misc::markers(app, ui, rect),
         PanelKind::Info => misc::info(app, ui, rect),
         PanelKind::MediaBrowser => misc::media_browser(app, ui, rect),
-        PanelKind::AudioTrackMixer => meters::track_mixer(app, ui, rect),
+        PanelKind::AudioTrackMixer => mixer::track_mixer(app, ui, rect),
+        PanelKind::AudioClipMixer => mixer::clip_mixer(app, ui, rect),
         PanelKind::LumetriScopes => misc::scopes(app, ui, rect),
         PanelKind::Text => text::show(app, ui, rect),
         other => crate::dock::placeholder(ui, rect, &app.tokens, &format!("{} — coming in a later milestone", other.title())),
diff --git a/crates/ui-egui/src/panels/monitor.rs b/crates/ui-egui/src/panels/monitor.rs
index 3dcb1d5b8..61695ddba 100644
--- a/crates/ui-egui/src/panels/monitor.rs
+++ b/crates/ui-egui/src/panels/monitor.rs
@@ -159,6 +159,9 @@ pub fn show(app: &mut FilmcraftApp, ui: &mut egui::Ui, rect: Rect, which: Which)
     // Click/drag in the picture: the Hand tool pans, otherwise focus.
     let pic_resp = ui.interact(pic, egui::Id::new((prefix, "pic")), Sense::click());
     app.auto.add(&format!("{prefix}.picture"), pic, "picture");
+    if which == Which::Program && has_video {
+        crate::panels::graphics::monitor_overlay(app, ui, pic, frame_size);
+    }
     if pic_resp.double_clicked() && which == Which::Source {
         // (Premiere opens the clip's settings; we show info)
         app.ui.status = name.clone();
diff --git a/crates/ui-egui/src/panels/project.rs b/crates/ui-egui/src/panels/project.rs
index ef5098dcf..e9bfb3241 100644
--- a/crates/ui-egui/src/panels/project.rs
+++ b/crates/ui-egui/src/panels/project.rs
@@ -21,7 +21,7 @@ fn item_icon(k: &ItemKind) -> Icon {
         },
         ItemKind::Sequence(_) => Icon::Sequence,
         ItemKind::Subclip { .. } => Icon::Film,
-        ItemKind::AdjustmentLayer { .. } => Icon::Adjust,
+        ItemKind::AdjustmentLayer { .. } | ItemKind::Graphic { .. } => Icon::Adjust,
     }
 }
 
@@ -166,7 +166,9 @@ fn columns(r: Rect) -> [f32; 4] {
 }
 
 fn matches(app: &FilmcraftApp, id: ItemId, filter: &str) -> bool {
-    filter.is_empty() || app.session.project.item(id).is_some_and(|i| i.name.to_ascii_lowercase().contains(filter))
+    // graphic clip sources are internal (Premiere doesn't list graphics in the Project panel)
+    app.session.project.item(id).is_some_and(|i| !matches!(i.kind, ItemKind::Graphic { .. }))
+        && (filter.is_empty() || app.session.project.item(id).is_some_and(|i| i.name.to_ascii_lowercase().contains(filter)))
 }
 
 #[allow(clippy::too_many_arguments)]
diff --git a/crates/ui-egui/src/panels/shortcuts_dialog.rs b/crates/ui-egui/src/panels/shortcuts_dialog.rs
new file mode 100644
index 000000000..262d830c9
--- /dev/null
+++ b/crates/ui-egui/src/panels/shortcuts_dialog.rs
@@ -0,0 +1,787 @@
+//! Edit ▸ Keyboard Shortcuts… (⌥⌘K): a keyboard drawn in code with every assigned key coloured
+//! (application-wide / panel-specific / both), a searchable command list with a shortcut column
+//! (click it and press keys to assign; "+" adds another shortcut), the "Key:" detail list,
+//! conflict warnings, preset load / Save As / Delete / Export / Import, and Undo / Redo / Clear.
+//! Edits apply live (menus update immediately); Cancel restores the set the dialog opened with.
+//!
+//! All state lives in the engine's shortcut set (`shortcuts.*` commands), so agents can do the
+//! same over MCP. Automation ids: `shortcuts.preset`, `shortcuts.preset.<name>`, `shortcuts.saveAs`,
+//! `shortcuts.saveAs.name`, `shortcuts.saveAs.ok`, `shortcuts.delete`, `shortcuts.export`,
+//! `shortcuts.import`, `shortcuts.context`, `shortcuts.context.<panel>`, `shortcuts.search`,
+//! `shortcuts.key.<Key>`, `shortcuts.mod.<Cmd|Ctrl|Alt|Shift>`, `shortcuts.row.<command>`,
+//! `shortcuts.cell.<command>` (click = record), `shortcuts.add.<command>`, `shortcuts.assignKey`,
+//! `shortcuts.undo`, `shortcuts.redo`, `shortcuts.clear`, `shortcuts.cancel`, `shortcuts.ok`.
+
+use egui::text::LayoutJob;
+use egui::{Align2, Color32, CornerRadius, FontId, Rect, RichText, Sense, Stroke, StrokeKind, TextFormat, pos2, vec2};
+use filmcraft_engine::shortcuts::{APPLICATION, Chord, KEYS, Mods, PANELS, Platform};
+use serde::Serialize;
+use serde_json::{Value, json};
+
+use crate::FilmcraftApp;
+use crate::theme::Tokens;
+
+/// Key colours (our own palette): application-wide, panel-specific, unassigned, held modifier.
+pub const APP_KEY: Color32 = Color32::from_rgb(0x74, 0x57, 0xc8);
+pub const PANEL_KEY: Color32 = Color32::from_rgb(0x4a, 0xa6, 0x84);
+pub const FREE_KEY: Color32 = Color32::from_rgb(0x5a, 0x5a, 0x5e);
+const MOD_KEY: Color32 = Color32::from_rgb(0x2f, 0x62, 0xc0);
+const WARN: Color32 = Color32::from_rgb(0xe8, 0xa0, 0x3c);
+
+#[derive(Clone, Debug, Default, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct EditorState {
+    pub search: String,
+    /// "Application" or a panel name (which panel's shortcuts the keyboard and assignments use).
+    pub context: String,
+    pub selected: Option<String>,
+    /// Waiting for a key press: (command, add instead of replace).
+    pub recording: Option<(String, bool)>,
+    /// Modifier filter toggled on the drawn keyboard.
+    pub mods: Mods,
+    /// Key whose assignments the "Key:" list shows.
+    pub key: Option<String>,
+    pub message: String,
+    /// Save As… name being typed (Some = the field is open).
+    pub save_name: Option<String>,
+}
+
+impl EditorState {
+    fn panel(&self) -> Option<&str> {
+        if self.context.is_empty() || self.context == APPLICATION { None } else { Some(self.context.as_str()) }
+    }
+}
+
+/// Open the dialog (Edit ▸ Keyboard Shortcuts…).
+pub fn open(app: &mut FilmcraftApp) {
+    app.session.shortcuts.begin_editing();
+    app.shortcut_editor = EditorState { context: APPLICATION.into(), ..Default::default() };
+    app.dialog = Some(crate::Dialog::Shortcuts);
+}
+
+/// The egui key for a canonical key name.
+fn egui_key(name: &str) -> Option<egui::Key> {
+    crate::menus::parse_shortcut(name).map(|(_, k)| k)
+}
+
+/// Canonical chord text from an egui key event.
+pub fn chord_of(key: egui::Key, m: egui::Modifiers) -> Option<String> {
+    let name = KEYS.iter().find(|k| egui_key(k) == Some(key))?;
+    let mods = Mods { cmd: m.command || m.mac_cmd, ctrl: m.ctrl && cfg!(target_os = "macos"), alt: m.alt, shift: m.shift };
+    Some(format!("{}{}", mods.prefix(), name))
+}
+
+fn label_of(app: &FilmcraftApp, id: &str) -> String {
+    app.session
+        .shortcuts
+        .command(id)
+        .map(|c| c.label)
+        .or_else(|| filmcraft_engine::find_command(id).map(|c| c.label.to_string()))
+        .unwrap_or_else(|| id.to_string())
+}
+
+fn exec(app: &mut FilmcraftApp, cmd: &str, params: Value) -> Option<Value> {
+    match app.session.execute(cmd, params) {
+        Ok(v) => Some(v),
+        Err(e) => {
+            app.shortcut_editor.message = e.to_string();
+            None
+        }
+    }
+}
+
+/// Assign a recorded chord.
+fn assign(app: &mut FilmcraftApp, command: &str, keys: &str, add: bool) {
+    let panel = app.shortcut_editor.panel().map(str::to_string);
+    let p = Platform::current();
+    if let Some(r) = exec(app, "shortcuts.set", json!({"command": command, "keys": keys, "panel": panel, "add": add})) {
+        let disp = Chord::parse(keys).map(|c| c.display(p)).unwrap_or_else(|_| keys.into());
+        let mut msg = format!("{disp} → {}", label_of(app, command));
+        let moved: Vec<String> = r["reassigned"].as_array().into_iter().flatten().filter_map(|b| b["command"].as_str().map(|c| label_of(app, c))).collect();
+        if !moved.is_empty() {
+            msg.push_str(&format!(" (removed from {})", moved.join(", ")));
+        }
+        app.shortcut_editor.message = msg;
+    }
+}
+
+/// Take the next key press while recording (Esc cancels).
+fn record(app: &mut FilmcraftApp, ctx: &egui::Context) {
+    let Some((cmd, add)) = app.shortcut_editor.recording.clone() else { return };
+    let got = ctx.input_mut(|i| {
+        let mut got = None;
+        i.events.retain(|e| match e {
+            egui::Event::Key { key, pressed: true, modifiers, .. } if got.is_none() => {
+                got = Some((*key, *modifiers));
+                false
+            }
+            egui::Event::Key { .. } | egui::Event::Text(_) => false,
+            _ => true,
+        });
+        got
+    });
+    let Some((key, m)) = got else { return };
+    app.shortcut_editor.recording = None;
+    if key == egui::Key::Escape && !m.any() {
+        app.shortcut_editor.message = "Cancelled".into();
+        return;
+    }
+    match chord_of(key, m) {
+        Some(k) => assign(app, &cmd, &k, add),
+        None => app.shortcut_editor.message = format!("{key:?} can't be used as a shortcut"),
+    }
+}
+
+/// Show the dialog; false when it closed.
+pub fn show(app: &mut FilmcraftApp, ctx: &egui::Context) -> bool {
+    record(app, ctx);
+    let t = app.tokens;
+    let screen = ctx.content_rect();
+    let size = vec2((screen.width() - 40.0).clamp(760.0, 1320.0), (screen.height() - 60.0).clamp(560.0, 900.0));
+    let mut close: Option<bool> = None; // Some(true) = OK, Some(false) = Cancel
+    let mut open = true;
+    egui::Window::new("Keyboard Shortcuts")
+        .id(egui::Id::new("keyboard-shortcuts"))
+        .open(&mut open)
+        .collapsible(false)
+        .resizable(false)
+        .fixed_size(size)
+        .anchor(Align2::CENTER_CENTER, vec2(0.0, 0.0))
+        .frame(egui::Frame::window(&ctx.global_style()).fill(t.panel_bg).inner_margin(14.0))
+        .show(ctx, |ui| {
+            ui.set_width(size.x);
+            header(app, ui, &t);
+            ui.add_space(8.0);
+            let kb_h = (size.y * 0.42).clamp(220.0, 360.0);
+            let (kb, _) = ui.allocate_exact_size(vec2(size.x, kb_h), Sense::hover());
+            keyboard(app, ui, kb, &t);
+            legend(ui, &t);
+            ui.add_space(6.0);
+            let rest_h = (size.y - kb_h - 160.0).max(160.0);
+            ui.horizontal_top(|ui| {
+                ui.vertical(|ui| {
+                    ui.set_width(size.x * 0.6);
+                    command_list(app, ui, rest_h, &t);
+                });
+                ui.add_space(12.0);
+                ui.vertical(|ui| {
+                    ui.set_width(size.x * 0.4 - 14.0);
+                    key_detail(app, ui, rest_h, &t);
+                });
+            });
+            ui.add_space(6.0);
+            close = footer(app, ui, &t);
+        });
+    if !open {
+        close = Some(false);
+    }
+    match close {
+        Some(ok) => {
+            if ok {
+                app.session.shortcuts.end_editing();
+            } else {
+                app.session.shortcuts.cancel_editing();
+            }
+            app.shortcut_editor.recording = None;
+            false
+        }
+        None => true,
+    }
+}
+
+fn small_button(app: &mut FilmcraftApp, ui: &mut egui::Ui, id: &str, label: &str, enabled: bool) -> bool {
+    let r = ui.add_enabled(enabled, egui::Button::new(RichText::new(label).size(12.5)).min_size(vec2(0.0, 24.0)));
+    app.auto.add(id, r.rect, label);
+    r.clicked()
+}
+
+fn header(app: &mut FilmcraftApp, ui: &mut egui::Ui, t: &Tokens) {
+    let presets = app.session.execute("shortcuts.presets", json!({})).unwrap_or_default();
+    let active = presets["active"].as_str().unwrap_or("").to_string();
+    let modified = presets["modified"].as_bool().unwrap_or(false);
+    let builtin: Vec<String> = presets["builtin"].as_array().into_iter().flatten().filter_map(|v| v.as_str().map(str::to_string)).collect();
+    let custom: Vec<String> = presets["custom"].as_array().into_iter().flatten().filter_map(|v| v.as_str().map(str::to_string)).collect();
+    ui.horizontal(|ui| {
+        ui.label(RichText::new("Preset:").size(13.0).color(t.text_dim));
+        let shown = if modified { format!("{active} (modified)") } else { active.clone() };
+        let r = egui::ComboBox::from_id_salt("shortcuts-preset").width(280.0).selected_text(shown).show_ui(ui, |ui| {
+            for name in builtin.iter().chain(custom.iter()) {
+                let r = ui.selectable_label(*name == active && !modified, name);
+                app.auto.add(&format!("shortcuts.preset.{name}"), r.rect, name);
+                if r.clicked() {
+                    exec(app, "shortcuts.loadPreset", json!({"name": name}));
+                    app.shortcut_editor.message = format!("Loaded “{name}”");
+                }
+            }
+        });
+        app.auto.add("shortcuts.preset", r.response.rect, "Preset");
+        ui.add_space(8.0);
+        if small_button(app, ui, "shortcuts.saveAs", "Save As…", true) {
+            app.shortcut_editor.save_name = Some(if builtin.contains(&active) { "My Shortcuts".into() } else { active.clone() });
+        }
+        let can_delete = custom.contains(&active);
+        if small_button(app, ui, "shortcuts.delete", "Delete", can_delete) {
+            exec(app, "shortcuts.deletePreset", json!({"name": active}));
+            app.shortcut_editor.message = format!("Deleted preset “{active}”");
+        }
+        if small_button(app, ui, "shortcuts.export", "Export…", true) {
+            let picked = app.hooks.pick_save_as.as_mut().and_then(|f| f("Keyboard Shortcuts", &["json"], &format!("{active}.json")));
+            match picked {
+                Some(path) => {
+                    if exec(app, "shortcuts.export", json!({"path": path})).is_some() {
+                        app.shortcut_editor.message = format!("Exported to {path}");
+                    }
+                }
+                None => app.shortcut_editor.message = "Export: no file chosen (agents: shortcuts.export {path})".into(),
+            }
+        }
+        if small_button(app, ui, "shortcuts.import", "Import…", true) {
+            let picked = app.hooks.pick_open_file.as_mut().and_then(|f| f("Keyboard Shortcuts", &["json"]));
+            match picked {
+                Some(path) => {
+                    if let Some(r) = exec(app, "shortcuts.import", json!({"path": path})) {
+                        app.shortcut_editor.message = format!("Imported “{}”", r["name"].as_str().unwrap_or(""));
+                    }
+                }
+                None => app.shortcut_editor.message = "Import: no file chosen (agents: shortcuts.import {path})".into(),
+            }
+        }
+        ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+            ui.label(RichText::new(if cfg!(target_os = "macos") { "Keyboard: US (macOS)" } else { "Keyboard: US" }).size(12.0).color(t.text_dim));
+        });
+    });
+    if let Some(mut name) = app.shortcut_editor.save_name.clone() {
+        ui.horizontal(|ui| {
+            ui.label(RichText::new("Save preset as:").size(13.0).color(t.text_dim));
+            let r = ui.add(egui::TextEdit::singleline(&mut name).desired_width(260.0));
+            app.auto.add("shortcuts.saveAs.name", r.rect, "Preset name");
+            let enter = r.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter));
+            if small_button(app, ui, "shortcuts.saveAs.ok", "Save", !name.trim().is_empty()) || enter {
+                if exec(app, "shortcuts.savePreset", json!({"name": name})).is_some() {
+                    app.shortcut_editor.message = format!("Saved preset “{}”", name.trim());
+                    app.shortcut_editor.save_name = None;
+                } else {
+                    app.shortcut_editor.save_name = Some(name.clone());
+                }
+            } else if small_button(app, ui, "shortcuts.saveAs.cancel", "Cancel", true) {
+                app.shortcut_editor.save_name = None;
+            } else {
+                app.shortcut_editor.save_name = Some(name.clone());
+            }
+        });
+    }
+    ui.add_space(4.0);
+    ui.horizontal(|ui| {
+        ui.label(RichText::new("Commands:").size(13.0).color(t.text_dim));
+        let cur = app.shortcut_editor.context.clone();
+        let r =
+            egui::ComboBox::from_id_salt("shortcuts-context").width(280.0).selected_text(if cur.is_empty() { APPLICATION } else { &cur }).show_ui(ui, |ui| {
+                for c in std::iter::once(APPLICATION).chain(PANELS.iter().copied()) {
+                    let label = if c == APPLICATION { c.to_string() } else { format!("{c} Panel") };
+                    let r = ui.selectable_label(cur == c, label);
+                    app.auto.add(&format!("shortcuts.context.{c}"), r.rect, c);
+                    if r.clicked() {
+                        app.shortcut_editor.context = c.to_string();
+                    }
+                }
+            });
+        app.auto.add("shortcuts.context", r.response.rect, "Commands");
+    });
+}
+
+/// (key name, width in key units); "" = gap.
+type KeyRow = &'static [(&'static str, f32)];
+const MAIN_ROWS: [KeyRow; 6] = [
+    &[
+        ("Escape", 1.0),
+        ("", 0.5),
+        ("F1", 1.0),
+        ("F2", 1.0),
+        ("F3", 1.0),
+        ("F4", 1.0),
+        ("", 0.25),
+        ("F5", 1.0),
+        ("F6", 1.0),
+        ("F7", 1.0),
+        ("F8", 1.0),
+        ("", 0.25),
+        ("F9", 1.0),
+        ("F10", 1.0),
+        ("F11", 1.0),
+        ("F12", 1.0),
+    ],
+    &[
+        ("`", 1.0),
+        ("1", 1.0),
+        ("2", 1.0),
+        ("3", 1.0),
+        ("4", 1.0),
+        ("5", 1.0),
+        ("6", 1.0),
+        ("7", 1.0),
+        ("8", 1.0),
+        ("9", 1.0),
+        ("0", 1.0),
+        ("-", 1.0),
+        ("=", 1.0),
+        ("Backspace", 2.0),
+    ],
+    &[
+        ("Tab", 1.5),
+        ("Q", 1.0),
+        ("W", 1.0),
+        ("E", 1.0),
+        ("R", 1.0),
+        ("T", 1.0),
+        ("Y", 1.0),
+        ("U", 1.0),
+        ("I", 1.0),
+        ("O", 1.0),
+        ("P", 1.0),
+        ("[", 1.0),
+        ("]", 1.0),
+        ("\\", 1.5),
+    ],
+    &[
+        ("#Caps", 1.75),
+        ("A", 1.0),
+        ("S", 1.0),
+        ("D", 1.0),
+        ("F", 1.0),
+        ("G", 1.0),
+        ("H", 1.0),
+        ("J", 1.0),
+        ("K", 1.0),
+        ("L", 1.0),
+        (";", 1.0),
+        ("'", 1.0),
+        ("Enter", 2.25),
+    ],
+    &[
+        ("#Shift", 2.25),
+        ("Z", 1.0),
+        ("X", 1.0),
+        ("C", 1.0),
+        ("V", 1.0),
+        ("B", 1.0),
+        ("N", 1.0),
+        ("M", 1.0),
+        (",", 1.0),
+        (".", 1.0),
+        ("/", 1.0),
+        ("#Shift", 2.75),
+    ],
+    &[("#Ctrl", 1.5), ("#Alt", 1.25), ("#Cmd", 1.5), ("Space", 6.5), ("#Cmd", 1.5), ("#Alt", 1.25), ("#Ctrl", 1.5)],
+];
+/// Navigation cluster rows (x offset in units within the cluster).
+const NAV_ROWS: [&[(&str, f32)]; 6] = [
+    &[],
+    &[("Insert", 0.0), ("Home", 1.0), ("PageUp", 2.0)],
+    &[("Delete", 0.0), ("End", 1.0), ("PageDown", 2.0)],
+    &[],
+    &[("Up", 1.0)],
+    &[("Left", 0.0), ("Down", 1.0), ("Right", 2.0)],
+];
+
+fn key_legend(name: &str, mac: bool) -> String {
+    match name {
+        "#Caps" => "Caps Lock".into(),
+        "#Shift" => "⇧ Shift".into(),
+        "#Ctrl" => {
+            if mac {
+                "⌃ Control".into()
+            } else {
+                "Win".into()
+            }
+        }
+        "#Alt" => {
+            if mac {
+                "⌥ Option".into()
+            } else {
+                "Alt".into()
+            }
+        }
+        "#Cmd" => {
+            if mac {
+                "⌘ Command".into()
+            } else {
+                "Ctrl".into()
+            }
+        }
+        "Backspace" => {
+            if mac {
+                "⌫ Delete".into()
+            } else {
+                "Backspace".into()
+            }
+        }
+        "Delete" => {
+            if mac {
+                "⌦ Fwd Del".into()
+            } else {
+                "Delete".into()
+            }
+        }
+        "Enter" => "↩ Return".into(),
+        "Escape" => "Esc".into(),
+        "PageUp" => "Page Up".into(),
+        "PageDown" => "Page Down".into(),
+        "Up" => "↑".into(),
+        "Down" => "↓".into(),
+        "Left" => "←".into(),
+        "Right" => "→".into(),
+        k => k.into(),
+    }
+}
+
+fn keyboard(app: &mut FilmcraftApp, ui: &mut egui::Ui, area: Rect, t: &Tokens) {
+    let mac = cfg!(target_os = "macos");
+    // held modifiers count as the filter too (outside recording)
+    let held = ui.input(|i| i.modifiers);
+    let mut mods = app.shortcut_editor.mods;
+    if app.shortcut_editor.recording.is_none() {
+        mods.cmd |= held.command;
+        mods.ctrl |= held.ctrl && mac;
+        mods.alt |= held.alt;
+        mods.shift |= held.shift;
+    }
+    let panel = app.shortcut_editor.panel().map(str::to_string);
+    let map = app.session.shortcuts.keyboard(mods, panel.as_deref());
+    let units_w = 15.0 + 0.5 + 3.0;
+    let gap = 3.0;
+    let u = (area.width() / units_w).min(area.height() / 6.2);
+    let row_h = u * 0.98;
+    let origin = area.min;
+    let mut clicked_key: Option<String> = None;
+    let mut toggled: Option<&str> = None;
+    let mut draw = |ui: &mut egui::Ui, r: Rect, name: &str| {
+        let r = r.shrink(gap / 2.0);
+        let is_mod = name.starts_with('#');
+        let (app_cmd, panel_cmd) = map.get(name).cloned().unwrap_or_default();
+        let mod_on = match name {
+            "#Shift" => mods.shift,
+            "#Alt" => mods.alt,
+            "#Cmd" => mods.cmd,
+            "#Ctrl" => mods.ctrl,
+            _ => false,
+        };
+        // modifier keys appear twice: the right-hand ones get a ".right" suffix
+        let right = is_mod && r.center().x > area.center().x;
+        let id = match (is_mod, right) {
+            (true, false) => format!("shortcuts.mod.{}", &name[1..]),
+            (true, true) => format!("shortcuts.mod.{}.right", &name[1..]),
+            _ => format!("shortcuts.key.{name}"),
+        };
+        let resp = ui.interact(r, egui::Id::new(&id), Sense::click());
+        let p = ui.painter();
+        let base = if is_mod {
+            if mod_on { MOD_KEY } else { FREE_KEY.gamma_multiply(0.8) }
+        } else if app_cmd.is_some() {
+            APP_KEY
+        } else if panel_cmd.is_some() {
+            PANEL_KEY
+        } else {
+            FREE_KEY
+        };
+        p.rect_filled(r, CornerRadius::same(3), base);
+        if app_cmd.is_some() && panel_cmd.is_some() {
+            // both: lower-right triangle in the panel colour
+            p.add(egui::Shape::convex_polygon(vec![r.right_top(), r.right_bottom(), r.left_bottom()], PANEL_KEY, Stroke::NONE));
+        }
+        if resp.hovered() {
+            p.rect_stroke(r, CornerRadius::same(3), Stroke::new(1.5, Color32::WHITE), StrokeKind::Inside);
+        }
+        if app.shortcut_editor.key.as_deref() == Some(name) {
+            p.rect_stroke(r, CornerRadius::same(3), Stroke::new(2.0, t.accent), StrokeKind::Inside);
+        }
+        let fs = (u * 0.2).clamp(8.5, 12.0);
+        if let Some(cmd) = app_cmd.as_ref().or(panel_cmd.as_ref()) {
+            let label = label_of(app, cmd);
+            let mut job = LayoutJob::single_section(label, TextFormat::simple(FontId::proportional(fs), Color32::WHITE));
+            job.wrap.max_width = r.width() - 8.0;
+            job.wrap.max_rows = if r.height() > 3.5 * fs { 2 } else { 1 };
+            job.wrap.break_anywhere = false;
+            job.wrap.overflow_character = Some('…');
+            let g = ui.fonts_mut(|f| f.layout_job(job));
+            ui.painter().galley(r.min + vec2(4.0, 3.0), g, Color32::WHITE);
+        }
+        ui.painter().text(
+            r.left_bottom() + vec2(4.0, -3.0),
+            Align2::LEFT_BOTTOM,
+            key_legend(name, mac),
+            FontId::proportional(fs),
+            Color32::from_white_alpha(220),
+        );
+        let tip = match (&app_cmd, &panel_cmd) {
+            (Some(a), Some(b)) => format!("{} / {} ({})", label_of(app, a), label_of(app, b), panel.clone().unwrap_or_default()),
+            (Some(a), None) => label_of(app, a),
+            (None, Some(b)) => label_of(app, b),
+            _ => key_legend(name, mac),
+        };
+        app.auto.add(&id, r, &tip);
+        if resp.clicked() {
+            if is_mod {
+                toggled = Some(match name {
+                    "#Shift" => "Shift",
+                    "#Alt" => "Alt",
+                    "#Cmd" => "Cmd",
+                    _ => "Ctrl",
+                });
+            } else if name != "#Caps" {
+                clicked_key = Some(name.to_string());
+            }
+        }
+    };
+    for (ri, row) in MAIN_ROWS.iter().enumerate() {
+        let mut x = origin.x;
+        let y = origin.y + ri as f32 * row_h + if ri > 0 { u * 0.15 } else { 0.0 };
+        for (name, w) in row.iter() {
+            let r = Rect::from_min_size(pos2(x, y), vec2(w * u, row_h));
+            if !name.is_empty() {
+                draw(ui, r, name);
+            }
+            x += w * u;
+        }
+    }
+    let nav_x = origin.x + 15.5 * u;
+    for (ri, row) in NAV_ROWS.iter().enumerate() {
+        let y = origin.y + ri as f32 * row_h + if ri > 0 { u * 0.15 } else { 0.0 };
+        for (name, off) in row.iter() {
+            draw(ui, Rect::from_min_size(pos2(nav_x + off * u, y), vec2(u, row_h)), name);
+        }
+    }
+    let ed = &mut app.shortcut_editor;
+    if let Some(m) = toggled {
+        match m {
+            "Shift" => ed.mods.shift = !ed.mods.shift,
+            "Alt" => ed.mods.alt = !ed.mods.alt,
+            "Cmd" => ed.mods.cmd = !ed.mods.cmd,
+            _ => ed.mods.ctrl = !ed.mods.ctrl,
+        }
+    }
+    if let Some(k) = clicked_key {
+        ed.key = Some(k);
+    }
+}
+
+fn legend(ui: &mut egui::Ui, t: &Tokens) {
+    ui.horizontal(|ui| {
+        for (c, text) in [
+            (APP_KEY, "Application shortcuts work whatever panel has focus"),
+            (PANEL_KEY, "Panel shortcuts override application shortcuts while that panel has focus"),
+            (MOD_KEY, "Modifier held / selected"),
+        ] {
+            let (r, _) = ui.allocate_exact_size(vec2(14.0, 14.0), Sense::hover());
+            ui.painter().rect_filled(r, 2.0, c);
+            ui.label(RichText::new(text).size(12.0).color(t.text_dim));
+            ui.add_space(14.0);
+        }
+    });
+}
+
+fn command_list(app: &mut FilmcraftApp, ui: &mut egui::Ui, height: f32, t: &Tokens) {
+    let plat = Platform::current();
+    ui.horizontal(|ui| {
+        let mut q = app.shortcut_editor.search.clone();
+        let r = ui.add(egui::TextEdit::singleline(&mut q).hint_text("Search commands or keys").desired_width(320.0));
+        app.auto.add("shortcuts.search", r.rect, "Search");
+        app.shortcut_editor.search = q;
+        if let Some(sel) = app.shortcut_editor.selected.clone() {
+            ui.label(RichText::new(format!("Selected: {}", label_of(app, &sel))).size(12.0).color(t.text_dim));
+        }
+    });
+    ui.add_space(4.0);
+    let rows = app.session.execute("shortcuts.list", json!({"query": app.shortcut_editor.search})).unwrap_or_default();
+    let rows = rows.as_array().cloned().unwrap_or_default();
+    let w = ui.available_width();
+    // column header
+    let (hr, _) = ui.allocate_exact_size(vec2(w, 22.0), Sense::hover());
+    ui.painter().text(hr.left_center() + vec2(8.0, 0.0), Align2::LEFT_CENTER, "Command", Tokens::semibold(12.5), t.text_dim);
+    ui.painter().text(pos2(hr.min.x + w * 0.58, hr.center().y), Align2::LEFT_CENTER, "Shortcut", Tokens::semibold(12.5), t.text_dim);
+    egui::ScrollArea::vertical().id_salt("shortcuts-list").max_height(height - 50.0).auto_shrink([false, false]).show(ui, |ui| {
+        let mut last_cat = String::new();
+        for (i, row) in rows.iter().enumerate() {
+            let id = row["id"].as_str().unwrap_or("").to_string();
+            let cat = row["category"].as_str().unwrap_or("").to_string();
+            if cat != last_cat {
+                let (cr, _) = ui.allocate_exact_size(vec2(w, 22.0), Sense::hover());
+                let c = cr.left_center() + vec2(9.0, 0.0);
+                ui.painter().add(egui::Shape::convex_polygon(vec![c + vec2(-4.0, -2.5), c + vec2(4.0, -2.5), c + vec2(0.0, 3.0)], t.text_dim, Stroke::NONE));
+                ui.painter().text(cr.left_center() + vec2(20.0, 0.0), Align2::LEFT_CENTER, &cat, Tokens::semibold(12.0), t.text);
+                last_cat = cat;
+            }
+            let (r, resp) = ui.allocate_exact_size(vec2(w, 26.0), Sense::click());
+            let selected = app.shortcut_editor.selected.as_deref() == Some(id.as_str());
+            let bg = if selected {
+                t.row_selected
+            } else if i % 2 == 0 {
+                t.app_bg
+            } else {
+                t.row_alt
+            };
+            ui.painter().rect_filled(r, 0.0, bg);
+            ui.painter().text(r.left_center() + vec2(22.0, 0.0), Align2::LEFT_CENTER, row["label"].as_str().unwrap_or(""), Tokens::ui(12.5), t.text);
+            app.auto.add(&format!("shortcuts.row.{id}"), r, row["label"].as_str().unwrap_or(""));
+            if resp.clicked() {
+                app.shortcut_editor.selected = Some(id.clone());
+            }
+            // shortcut cell: click to record (replace); "+" adds another
+            let cell = Rect::from_min_max(pos2(r.min.x + w * 0.58, r.min.y + 2.0), pos2(r.max.x - 34.0, r.max.y - 2.0));
+            let recording = app.shortcut_editor.recording.as_ref().is_some_and(|(c, _)| *c == id);
+            let text = if recording {
+                "Type a shortcut… (Esc cancels)".to_string()
+            } else {
+                row["shortcuts"]
+                    .as_array()
+                    .into_iter()
+                    .flatten()
+                    .map(|b| {
+                        let d = b["display"].as_str().unwrap_or("").to_string();
+                        match b["panel"].as_str() {
+                            Some(pn) => format!("{d} ({pn})"),
+                            None => d,
+                        }
+                    })
+                    .collect::<Vec<_>>()
+                    .join(",  ")
+            };
+            let cresp = ui.interact(cell, egui::Id::new(("shortcut-cell", &id)), Sense::click());
+            if recording {
+                ui.painter().rect(cell, 3.0, t.field_bg, Stroke::new(1.5, t.accent), StrokeKind::Inside);
+            } else if cresp.hovered() {
+                ui.painter().rect_stroke(cell, 3.0, Stroke::new(1.0, t.field_border), StrokeKind::Inside);
+            }
+            ui.painter().text(cell.left_center() + vec2(6.0, 0.0), Align2::LEFT_CENTER, &text, Tokens::ui(12.5), if recording { t.accent } else { t.hot_text });
+            app.auto.add(&format!("shortcuts.cell.{id}"), cell, &text);
+            if cresp.clicked() {
+                app.shortcut_editor.selected = Some(id.clone());
+                app.shortcut_editor.recording = Some((id.clone(), false));
+            }
+            let plus = Rect::from_min_size(pos2(r.max.x - 30.0, r.min.y + 3.0), vec2(20.0, 20.0));
+            let presp = ui.interact(plus, egui::Id::new(("shortcut-add", &id)), Sense::click()).on_hover_text("Add another shortcut");
+            ui.painter().text(
+                plus.center(),
+                Align2::CENTER_CENTER,
+                "+",
+                Tokens::semibold(14.0),
+                if presp.hovered() { t.tab_text_active } else { t.text_faint },
+            );
+            app.auto.add(&format!("shortcuts.add.{id}"), plus, "Add shortcut");
+            if presp.clicked() {
+                app.shortcut_editor.selected = Some(id.clone());
+                app.shortcut_editor.recording = Some((id.clone(), true));
+            }
+        }
+        if rows.is_empty() {
+            ui.label(RichText::new("No matching commands").color(t.text_dim));
+        }
+    });
+    let _ = plat;
+}
+
+fn key_detail(app: &mut FilmcraftApp, ui: &mut egui::Ui, height: f32, t: &Tokens) {
+    let plat = Platform::current();
+    let key = app.shortcut_editor.key.clone();
+    ui.horizontal(|ui| {
+        ui.label(RichText::new("Key:").size(13.0).strong().color(t.text));
+        if let Some(k) = &key {
+            ui.label(RichText::new(key_legend(k, plat.is_mac())).size(13.0).color(t.hot_text));
+        }
+    });
+    let (hr, _) = ui.allocate_exact_size(vec2(ui.available_width(), 22.0), Sense::hover());
+    ui.painter().text(hr.left_center() + vec2(8.0, 0.0), Align2::LEFT_CENTER, "Modifiers", Tokens::semibold(12.5), t.text_dim);
+    ui.painter().text(hr.left_center() + vec2(110.0, 0.0), Align2::LEFT_CENTER, "Command", Tokens::semibold(12.5), t.text_dim);
+    let list = key.as_ref().and_then(|k| app.session.execute("shortcuts.forKey", json!({"key": k})).ok()).unwrap_or_default();
+    egui::ScrollArea::vertical().id_salt("shortcuts-key").max_height(height - 90.0).auto_shrink([false, false]).show(ui, |ui| {
+        let w = ui.available_width();
+        for (i, b) in list.as_array().into_iter().flatten().enumerate() {
+            let (r, _) = ui.allocate_exact_size(vec2(w, 24.0), Sense::hover());
+            ui.painter().rect_filled(r, 0.0, if i % 2 == 0 { t.app_bg } else { t.row_alt });
+            let keys = b["keys"].as_str().unwrap_or("");
+            let mods = Chord::parse(keys).map(|c| {
+                let k = Chord { mods: c.mods, key: c.key };
+                let d = k.display(plat);
+                let legend = key_legend(c.key, plat.is_mac());
+                let m = d.trim_end_matches(&legend).trim_end_matches(c.key).trim_end_matches('+').to_string();
+                if m.is_empty() { "None".to_string() } else { m }
+            });
+            ui.painter().text(r.left_center() + vec2(8.0, 0.0), Align2::LEFT_CENTER, mods.unwrap_or_default(), Tokens::ui(12.5), t.text);
+            let cmd = b["command"].as_str().unwrap_or("");
+            let label = match b["panel"].as_str() {
+                Some(p) => format!("{} ({p})", label_of(app, cmd)),
+                None => label_of(app, cmd),
+            };
+            ui.painter().text(r.left_center() + vec2(110.0, 0.0), Align2::LEFT_CENTER, label, Tokens::ui(12.5), t.text);
+        }
+        if key.is_some() && list.as_array().is_none_or(|a| a.is_empty()) {
+            ui.label(RichText::new("Nothing is assigned to this key").color(t.text_dim));
+        }
+        if key.is_none() {
+            ui.label(RichText::new("Click a key on the keyboard to see its shortcuts").color(t.text_dim));
+        }
+    });
+    // assign the selected command to the clicked key with the selected modifiers
+    if let (Some(k), Some(cmd)) = (key, app.shortcut_editor.selected.clone()) {
+        let keys = format!("{}{}", app.shortcut_editor.mods.prefix(), k);
+        let disp = Chord::parse(&keys).map(|c| c.display(plat)).unwrap_or(keys.clone());
+        let label = format!("Assign {disp} to {}", label_of(app, &cmd));
+        if small_button(app, ui, "shortcuts.assignKey", &label, true) {
+            assign(app, &cmd, &keys, false);
+        }
+    }
+}
+
+/// Bottom row: messages / conflicts, Undo / Redo / Clear, Cancel / OK. Returns Some(ok) to close.
+fn footer(app: &mut FilmcraftApp, ui: &mut egui::Ui, t: &Tokens) -> Option<bool> {
+    let plat = Platform::current();
+    let conflicts = app.session.shortcuts.conflicts(plat);
+    let mut close = None;
+    ui.horizontal(|ui| {
+        ui.vertical(|ui| {
+            ui.set_width(ui.available_width() - 420.0);
+            for (ctx, keys, cmds) in conflicts.iter().take(2) {
+                let disp = Chord::parse(keys).map(|c| c.display(plat)).unwrap_or(keys.clone());
+                let names: Vec<String> = cmds.iter().map(|c| label_of(app, c)).collect();
+                let r = ui.label(RichText::new(format!("Conflict: {disp} is assigned to {} ({ctx})", names.join(" and "))).size(12.0).color(WARN));
+                app.auto.add("shortcuts.conflict", r.rect, "conflict");
+            }
+            let msg = if app.shortcut_editor.message.is_empty() {
+                "Click a command's Shortcut cell and press keys to assign it; + adds another shortcut.".to_string()
+            } else {
+                app.shortcut_editor.message.clone()
+            };
+            let r = ui.label(RichText::new(msg.clone()).size(12.0).color(t.text_dim));
+            app.auto.add("shortcuts.message", r.rect, &msg);
+        });
+        ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+            let ok =
+                ui.add(egui::Button::new(RichText::new("OK").size(13.0).color(Color32::WHITE)).fill(t.accent).min_size(vec2(72.0, 28.0)).corner_radius(14.0));
+            app.auto.add("shortcuts.ok", ok.rect, "OK");
+            if ok.clicked() {
+                close = Some(true);
+            }
+            let cancel = ui.add(egui::Button::new(RichText::new("Cancel").size(13.0)).min_size(vec2(72.0, 28.0)).corner_radius(14.0));
+            app.auto.add("shortcuts.cancel", cancel.rect, "Cancel");
+            if cancel.clicked() {
+                close = Some(false);
+            }
+            ui.add_space(16.0);
+            let sel = app.shortcut_editor.selected.clone();
+            let panel = app.shortcut_editor.panel().map(str::to_string);
+            if small_button(app, ui, "shortcuts.clear", "Clear", sel.is_some())
+                && let Some(c) = sel
+                && let Some(r) = exec(app, "shortcuts.clear", json!({"command": c, "panel": panel.clone().unwrap_or_else(|| APPLICATION.into())}))
+            {
+                app.shortcut_editor.message = format!("Cleared {} shortcut(s) of {}", r["removed"], label_of(app, &c));
+            }
+            let (cu, cr) = (app.session.shortcuts.can_undo(), app.session.shortcuts.can_redo());
+            if small_button(app, ui, "shortcuts.redo", "Redo", cr) {
+                exec(app, "shortcuts.redo", json!({}));
+            }
+            if small_button(app, ui, "shortcuts.undo", "Undo", cu) {
+                exec(app, "shortcuts.undo", json!({}));
+            }
+        });
+    });
+    close
+}
diff --git a/crates/ui-egui/src/panels/timeline.rs b/crates/ui-egui/src/panels/timeline.rs
index 2170471fd..da05c234a 100644
--- a/crates/ui-egui/src/panels/timeline.rs
+++ b/crates/ui-egui/src/panels/timeline.rs
@@ -253,6 +253,8 @@ pub fn show(app: &mut FilmcraftApp, ui: &mut egui::Ui, rect: Rect) {
                 draw_clip(app, &ctx, &p, body, it, r.kind, true, &t, rate);
             }
         }
+        // selected edit points (trim mode): red brackets for ripple, yellow for roll / regular trim
+        super::trim_monitor::paint_edit_points(app, &p, &seq, tr, r, &layout);
         // transitions
         for trn in &tr.transitions {
             let x0 = layout.x_of(trn.start);
@@ -343,6 +345,8 @@ pub fn show(app: &mut FilmcraftApp, ui: &mut egui::Ui, rect: Rect) {
 
     // ---- interaction
     interact(app, ui, &seq, &layout, rect);
+    // track keyframes (drawn and edited on top of the clips)
+    super::timeline_automation::show(app, ui, &seq, &layout, aclip);
     if cap_n > 0 {
         super::timeline_captions::interact(app, ui, &seq, caption_area, &layout);
     }
@@ -744,6 +748,8 @@ fn draw_headers(app: &mut FilmcraftApp, ui: &mut egui::Ui, seq: &Sequence, rows:
             }
             let vr = small(x + 42.0, upper_y);
             crate::widgets::icon_toggle(ui, vr.intersect(visible), Icon::Mic, true, t, egui::Id::new(("vo", r.track.0)), Some(t.text_dim));
+            let kr = small(x + 64.0, upper_y);
+            super::timeline_automation::header_button(app, ui, seq, r, kr, visible, &label, t);
         }
         // 5. name on the lower line (or inline when short)
         if hrect.height() >= 40.0 {
@@ -1280,6 +1286,22 @@ fn interact(app: &mut FilmcraftApp, ui: &mut egui::Ui, seq: &Sequence, layout: &
                 let _ = app.session.execute("timeline.select", json!({"clips": ids}));
                 None
             }
+            (Tool::Selection | Tool::Ripple | Tool::Rolling, Hit::Clip { clip, edge: Some(edge), .. }) if resp.clicked() => {
+                // click an edge = select it as an edit point (trim mode); Shift adds
+                let kind = if tool == Tool::Rolling || (mods.command && mods.shift) {
+                    "roll"
+                } else if tool == Tool::Ripple || mods.command {
+                    "ripple"
+                } else {
+                    "trim"
+                };
+                let e = if edge == filmcraft_edit::Edge::In { "in" } else { "out" };
+                let r = app.session.execute("trim.selectEditPoint", json!({"clip": clip.0, "edge": e, "kind": kind, "add": mods.shift && !mods.command}));
+                if let Err(e) = r {
+                    app.ui.status = e.to_string();
+                }
+                None
+            }
             (Tool::Selection | Tool::Ripple | Tool::Rolling | Tool::RateStretch, Hit::Clip { clip, edge: Some(edge), track }) => {
                 let tr = seq.track(track).expect("track");
                 let mode = if tool == Tool::Ripple || (tool == Tool::Selection && mods.command) {
@@ -1331,6 +1353,7 @@ fn interact(app: &mut FilmcraftApp, ui: &mut egui::Ui, seq: &Sequence, layout: &
                     Some(Drag::Marquee { start: p })
                 } else {
                     app.session.state.selection.clear();
+                    app.session.state.edit_points.clear();
                     None
                 }
             }
diff --git a/crates/ui-egui/src/panels/timeline_automation.rs b/crates/ui-egui/src/panels/timeline_automation.rs
new file mode 100644
index 000000000..e34e6c254
--- /dev/null
+++ b/crates/ui-egui/src/panels/timeline_automation.rs
@@ -0,0 +1,240 @@
+//! Track keyframes in the timeline.
+//!
+//! An audio track can show one of its automation lanes (Volume, Panner, Mute, send levels, insert
+//! parameters) instead of clip keyframes: the header's keyframe button picks it (Premiere's
+//! "Show Keyframes ▸ Track Keyframes"). The lane is drawn across the whole track as a line with
+//! keyframe diamonds; the Pen tool (or ⌘-click) adds keyframes, dragging a diamond moves it in time
+//! and value, right-click deletes. Everything goes through `mixer.setKeyframe` /
+//! `mixer.moveKeyframe` / `mixer.deleteKeyframe`.
+//!
+//! Automation ids: `timeline.track.A1.keyframes` (the header button) with its menu entries
+//! (`timeline.track.A1.keyframes.<lane>`, `….clip`), `timeline.track.A1.lane` (the band) and
+//! `timeline.track.A1.lane.kf.<n>` (the diamonds).
+
+use egui::{Align2, Color32, CursorIcon, Rect, Sense, Stroke, pos2, vec2};
+use filmcraft_project::mixer::{LANE_MUTE, LANE_PAN, LANE_VOLUME, lane_info, parse_fx_lane, send_lane};
+use filmcraft_project::{ParamKind, Sequence, Track, TrackKind};
+use filmcraft_time::Tick;
+use serde_json::json;
+
+use super::timeline::{Layout, Row};
+use crate::FilmcraftApp;
+use crate::icons::{self, Icon};
+use crate::state::Tool;
+use crate::theme::Tokens;
+
+const LANE_COL: Color32 = Color32::from_rgb(0xe8, 0xc5, 0x47);
+
+/// The lanes an audio track can show: (key, label).
+pub fn lane_options(tr: &Track) -> Vec<(String, String)> {
+    let mut v =
+        vec![(LANE_VOLUME.to_string(), "Volume".to_string()), (LANE_PAN.to_string(), "Panner".to_string()), (LANE_MUTE.to_string(), "Mute".to_string())];
+    for (i, s) in tr.mixer.sends.iter().enumerate() {
+        let _ = s;
+        v.push((send_lane(i), format!("Send {} Level", i + 1)));
+    }
+    for (slot, e) in tr.effects.iter().enumerate() {
+        let Some(def) = e.def() else { continue };
+        for p in def.params.iter().filter(|p| matches!(p.kind, ParamKind::Float { .. }) && p.animatable) {
+            v.push((filmcraft_project::mixer::fx_lane(slot, p.id), format!("{}: {}", def.name, p.label)));
+        }
+    }
+    v
+}
+
+/// Value range of a lane: (min, max, hold).
+fn range(tr: &Track, key: &str) -> (f64, f64, bool) {
+    if let Some(i) = lane_info(key) {
+        return (i.min, i.max, i.hold);
+    }
+    if let Some((slot, pid)) = parse_fx_lane(key)
+        && let Some(ParamKind::Float { soft_min, soft_max, .. }) = tr.effects.get(slot).and_then(|e| e.def()).and_then(|d| d.param(pid)).map(|p| p.kind.clone())
+    {
+        return (soft_min, soft_max, false);
+    }
+    (0.0, 1.0, false)
+}
+
+/// 0 (bottom) … 1 (top) for a value.
+fn norm(tr: &Track, key: &str, v: f64) -> f32 {
+    if key == LANE_VOLUME || key.starts_with("send.") {
+        return super::mixer::db_to_pos(v);
+    }
+    let (lo, hi, _) = range(tr, key);
+    (((v - lo) / (hi - lo).max(1e-9)) as f32).clamp(0.0, 1.0)
+}
+
+fn denorm(tr: &Track, key: &str, n: f32) -> f64 {
+    if key == LANE_VOLUME || key.starts_with("send.") {
+        return super::mixer::pos_to_db(n);
+    }
+    let (lo, hi, hold) = range(tr, key);
+    let v = lo + (hi - lo) * n.clamp(0.0, 1.0) as f64;
+    if hold { v.round() } else { v }
+}
+
+/// The stored automation (shown even when the strip's mode is Off).
+fn lane_at(tr: &Track, key: &str, t: Tick) -> f64 {
+    match tr.lane(key).filter(|p| p.is_animated()) {
+        Some(p) if range(tr, key).2 => {
+            let i = p.keyframes.partition_point(|k| k.time <= t);
+            p.keyframes[i.saturating_sub(1)].value.as_f64().unwrap_or(0.0)
+        }
+        Some(p) => p.scalar_at(t),
+        None => tr.lane_static(key).unwrap_or(0.0),
+    }
+}
+
+fn band(r: &Row) -> Rect {
+    Rect::from_min_max(pos2(r.rect.min.x, r.rect.min.y + 17.0), pos2(r.rect.max.x, r.rect.max.y - 4.0))
+}
+
+/// Header button (diamond) choosing clip keyframes or a track lane.
+#[allow(clippy::too_many_arguments)]
+pub fn header_button(app: &mut FilmcraftApp, ui: &mut egui::Ui, seq: &Sequence, r: &Row, rect: Rect, visible: Rect, label: &str, t: &Tokens) {
+    let Some(tr) = seq.track(r.track) else { return };
+    let showing = app.ui.timeline.track_lanes.get(&r.track.0).cloned();
+    let resp =
+        crate::widgets::icon_toggle(ui, rect.intersect(visible), Icon::Keyframe, showing.is_some(), t, egui::Id::new(("lanebtn", r.track.0)), Some(LANE_COL))
+            .on_hover_text("Show Keyframes");
+    app.auto.add(&format!("timeline.track.{label}.keyframes"), rect, "Show Keyframes");
+    let opts = lane_options(tr);
+    egui::Popup::menu(&resp).show(|ui| {
+        ui.set_min_width(170.0);
+        let c = ui.selectable_label(showing.is_none(), "Clip Keyframes");
+        app.auto.add(&format!("timeline.track.{label}.keyframes.clip"), c.rect, "Clip Keyframes");
+        if c.clicked() {
+            app.ui.timeline.track_lanes.remove(&r.track.0);
+        }
+        ui.separator();
+        ui.label(egui::RichText::new("Track Keyframes").small());
+        for (k, l) in &opts {
+            let e = ui.selectable_label(showing.as_deref() == Some(k.as_str()), l);
+            app.auto.add(&format!("timeline.track.{label}.keyframes.{k}"), e.rect, l);
+            if e.clicked() {
+                app.ui.timeline.track_lanes.insert(r.track.0, k.clone());
+            }
+        }
+    });
+}
+
+#[derive(Clone, Copy)]
+struct KfDrag {
+    track: u64,
+    index: usize,
+    orig: Tick,
+    /// pointer offset at grab
+    grab: egui::Vec2,
+}
+
+fn drag_id() -> egui::Id {
+    egui::Id::new("tl-lane-kf-drag")
+}
+
+/// Draw the shown lanes (after clips) and handle their editing (after the timeline's own interaction,
+/// so keyframes sit on top).
+pub fn show(app: &mut FilmcraftApp, ui: &mut egui::Ui, seq: &Sequence, layout: &Layout, aclip: Rect) {
+    if app.ui.timeline.track_lanes.is_empty() {
+        return;
+    }
+    let rows: Vec<Row> = layout.rows.iter().filter(|r| r.kind == TrackKind::Audio).cloned().collect();
+    let drag: Option<KfDrag> = ui.data(|d| d.get_temp(drag_id()));
+    let pointer = ui.input(|i| i.pointer.interact_pos());
+    let mut acts: Vec<(&str, serde_json::Value)> = Vec::new();
+    for r in &rows {
+        let Some(key) = app.ui.timeline.track_lanes.get(&r.track.0).cloned() else { continue };
+        let Some(tr) = seq.track(r.track) else { continue };
+        if !lane_options(tr).iter().any(|(k, _)| *k == key) {
+            continue;
+        }
+        let label = format!("A{}", r.index + 1);
+        let b = band(r);
+        let vis = b.intersect(aclip).intersect(layout.content);
+        if vis.height() <= 2.0 {
+            continue;
+        }
+        let p = ui.painter().with_clip_rect(vis.expand2(vec2(0.0, 5.0)).intersect(aclip));
+        let y_of = |v: f64| b.max.y - norm(tr, &key, v) * b.height();
+        // the curve
+        let mut pts = Vec::new();
+        let mut x = vis.min.x;
+        while x <= vis.max.x + 2.0 {
+            pts.push(pos2(x, y_of(lane_at(tr, &key, layout.tick_at(x)))));
+            x += 2.0;
+        }
+        p.add(egui::Shape::line(pts.iter().map(|q| *q + vec2(0.0, 1.0)).collect(), Stroke::new(1.0, Color32::BLACK)));
+        p.add(egui::Shape::line(pts, Stroke::new(1.5, LANE_COL)));
+        let name = lane_options(tr).into_iter().find(|(k, _)| *k == key).map(|(_, l)| l).unwrap_or_default();
+        p.text(pos2(vis.max.x - 4.0, b.min.y + 1.0), Align2::RIGHT_TOP, &name, Tokens::ui(9.5), LANE_COL.gamma_multiply(0.85));
+        app.auto.add(&format!("timeline.track.{label}.lane"), vis, &format!("{name} track keyframes"));
+        // add keyframes: Pen tool, or ⌘-click with any tool
+        let adding = app.ui.tool == Tool::Pen || ui.input(|i| i.modifiers.command);
+        if adding {
+            let bresp = ui.interact(vis, egui::Id::new(("lane-band", r.track.0)), Sense::click());
+            if bresp.hovered() {
+                ui.ctx().set_cursor_icon(CursorIcon::Crosshair);
+            }
+            if bresp.clicked()
+                && let Some(pp) = pointer
+            {
+                let tt = layout.tick_at(pp.x).max(Tick::ZERO);
+                let n = ((b.max.y - pp.y) / b.height()).clamp(0.0, 1.0);
+                acts.push(("mixer.setKeyframe", json!({"strip": r.track.0, "lane": key, "time": tt.0, "value": denorm(tr, &key, n)})));
+            }
+        }
+        // keyframe diamonds
+        let kfs = tr.lane_keyframes(&key).to_vec();
+        for (i, k) in kfs.iter().enumerate() {
+            let v = k.value.as_f64().unwrap_or(0.0);
+            let mut c = pos2(layout.x_of(k.time), y_of(v));
+            let dragging = drag.filter(|d| d.track == r.track.0 && d.index == i);
+            if let (Some(d), Some(pp)) = (dragging, pointer) {
+                c = pp - d.grab;
+                c.y = c.y.clamp(b.min.y, b.max.y);
+            }
+            if c.x < vis.min.x - 6.0 || c.x > vis.max.x + 6.0 {
+                continue;
+            }
+            let hr = Rect::from_center_size(c, vec2(11.0, 11.0));
+            let resp = ui.interact(hr, egui::Id::new(("lane-kf", r.track.0, i)), Sense::click_and_drag());
+            let hot = resp.hovered() || dragging.is_some();
+            icons::paint(&p, Rect::from_center_size(c, vec2(9.0, 9.0)), Icon::Keyframe, if hot { Color32::WHITE } else { LANE_COL });
+            app.auto.add(&format!("timeline.track.{label}.lane.kf.{i}"), hr, &format!("{name} keyframe {v:.1}"));
+            if resp.drag_started()
+                && let Some(pp) = pointer
+            {
+                ui.data_mut(|d| d.insert_temp(drag_id(), KfDrag { track: r.track.0, index: i, orig: k.time, grab: pp - c }));
+            }
+            if resp.drag_stopped()
+                && let Some(d) = dragging
+            {
+                let nt = layout.tick_at(c.x).max(Tick::ZERO);
+                let nv = denorm(tr, &key, ((b.max.y - c.y) / b.height()).clamp(0.0, 1.0));
+                acts.push(("mixer.moveKeyframe", json!({"strip": r.track.0, "lane": key, "time": d.orig.0, "newTime": nt.0, "value": nv})));
+                ui.data_mut(|dd| dd.remove::<KfDrag>(drag_id()));
+            }
+            if dragging.is_some() {
+                let nv = denorm(tr, &key, ((b.max.y - c.y) / b.height()).clamp(0.0, 1.0));
+                egui::Tooltip::always_open(ui.ctx().clone(), ui.layer_id(), egui::Id::new("lane-kf-tip"), egui::PopupAnchor::Pointer).show(|ui| {
+                    ui.label(if key == LANE_VOLUME { format!("{nv:.2} dB") } else { format!("{nv:.2}") });
+                });
+            }
+            let time = k.time;
+            let key2 = key.clone();
+            resp.context_menu(|ui| {
+                if ui.button("Delete").clicked() {
+                    acts.push(("mixer.deleteKeyframe", json!({"strip": r.track.0, "lane": key2, "time": time.0})));
+                    ui.close();
+                }
+            });
+        }
+    }
+    if drag.is_some() && !ui.input(|i| i.pointer.any_down()) {
+        ui.data_mut(|d| d.remove::<KfDrag>(drag_id()));
+    }
+    for (id, p) in acts {
+        if let Err(e) = app.session.execute(id, p) {
+            app.ui.status = e.to_string();
+        }
+    }
+}
diff --git a/crates/ui-egui/src/panels/trim_monitor.rs b/crates/ui-egui/src/panels/trim_monitor.rs
new file mode 100644
index 000000000..92b5e836b
--- /dev/null
+++ b/crates/ui-egui/src/panels/trim_monitor.rs
@@ -0,0 +1,336 @@
+//! The Trim Monitor: while edit points are selected (trim mode) the Program monitor shows the
+//! outgoing clip's last frame and the incoming clip's first frame side by side, with their
+//! timecodes, the Out/In shift counters and the trim buttons (−N, −1, Apply Default Transitions,
+//! +1, +N; N = Preferences ▸ Trim ▸ Large Trim Offset). Dragging in the outgoing picture trims the
+//! outgoing side, in the incoming picture the incoming side, between them rolls.
+//!
+//! J/K/L and Space are routed to dynamic trimming / loop playback in `menus::invoke`; the engine
+//! state machine (`filmcraft_engine::trim`) is advanced here once per frame with the UI clock.
+//!
+//! Automation ids: `trimMonitor.outgoing`, `trimMonitor.incoming`, `trimMonitor.roll`,
+//! `trimMonitor.outTimecode`, `trimMonitor.inTimecode`, `trimMonitor.outShift`,
+//! `trimMonitor.inShift`, `trimMonitor.backwardMany`, `trimMonitor.backward`,
+//! `trimMonitor.applyTransition`, `trimMonitor.forward`, `trimMonitor.forwardMany`,
+//! `trimMonitor.playAround`, `trimMonitor.exit`.
+
+use egui::{Align2, Color32, Rect, Sense, Stroke, StrokeKind, pos2, vec2};
+use filmcraft_project::{ItemKind, Sequence, Track};
+use filmcraft_time::{Tick, TimeDisplay, format_time};
+use serde_json::{Value, json};
+
+use crate::FilmcraftApp;
+use crate::frames::{FrameKey, Target};
+use crate::icons::{self, Icon};
+use crate::panels::timeline::{Layout, Row};
+use crate::theme::Tokens;
+
+/// Ripple edit points are red, roll / regular trims yellow (as in Premiere's timeline).
+pub const RIPPLE_RED: Color32 = Color32::from_rgb(0xe5, 0x3e, 0x3e);
+pub const ROLL_YELLOW: Color32 = Color32::from_rgb(0xf2, 0xc4, 0x3d);
+
+/// True when J/K/L/Space should drive trim mode instead of normal playback.
+pub fn trim_mode(app: &FilmcraftApp) -> bool {
+    !app.session.state.edit_points.is_empty() && app.ui.focused != crate::dock::PanelKind::Source
+}
+
+/// Advance dynamic trimming / loop playback to the current UI time (once per frame).
+pub fn advance(app: &mut FilmcraftApp, ctx: &egui::Context) {
+    if !app.session.trim_play.active() {
+        return;
+    }
+    let clock = ctx.input(|i| i.time);
+    if let Err(e) = app.session.execute("trim.tick", json!({"clock": clock})) {
+        app.ui.status = e.to_string();
+    }
+    ctx.request_repaint();
+}
+
+/// Route a transport command in trim mode (J/K/L/Space/Shift+K). `None` = not handled.
+pub fn route_transport(app: &mut FilmcraftApp, ctx: &egui::Context, id: &str) -> Option<Result<Value, String>> {
+    let clock = ctx.input(|i| i.time);
+    let trimming = trim_mode(app);
+    let (cmd, params) = match id {
+        "playback.forward" if trimming => ("trim.shuttle", json!({"direction": "forward", "clock": clock})),
+        "playback.reverse" if trimming => ("trim.shuttle", json!({"direction": "reverse", "clock": clock})),
+        "playback.slowForward" if trimming => ("trim.shuttle", json!({"direction": "forward", "slow": true, "clock": clock})),
+        "playback.slowReverse" if trimming => ("trim.shuttle", json!({"direction": "reverse", "slow": true, "clock": clock})),
+        "playback.stop" if app.session.trim_play.active() => ("trim.shuttleStop", json!({"clock": clock})),
+        "playback.toggle" if trimming || app.session.trim_play.around.is_some() => ("trim.playAround", json!({"clock": clock, "toggle": true})),
+        "playback.playAround" => ("trim.playAround", json!({"clock": clock, "loop": false})),
+        _ => return None,
+    };
+    app.stop();
+    Some(app.session.execute(cmd, params).map_err(|e| e.to_string()))
+}
+
+/// Paint the selected edit points that sit on `tr` as brackets at the clip edges.
+pub fn paint_edit_points(app: &FilmcraftApp, p: &egui::Painter, seq: &Sequence, tr: &Track, row: &Row, layout: &Layout) {
+    use filmcraft_engine::trim::{TrimKind, roll_pair};
+    for ep in &app.session.state.edit_points {
+        let mut marks = Vec::new(); // (clip on this track, out edge)
+        if ep.kind == TrimKind::Roll
+            && let Some((l, r)) = roll_pair(seq, ep)
+        {
+            marks.push((l, true));
+            marks.push((r, false));
+        } else {
+            marks.push((ep.clip, ep.out));
+        }
+        let col = if ep.kind == TrimKind::Ripple { RIPPLE_RED } else { ROLL_YELLOW };
+        for (clip, out) in marks {
+            let Some(it) = tr.item(clip) else { continue };
+            let x = layout.x_of(if out { it.end() } else { it.start });
+            let (y0, y1) = (row.rect.min.y + 2.0, row.rect.max.y - 2.0);
+            let dir = if out { -1.0 } else { 1.0 };
+            let xi = x + dir * 1.5;
+            let w = 6.0 * dir;
+            let s = Stroke::new(3.0, col);
+            p.line_segment([pos2(xi, y0), pos2(xi, y1)], s);
+            p.line_segment([pos2(xi, y0 + 1.0), pos2(xi + w, y0 + 1.0)], s);
+            p.line_segment([pos2(xi, y1 - 1.0), pos2(xi + w, y1 - 1.0)], s);
+        }
+    }
+}
+
+/// Fit a w×h picture into `area`.
+fn fit(area: Rect, w: f32, h: f32) -> Rect {
+    let s = (area.width() / w.max(1.0)).min(area.height() / h.max(1.0));
+    Rect::from_center_size(area.center(), vec2(w * s, h * s))
+}
+
+/// Draw one side's frame (the clip's media at `media_time`).
+fn picture(app: &mut FilmcraftApp, ui: &mut egui::Ui, area: Rect, side: &Value, tex_name: &str) -> Rect {
+    let t = app.tokens;
+    let item = filmcraft_project::ItemId(side["item"].as_u64().unwrap_or(0));
+    let Some(pi) = app.session.project.item(item) else { return area };
+    let size = match &pi.kind {
+        ItemKind::Media(m) => m.info.video.as_ref().map(|v| (v.width, v.height)).unwrap_or((0, 0)),
+        ItemKind::Sequence(s) => (s.settings.width, s.settings.height),
+        _ => (1920, 1080),
+    };
+    let seq_size = app.session.active_sequence().map(|q| (q.settings.width, q.settings.height)).unwrap_or((1920, 1080));
+    let pic = fit(area, seq_size.0 as f32, seq_size.1 as f32);
+    ui.painter().rect_filled(pic, 0.0, t.monitor_bg);
+    if size.0 == 0 || !side["video"].as_bool().unwrap_or(false) {
+        ui.painter().text(pic.center(), Align2::CENTER_CENTER, format!("♪  {}", side["name"].as_str().unwrap_or("")), Tokens::ui(13.0), t.text_dim);
+        return pic;
+    }
+    let img_rect = fit(pic, size.0 as f32, size.1 as f32);
+    let rate = pi.frame_rate();
+    let media_time = Tick(side["mediaTime"].as_i64().unwrap_or(0));
+    let frame = rate.frame_at(media_time);
+    let ppp = ui.ctx().pixels_per_point();
+    let want = (img_rect.width() * ppp / size.0 as f32).clamp(1.0 / 32.0, 1.0);
+    let buckets = [1.0 / 32.0, 1.0 / 16.0, 1.0 / 8.0, 0.1875, 0.25, 0.375, 0.5, 0.75, 1.0];
+    let scale = *buckets.iter().find(|b| **b >= want - 1e-4).unwrap_or(&1.0);
+    let scale = scale.min(app.ui.program.res.scale());
+    let size_key = (scale * 1000.0) as u32;
+    let key = FrameKey { target: Target::Item(item), frame, size: size_key, revision: 0 };
+    let project = app.session.project.clone();
+    app.frames.request(key, rate.tick_of(frame), scale, &project, 0);
+    let ctx = ui.ctx().clone();
+    let tex = if let Some(img) = app.frames.get(&key) {
+        Some(app.texture_for(&ctx, tex_name, key, &img))
+    } else {
+        match app.frames.nearest(Target::Item(item), frame, size_key, 0, 48) {
+            Some(img) => Some(app.texture_for(&ctx, tex_name, FrameKey { frame: frame - 1, ..key }, &img)),
+            None => app.texture_existing(tex_name).map(|(id, _)| id),
+        }
+    };
+    if let Some(tex) = tex {
+        ui.painter().image(tex, img_rect, Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)), Color32::WHITE);
+    }
+    pic
+}
+
+fn shift_text(frames: i64) -> String {
+    if frames > 0 { format!("+{frames}") } else { frames.to_string() }
+}
+
+/// The two-up Trim Monitor in the Program monitor's `rect`.
+pub fn show(app: &mut FilmcraftApp, ui: &mut egui::Ui, rect: Rect) {
+    let t = app.tokens;
+    let info = filmcraft_engine::trim::monitor_info(&app.session);
+    let Some(seq) = app.session.active_sequence() else { return };
+    let rate = seq.settings.frame_rate;
+    let df = seq.settings.drop_frame;
+    ui.painter().rect_filled(rect, 0.0, t.panel_bg);
+    let controls_h = 26.0 + 40.0;
+    let header_h = 22.0;
+    let gap = 14.0;
+    let area = Rect::from_min_max(rect.min + vec2(6.0, 4.0 + header_h), pos2(rect.max.x - 6.0, rect.max.y - controls_h));
+    let half = (area.width() - gap) / 2.0;
+    let left = Rect::from_min_size(area.min, vec2(half, area.height()));
+    let right = Rect::from_min_size(pos2(left.max.x + gap, area.min.y), vec2(half, area.height()));
+    let kind = info["kind"].as_str().unwrap_or("trim").to_string();
+    let out_edge = info["edge"] == json!("out");
+    // which sides move: roll = both; otherwise the side the edit point belongs to
+    let (hot_out, hot_in) = match kind.as_str() {
+        "roll" => (true, true),
+        _ => (out_edge, !out_edge),
+    };
+    let col = if kind == "ripple" { RIPPLE_RED } else { ROLL_YELLOW };
+    // headers: clip names
+    for (side, r, key) in [(&info["outgoing"], left, "outgoing"), (&info["incoming"], right, "incoming")] {
+        let name = side["name"].as_str().map(|n| format!("{} ({})", n, side["track"].as_str().unwrap_or(""))).unwrap_or_else(|| "(gap)".into());
+        let label = if key == "outgoing" { format!("Out: {name}") } else { format!("In: {name}") };
+        ui.painter().text(pos2(r.min.x + 2.0, rect.min.y + 4.0 + header_h / 2.0), Align2::LEFT_CENTER, label, Tokens::ui(11.5), t.text_dim);
+    }
+    let mut pics = [left, right];
+    for (i, (side, r)) in [(&info["outgoing"], left), (&info["incoming"], right)].into_iter().enumerate() {
+        if side.is_null() {
+            let p = fit(r, 16.0, 9.0);
+            ui.painter().rect_filled(p, 0.0, Color32::BLACK);
+            ui.painter().text(p.center(), Align2::CENTER_CENTER, "(gap)", Tokens::ui(12.0), t.text_faint);
+            pics[i] = p;
+        } else {
+            pics[i] = picture(app, ui, r, side, if i == 0 { "trim-outgoing" } else { "trim-incoming" });
+        }
+    }
+    let [lp, rp] = pics;
+    let hot = [hot_out, hot_in];
+    for (i, p) in pics.iter().enumerate() {
+        if hot[i] {
+            ui.painter().rect_stroke(*p, 0.0, Stroke::new(2.0, col), StrokeKind::Outside);
+        }
+    }
+    // dynamic trim indicator
+    if let Some(d) = info["dynamic"].as_object() {
+        let sp = d.get("speed").and_then(Value::as_f64).unwrap_or(0.0);
+        let txt = if sp == 0.0 {
+            "TRIM ■".to_string()
+        } else if sp > 0.0 {
+            format!("TRIM ▶ {sp}×")
+        } else {
+            format!("TRIM ◀ {}×", -sp)
+        };
+        let at = pos2((lp.max.x + rp.min.x) / 2.0, area.min.y + 12.0);
+        ui.painter().text(at, Align2::CENTER_CENTER, txt, Tokens::semibold(11.0), col);
+    }
+    app.auto.add("trimMonitor.outgoing", lp, "Outgoing clip (drag to trim the Out point)");
+    app.auto.add("trimMonitor.incoming", rp, "Incoming clip (drag to trim the In point)");
+    let mid = Rect::from_min_max(pos2(lp.max.x, area.min.y), pos2(rp.min.x, area.max.y));
+    app.auto.add("trimMonitor.roll", mid, "Drag to roll the edit");
+
+    // drag to trim: px → frames (6 px per frame), applied on release as one trim
+    let fpp = 1.0 / 6.0;
+    for (r, which) in [(lp, "out"), (rp, "in"), (mid, "roll")] {
+        let resp = ui.interact(r, egui::Id::new(("trim-monitor-drag", which)), Sense::drag());
+        if resp.dragged() || resp.hovered() {
+            ui.ctx().set_cursor_icon(egui::CursorIcon::ResizeColumn);
+        }
+        if resp.dragged() {
+            let total = ui.ctx().data_mut(|d| {
+                let v = d.get_temp_mut_or_default::<f32>(egui::Id::new("trim-monitor-dx"));
+                *v += resp.drag_delta().x;
+                *v
+            });
+            let n = (total * fpp).round() as i64;
+            ui.painter().text(pos2(r.center().x, r.max.y - 14.0), Align2::CENTER_CENTER, shift_text(n), Tokens::semibold(14.0), col);
+        }
+        if resp.drag_stopped() {
+            let total = ui.ctx().data_mut(|d| d.remove_temp::<f32>(egui::Id::new("trim-monitor-dx")).unwrap_or(0.0));
+            let n = (total * fpp).round() as i64;
+            if n != 0 {
+                drag_trim(app, which, n);
+            }
+        }
+    }
+
+    // ---- counters row: outgoing Out timecode + shift | incoming In timecode + shift
+    let row = Rect::from_min_size(pos2(rect.min.x + 10.0, area.max.y + 2.0), vec2(rect.width() - 20.0, 24.0));
+    let tc = |v: &Value, k: &str| v[k].as_i64().map(|x| format_time(Tick(x), rate, df, TimeDisplay::Timecode, 48000)).unwrap_or_else(|| "--:--:--:--".into());
+    let out_tc = tc(&info["outgoing"], "time");
+    let in_tc = tc(&info["incoming"], "time");
+    let out_shift = shift_text(info["outShift"].as_i64().unwrap_or(0));
+    let in_shift = shift_text(info["inShift"].as_i64().unwrap_or(0));
+    let p = ui.painter();
+    let tcr = p.text(pos2(lp.min.x, row.center().y), Align2::LEFT_CENTER, &out_tc, Tokens::semibold(14.0), t.hot_text);
+    app.auto.add("trimMonitor.outTimecode", tcr, &out_tc);
+    let sr = p.text(pos2(lp.max.x, row.center().y), Align2::RIGHT_CENTER, &out_shift, Tokens::semibold(14.0), if hot_out { col } else { t.text_dim });
+    app.auto.add("trimMonitor.outShift", sr, &out_shift);
+    let sr = p.text(pos2(rp.min.x, row.center().y), Align2::LEFT_CENTER, &in_shift, Tokens::semibold(14.0), if hot_in { col } else { t.text_dim });
+    app.auto.add("trimMonitor.inShift", sr, &in_shift);
+    let tcr = p.text(pos2(rp.max.x, row.center().y), Align2::RIGHT_CENTER, &in_tc, Tokens::semibold(14.0), t.hot_text);
+    app.auto.add("trimMonitor.inTimecode", tcr, &in_tc);
+
+    // ---- trim buttons
+    let n = info["largeTrimOffset"].as_i64().unwrap_or(5);
+    let bar = Rect::from_min_size(pos2(rect.min.x, row.max.y + 6.0), vec2(rect.width(), 28.0));
+    let buttons: [(&str, String, &str, f32); 6] = [
+        ("trimMonitor.playAround", String::new(), "Play Around Edit (Space loops, Shift+K once)", 30.0),
+        ("trimMonitor.backwardMany", format!("−{n}"), "Trim Backward Many", 40.0),
+        ("trimMonitor.backward", "−1".into(), "Trim Backward", 40.0),
+        ("trimMonitor.applyTransition", "Apply Default Transitions".into(), "Apply Default Transitions to Selection (Shift+D)", 176.0),
+        ("trimMonitor.forward", "+1".into(), "Trim Forward", 40.0),
+        ("trimMonitor.forwardMany", format!("+{n}"), "Trim Forward Many", 40.0),
+    ];
+    let total: f32 = buttons.iter().map(|b| b.3 + 4.0).sum();
+    let mut x = bar.center().x - total / 2.0;
+    let ctx = ui.ctx().clone();
+    for (id, label, tip, w) in buttons {
+        let r = Rect::from_min_size(pos2(x, bar.min.y), vec2(w, bar.height()));
+        let resp = ui.interact(r, egui::Id::new(id), Sense::click()).on_hover_text(tip);
+        let bg = if resp.is_pointer_button_down_on() {
+            t.pressed
+        } else if resp.hovered() {
+            t.hover
+        } else {
+            t.field_bg
+        };
+        ui.painter().rect_filled(r, 4.0, bg);
+        if label.is_empty() {
+            let playing = app.session.trim_play.around.is_some();
+            icons::paint(ui.painter(), Rect::from_center_size(r.center(), vec2(14.0, 14.0)), if playing { Icon::Pause } else { Icon::Loop }, t.icon);
+        } else {
+            ui.painter().text(r.center(), Align2::CENTER_CENTER, &label, Tokens::ui(12.0), t.text);
+        }
+        app.auto.add(id, r, tip);
+        if resp.clicked() {
+            let res = match id {
+                "trimMonitor.playAround" => app.session.execute("trim.playAround", json!({"clock": ctx.input(|i| i.time), "toggle": true})),
+                "trimMonitor.backwardMany" => app.session.execute("trim.backwardMany", json!({})),
+                "trimMonitor.backward" => app.session.execute("trim.backward", json!({})),
+                "trimMonitor.forward" => app.session.execute("trim.forward", json!({})),
+                "trimMonitor.forwardMany" => app.session.execute("trim.forwardMany", json!({})),
+                _ => app.session.execute("trim.applyDefaultTransition", json!({})),
+            };
+            if let Err(e) = res {
+                app.ui.status = e.to_string();
+            }
+        }
+        x += w + 4.0;
+    }
+    // exit trim mode
+    let r = Rect::from_min_size(pos2(rect.max.x - 30.0, bar.min.y + 3.0), vec2(22.0, 22.0));
+    let resp = ui.interact(r, egui::Id::new("trimMonitor.exit"), Sense::click()).on_hover_text("Exit Trim Mode");
+    let c = if resp.hovered() { t.tab_text_active } else { t.text_dim };
+    ui.painter().line_segment([r.min + vec2(6.0, 6.0), r.max - vec2(6.0, 6.0)], Stroke::new(1.5, c));
+    ui.painter().line_segment([pos2(r.max.x - 6.0, r.min.y + 6.0), pos2(r.min.x + 6.0, r.max.y - 6.0)], Stroke::new(1.5, c));
+    app.auto.add("trimMonitor.exit", r, "Exit Trim Mode");
+    if resp.clicked() {
+        let _ = app.session.execute("trim.clear", json!({}));
+    }
+}
+
+/// A drag in the Trim Monitor: re-target the primary edit point to the dragged side, then trim.
+fn drag_trim(app: &mut FilmcraftApp, which: &str, frames: i64) {
+    use filmcraft_engine::trim::{TrimKind, sides};
+    let Some(seq) = app.session.active_sequence() else { return };
+    let Some(ep) = app.session.state.edit_points.first().copied() else { return };
+    let (out_c, in_c) = sides(seq, &ep);
+    let target = match which {
+        "out" => out_c.map(|c| (c, "out", if ep.kind == TrimKind::Roll { TrimKind::Ripple } else { ep.kind })),
+        "in" => in_c.map(|c| (c, "in", if ep.kind == TrimKind::Roll { TrimKind::Ripple } else { ep.kind })),
+        _ => out_c.or(in_c).map(|c| (c, if out_c.is_some() { "out" } else { "in" }, TrimKind::Roll)),
+    };
+    let Some((clip, edge, kind)) = target else { return };
+    let multi = app.session.state.edit_points.len() > 1;
+    if !multi && (clip != ep.clip || (edge == "out") != ep.out || kind != ep.kind) {
+        let kind = serde_json::to_value(kind).unwrap_or(json!("trim"));
+        let _ = app.session.execute("trim.selectEditPoint", json!({"clip": clip.0, "edge": edge, "kind": kind}));
+    }
+    if let Err(e) = app.session.execute("trim.nudge", json!({"frames": frames})) {
+        app.ui.status = e.to_string();
+    }
+}
diff --git a/crates/ui-egui/src/state.rs b/crates/ui-egui/src/state.rs
index 983cf7747..d90aeaadb 100644
--- a/crates/ui-egui/src/state.rs
+++ b/crates/ui-egui/src/state.rs
@@ -185,6 +185,10 @@ pub struct TimelineView {
     /// Follow playhead during playback (page scroll).
     pub follow: bool,
     pub fit_pending: bool,
+    /// Audio tracks showing track keyframes instead of clip keyframes: track id → lane
+    /// (`volume`, `pan`, `mute`, `send.<i>.level`, `fx.<slot>.<param>`).
+    #[serde(default)]
+    pub track_lanes: std::collections::BTreeMap<u64, String>,
 }
 
 impl Default for TimelineView {
@@ -204,6 +208,7 @@ impl Default for TimelineView {
             show_waveforms: true,
             follow: true,
             fit_pending: true,
+            track_lanes: Default::default(),
         }
     }
 }
@@ -275,6 +280,40 @@ pub struct UiState {
     /// Preferences ▸ Playback: play the rendered range when a preview render finishes.
     #[serde(default = "yes")]
     pub play_after_render: bool,
+    /// Audio Track Mixer: effects and sends section expanded.
+    #[serde(default)]
+    pub mixer_fx_open: bool,
+    /// Audio Gain dialog draft (mode, dB values).
+    #[serde(default)]
+    pub audio_gain: AudioGainDraft,
+    /// On-monitor text editing (Type tool / double-click on a text layer).
+    #[serde(default)]
+    pub gfx_edit: Option<GfxEdit>,
+    /// Pen tool: path points placed so far (sequence pixels).
+    #[serde(default)]
+    pub pen_points: Vec<[f64; 2]>,
+}
+
+/// The Audio Gain dialog (Clip ▸ Audio Gain…, G).
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+#[serde(default)]
+pub struct AudioGainDraft {
+    /// "set" | "adjust" | "normalizeMax" | "normalizeAll"
+    pub mode: String,
+    pub set_db: f64,
+    pub adjust_db: f64,
+    pub max_peak_db: f64,
+    pub all_peaks_db: f64,
+}
+
+/// The text layer being edited on the Program monitor: caret and selection anchor are byte
+/// offsets into the layer's text.
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+pub struct GfxEdit {
+    pub clip: u64,
+    pub layer: usize,
+    pub caret: usize,
+    pub anchor: usize,
 }
 
 fn captions_tab() -> String {
@@ -313,6 +352,10 @@ impl Default for UiState {
             text_tab: captions_tab(),
             caption_search: String::new(),
             play_after_render: true,
+            mixer_fx_open: false,
+            audio_gain: AudioGainDraft::default(),
+            gfx_edit: None,
+            pen_points: vec![],
         }
     }
 }
diff --git a/crates/ui-egui/src/theme.rs b/crates/ui-egui/src/theme.rs
index 5c548ac95..9f938841a 100644
--- a/crates/ui-egui/src/theme.rs
+++ b/crates/ui-egui/src/theme.rs
@@ -193,10 +193,10 @@ impl Tokens {
 /// Install fonts (Inter, Inter SemiBold, JetBrains Mono) and egui visuals.
 pub fn install(ctx: &egui::Context, t: &Tokens) {
     let mut fonts = FontDefinitions::default();
-    fonts.font_data.insert("inter".into(), Arc::new(FontData::from_static(include_bytes!("../../../assets/fonts/Inter-Regular.ttf"))));
-    fonts.font_data.insert("inter-medium".into(), Arc::new(FontData::from_static(include_bytes!("../../../assets/fonts/Inter-Medium.ttf"))));
-    fonts.font_data.insert("inter-semibold".into(), Arc::new(FontData::from_static(include_bytes!("../../../assets/fonts/Inter-SemiBold.ttf"))));
-    fonts.font_data.insert("jbmono".into(), Arc::new(FontData::from_static(include_bytes!("../../../assets/fonts/JetBrainsMono-Regular.ttf"))));
+    fonts.font_data.insert("inter".into(), Arc::new(FontData::from_static(filmcraft_text::fonts::INTER_REGULAR)));
+    fonts.font_data.insert("inter-medium".into(), Arc::new(FontData::from_static(filmcraft_text::fonts::INTER_MEDIUM)));
+    fonts.font_data.insert("inter-semibold".into(), Arc::new(FontData::from_static(filmcraft_text::fonts::INTER_SEMIBOLD)));
+    fonts.font_data.insert("jbmono".into(), Arc::new(FontData::from_static(filmcraft_text::fonts::JETBRAINS_MONO_REGULAR)));
     fonts.families.entry(FontFamily::Proportional).or_default().insert(0, "inter".into());
     fonts.families.entry(FontFamily::Monospace).or_default().insert(0, "jbmono".into());
     fonts.families.insert(FontFamily::Name("semibold".into()), vec!["inter-semibold".into(), "inter".into()]);
diff --git a/crates/ui-egui/tests/graphics_ui.rs b/crates/ui-egui/tests/graphics_ui.rs
new file mode 100644
index 000000000..b866b9bfd
--- /dev/null
+++ b/crates/ui-egui/tests/graphics_ui.rs
@@ -0,0 +1,154 @@
+//! Graphics UI, driven headless through the control channel (like `scripted.rs`): the Type tool
+//! creates a text layer on the Program monitor, typing and keys edit it, the Properties panel's
+//! controls style it, the Selection tool moves it.
+//!
+//! With `FILMCRAFT_UI_SHOTS=<dir>` the test also renders the UI with wgpu (works without a
+//! window or an unlocked screen) and writes PNGs there for review.
+
+use std::sync::mpsc::{Sender, channel};
+
+use egui_kittest::Harness;
+use filmcraft_engine::Session;
+use filmcraft_ui_egui::FilmcraftApp;
+use filmcraft_ui_egui::control::ControlRequest;
+use serde_json::{Value, json};
+
+struct Driver {
+    harness: Harness<'static, FilmcraftApp>,
+    tx: Sender<ControlRequest>,
+    shots: Option<std::path::PathBuf>,
+}
+
+impl Driver {
+    fn demo() -> Self {
+        let mut session = Session::default();
+        session.execute("file.openDemoProject", json!({})).expect("demo project");
+        let (tx, rx) = channel();
+        let app = FilmcraftApp::new(session).with_control(rx);
+        let shots = std::env::var_os("FILMCRAFT_UI_SHOTS").map(std::path::PathBuf::from);
+        let mut b = Harness::builder().with_size(egui::vec2(1600.0, 980.0)).with_max_steps(10_000);
+        if shots.is_some() {
+            b = b.wgpu().with_pixels_per_point(1.0);
+        }
+        let harness = b.build_eframe(move |_cc| app);
+        let mut d = Driver { harness, tx, shots };
+        d.frames(4);
+        d
+    }
+    fn frames(&mut self, n: usize) {
+        for _ in 0..n {
+            let ctx = self.harness.ctx.clone();
+            let mut raw = std::mem::take(self.harness.input_mut());
+            eframe::App::raw_input_hook(self.harness.state_mut(), &ctx, &mut raw);
+            *self.harness.input_mut() = raw;
+            self.harness.step();
+        }
+    }
+    fn call(&mut self, method: &str, params: Value) -> Value {
+        let (req, reply) = ControlRequest::new(method, params.clone());
+        self.tx.send(req).unwrap();
+        for _ in 0..600 {
+            self.frames(1);
+            if let Ok(v) = reply.try_recv() {
+                return v;
+            }
+        }
+        panic!("no reply to {method} {params}");
+    }
+    fn ok(&mut self, method: &str, params: Value) -> Value {
+        let r = self.call(method, params.clone());
+        assert_eq!(r["ok"], true, "{method} {params}: {r}");
+        r["result"].clone()
+    }
+    fn exec(&mut self, command: &str, params: Value) -> Value {
+        self.ok("engine.execute", json!({"command": command, "params": params}))
+    }
+    fn rect(&mut self, id: &str) -> [f64; 4] {
+        let v = self.ok("ui.elements", json!({"prefix": id}));
+        let e = v.as_array().unwrap().iter().find(|e| e["id"] == id).unwrap_or_else(|| panic!("no element {id}: {v}")).clone();
+        let r: Vec<f64> = e["rect"].as_array().unwrap().iter().map(|x| x.as_f64().unwrap()).collect();
+        [r[0], r[1], r[2], r[3]]
+    }
+    fn shot(&mut self, name: &str) {
+        let Some(dir) = self.shots.clone() else { return };
+        self.frames(8);
+        let img = self.harness.render().expect("wgpu render");
+        std::fs::create_dir_all(&dir).unwrap();
+        img.save(dir.join(format!("{name}.png"))).unwrap();
+    }
+}
+
+#[test]
+fn type_tool_edit_style_and_move() {
+    let mut d = Driver::demo();
+    d.ok("ui.set", json!({"workspace": "Captions and Graphics"}));
+    d.exec("playhead.set", json!({"seconds": 2}));
+    d.ok("ui.set", json!({"tool": "Type"}));
+    d.frames(3);
+    let pic = d.rect("program.picture");
+    let (px, py) = (pic[0] + pic[2] * 0.2, pic[1] + pic[3] * 0.35);
+    d.ok("ui.click", json!({"x": px, "y": py}));
+    d.ok("ui.type", json!({"text": "Night Drive"}));
+    d.ok("ui.key", json!({"key": "Enter"}));
+    d.ok("ui.type", json!({"text": "through the city"}));
+    let list = d.exec("graphics.list", json!({}));
+    assert_eq!(list["layers"][0]["text"], "Night Drive\nthrough the city", "{list}");
+    // caret editing: Backspace ×4, select the word "Drive" with Shift+arrows… then retype
+    for _ in 0..4 {
+        d.ok("ui.key", json!({"key": "Backspace"}));
+    }
+    d.ok("ui.type", json!({"text": "town"}));
+    d.ok("ui.key", json!({"key": "ArrowUp"}));
+    d.ok("ui.key", json!({"key": "End"}));
+    for _ in 0..5 {
+        d.ok("ui.key", json!({"key": "Shift+ArrowLeft"}));
+    }
+    d.ok("ui.type", json!({"text": "Ride"}));
+    let list = d.exec("graphics.list", json!({}));
+    assert_eq!(list["layers"][0]["text"], "Night Ride\nthrough the town", "{list}");
+    // one undo step for the whole typing session (after "New Graphic")
+    let hist = d.exec("history.list", json!({}));
+    let undo: Vec<&str> = hist["undo"].as_array().unwrap().iter().filter_map(Value::as_str).collect();
+    assert_eq!(&undo[undo.len() - 2..], ["New Graphic", "Edit Text"], "{undo:?}");
+    d.shot("type-tool-editing");
+
+    // style through the Properties panel controls
+    d.ok("ui.key", json!({"key": "Escape"}));
+    d.ok("ui.set", json!({"tool": "Selection"}));
+    d.ok("ui.click", json!({"id": "graphics.prop.faux_bold"}));
+    d.ok("ui.click", json!({"id": "graphics.prop.align.1"}));
+    d.ok("ui.click", json!({"id": "graphics.prop.stroke"}));
+    d.ok("ui.click", json!({"id": "graphics.prop.shadow"}));
+    let clip = list["clip"].as_u64().unwrap();
+    d.exec("graphics.set", json!({"clip": clip, "props": {"font_style": "Bold", "fill_color": "#ffd23f", "size": 120}}));
+    let seq = d.exec("sequence.inspect", json!({}));
+    let s = seq.to_string();
+    assert!(s.contains("graphic_text"), "graphic layer in the sequence");
+    let list2 = d.exec("graphics.list", json!({"clip": clip}));
+    let q0 = list2["layers"][0]["quad"][0][0].as_f64().unwrap();
+    // selection-tool drag moves the layer
+    let lr = d.rect(&format!("program.layer.{clip}.0"));
+    let pic = d.rect("program.picture");
+    // a point on the layer that is inside the picture
+    let x0 = lr[0].max(pic[0]);
+    let x1 = (lr[0] + lr[2]).min(pic[0] + pic[2]);
+    let (cx, cy) = ((x0 + x1) / 2.0, lr[1] + lr[3] * 0.3);
+    let from = json!({"x": cx, "y": cy});
+    let to = json!({"x": cx + 60.0, "y": cy + 20.0});
+    d.ok("ui.drag", json!({"from": from, "to": to, "steps": 6}));
+    let list3 = d.exec("graphics.list", json!({"clip": clip}));
+    let q1 = list3["layers"][0]["quad"][0][0].as_f64().unwrap();
+    assert!(q1 > q0 + 20.0, "moved right: {q0} → {q1}");
+    d.shot("properties-styled");
+
+    // shapes: rectangle tool drag
+    d.ok("ui.set", json!({"tool": "Rectangle"}));
+    let pic = d.rect("program.picture");
+    d.ok("ui.drag", json!({"from": {"x": pic[0] + pic[2] * 0.15, "y": pic[1] + pic[3] * 0.75}, "to": {"x": pic[0] + pic[2] * 0.85, "y": pic[1] + pic[3] * 0.9}, "steps": 5}));
+    let list4 = d.exec("graphics.list", json!({"clip": clip}));
+    assert_eq!(list4["layers"].as_array().unwrap().len(), 2, "{list4}");
+    assert_eq!(list4["layers"][1]["kind"], "Rectangle");
+    d.exec("graphics.arrangeLayer", json!({"clip": clip, "layer": 1, "to": "back"}));
+    d.ok("ui.set", json!({"tool": "Selection"}));
+    d.shot("shape-layer");
+}
diff --git a/crates/ui-egui/tests/mixer_ui.rs b/crates/ui-egui/tests/mixer_ui.rs
new file mode 100644
index 000000000..dac7dbdd6
--- /dev/null
+++ b/crates/ui-egui/tests/mixer_ui.rs
@@ -0,0 +1,277 @@
+//! Headless UI tests of the Audio Track Mixer, Audio Clip Mixer and timeline track keyframes: the
+//! real `FilmcraftApp` under `egui_kittest`, driven by automation id and by frame-by-frame pointer
+//! input (a fader drag spans several frames, as with a mouse).
+//!
+//! Set `FILMCRAFT_UI_SNAPSHOT_DIR=<dir>` to also render the window offscreen with wgpu and write PNGs
+//! there (`mixer-*.png`); without it no GPU is needed.
+
+use std::sync::mpsc::{Sender, channel};
+
+use egui_kittest::Harness;
+use filmcraft_engine::Session;
+use filmcraft_ui_egui::FilmcraftApp;
+use filmcraft_ui_egui::control::ControlRequest;
+use serde_json::{Value, json};
+
+struct Driver {
+    harness: Harness<'static, FilmcraftApp>,
+    tx: Sender<ControlRequest>,
+    snapshots: Option<std::path::PathBuf>,
+}
+
+impl Driver {
+    fn demo() -> Self {
+        let mut session = Session::default();
+        session.execute("file.openDemoProject", json!({})).expect("demo project");
+        let (tx, rx) = channel();
+        let app = FilmcraftApp::new(session).with_control(rx);
+        let snapshots = std::env::var_os("FILMCRAFT_UI_SNAPSHOT_DIR").map(std::path::PathBuf::from);
+        let mut b = Harness::builder().with_size(egui::vec2(1600.0, 980.0)).with_max_steps(10_000);
+        if snapshots.is_some() {
+            b = b.wgpu();
+        }
+        let harness = b.build_eframe(move |_cc| app);
+        let mut d = Driver { harness, tx, snapshots };
+        d.frames(4);
+        d
+    }
+
+    fn frames(&mut self, n: usize) {
+        for _ in 0..n {
+            let ctx = self.harness.ctx.clone();
+            let mut raw = std::mem::take(self.harness.input_mut());
+            eframe::App::raw_input_hook(self.harness.state_mut(), &ctx, &mut raw);
+            *self.harness.input_mut() = raw;
+            self.harness.step();
+        }
+    }
+
+    fn call(&mut self, method: &str, params: Value) -> Value {
+        let (req, reply) = ControlRequest::new(method, params.clone());
+        self.tx.send(req).unwrap();
+        for _ in 0..600 {
+            self.frames(1);
+            if let Ok(v) = reply.try_recv() {
+                return v;
+            }
+        }
+        panic!("no reply to {method} {params}");
+    }
+
+    fn ok(&mut self, method: &str, params: Value) -> Value {
+        let v = self.call(method, params.clone());
+        assert_eq!(v["ok"], json!(true), "{method} {params} failed: {v}");
+        v["result"].clone()
+    }
+
+    fn exec(&mut self, command: &str, params: Value) -> Value {
+        self.ok("engine.execute", json!({"command": command, "params": params}))
+    }
+
+    fn click(&mut self, id: &str) {
+        self.ok("ui.click", json!({"id": id}));
+        self.frames(2);
+    }
+
+    fn element(&mut self, id: &str) -> Option<[f32; 4]> {
+        let v = self.ok("ui.elements", json!({"prefix": id}));
+        v.as_array()?.iter().find(|e| e["id"] == id).map(|e| {
+            let r = &e["rect"];
+            [r[0].as_f64().unwrap() as f32, r[1].as_f64().unwrap() as f32, r[2].as_f64().unwrap() as f32, r[3].as_f64().unwrap() as f32]
+        })
+    }
+
+    fn ids(&mut self, prefix: &str) -> Vec<String> {
+        let v = self.ok("ui.elements", json!({"prefix": prefix}));
+        v.as_array().unwrap().iter().filter_map(|e| e["id"].as_str().map(str::to_string)).collect()
+    }
+
+    /// Press on `id`, move `dy` pixels over several frames (calling `between` before each move),
+    /// release.
+    fn drag_frames(&mut self, id: &str, dy: f32, steps: usize, mut between: impl FnMut(&mut Self, usize)) {
+        let r = self.element(id).unwrap_or_else(|| panic!("no element {id}"));
+        let mut p = egui::pos2(r[0] + r[2] / 2.0, r[1] + r[3] / 2.0);
+        let push = |d: &mut Self, e: egui::Event| d.harness.input_mut().events.push(e);
+        push(self, egui::Event::PointerMoved(p));
+        self.frames(1);
+        push(self, egui::Event::PointerButton { pos: p, button: egui::PointerButton::Primary, pressed: true, modifiers: Default::default() });
+        self.frames(1);
+        for i in 0..steps {
+            between(self, i);
+            p.y += dy / steps as f32;
+            push(self, egui::Event::PointerMoved(p));
+            self.frames(1);
+        }
+        push(self, egui::Event::PointerButton { pos: p, button: egui::PointerButton::Primary, pressed: false, modifiers: Default::default() });
+        self.frames(2);
+    }
+
+    fn strip(&mut self, r: &str) -> Value {
+        let m = self.exec("mixer.inspect", json!({}));
+        m["strips"].as_array().unwrap().iter().find(|s| s["ref"] == r).cloned().unwrap_or(Value::Null)
+    }
+
+    /// Offscreen render of the window (or the bounding box of the elements under `prefix`).
+    fn snapshot(&mut self, name: &str, prefix: Option<&str>) {
+        let Some(dir) = self.snapshots.clone() else { return };
+        let crop = prefix.map(|p| {
+            let v = self.ok("ui.elements", json!({"prefix": p}));
+            let mut bb = [f32::MAX, f32::MAX, f32::MIN, f32::MIN];
+            for e in v.as_array().unwrap() {
+                let r = &e["rect"];
+                let (x, y, w, h) = (r[0].as_f64().unwrap() as f32, r[1].as_f64().unwrap() as f32, r[2].as_f64().unwrap() as f32, r[3].as_f64().unwrap() as f32);
+                bb = [bb[0].min(x), bb[1].min(y), bb[2].max(x + w), bb[3].max(y + h)];
+            }
+            bb
+        });
+        self.frames(2);
+        let img = match self.harness.render() {
+            Ok(i) => i,
+            Err(e) => {
+                eprintln!("snapshot {name} skipped: {e}");
+                return;
+            }
+        };
+        let ppp = img.width() as f32 / 1600.0;
+        let img = match crop {
+            Some(bb) => {
+                let x0 = ((bb[0] - 24.0) * ppp).max(0.0) as u32;
+                let y0 = ((bb[1] - 30.0) * ppp).max(0.0) as u32;
+                let x1 = (((bb[2] + 16.0) * ppp) as u32).min(img.width());
+                let y1 = (((bb[3] + 46.0) * ppp) as u32).min(img.height());
+                image::imageops::crop_imm(&img, x0, y0, x1 - x0, y1 - y0).to_image()
+            }
+            None => img,
+        };
+        std::fs::create_dir_all(&dir).unwrap();
+        let path = dir.join(format!("{name}.png"));
+        img.save(&path).unwrap();
+        eprintln!("snapshot: {}", path.display());
+    }
+}
+
+#[test]
+fn track_mixer_controls_by_id_and_by_drag() {
+    let mut d = Driver::demo();
+    d.ok("ui.set", json!({"workspace": "Audio"}));
+    d.frames(3);
+    let ids = d.ids("mixer.");
+    for id in [
+        "mixer.A1.fader",
+        "mixer.A1.pan",
+        "mixer.A1.mode",
+        "mixer.A1.mute",
+        "mixer.A1.solo",
+        "mixer.A1.record",
+        "mixer.A1.output",
+        "mixer.Mix.fader",
+        "mixer.showEffects",
+    ] {
+        assert!(ids.iter().any(|i| i == id), "{id} missing from {ids:?}");
+    }
+    // automation mode from the dropdown
+    d.click("mixer.A1.mode");
+    d.click("mixer.A1.mode.Touch");
+    assert_eq!(d.strip("A1")["mode"], "Touch");
+    // mute / solo buttons
+    d.click("mixer.A2.mute");
+    assert_eq!(d.strip("A2")["muted"], true);
+    d.click("mixer.A2.mute");
+    // a fader drag (stopped) is heard live while held and committed once on release
+    let undo0 = d.exec("history.list", json!({}))["undo"].as_array().unwrap().len();
+    d.drag_frames("mixer.A1.fader", 60.0, 6, |_, _| {});
+    let a1 = d.strip("A1");
+    assert!(a1["volumeDb"].as_f64().unwrap() < -3.0, "fader moved down: {a1}");
+    let undo = d.exec("history.list", json!({}))["undo"].as_array().unwrap().clone();
+    assert_eq!(undo.len(), undo0 + 1, "one undo step: {undo:?}");
+    // effects and sends
+    d.click("mixer.showEffects");
+    d.click("mixer.A1.fx.0");
+    d.click("mixer.A1.fx.0.studio_reverb");
+    assert_eq!(d.strip("A1")["inserts"][0]["effect"], "studio_reverb");
+    d.exec("mixer.addSubmix", json!({"name": "Reverb Bus"}));
+    d.frames(2);
+    d.click("mixer.A2.send.0");
+    d.click("mixer.A2.send.0.S1");
+    assert_eq!(d.strip("A2")["sends"][0]["target"], "S1");
+    let s1 = d.ids("mixer.S1.");
+    assert!(s1.iter().any(|i| i == "mixer.S1.fader"), "submix strip shown: {s1:?}");
+    d.snapshot("mixer-track-mixer-effects", Some("mixer."));
+}
+
+#[test]
+fn recording_a_touch_pass_from_the_fader() {
+    let mut d = Driver::demo();
+    d.ok("ui.set", json!({"workspace": "Audio"}));
+    d.frames(3);
+    d.exec("mixer.setStrip", json!({"strip": "A1", "mode": "Touch"}));
+    d.exec("playhead.set", json!({"seconds": 1.0}));
+    d.exec("mixer.recordStart", json!({}));
+    // the playhead advances while the fader is held (as during playback)
+    d.drag_frames("mixer.A1.fader", 80.0, 8, |d, i| {
+        d.exec("playhead.set", json!({"seconds": 1.0 + 0.1 * i as f64}));
+    });
+    let held_lanes = d.strip("A1")["lanes"].clone();
+    assert!(held_lanes.as_object().is_none_or(|m| m.is_empty()), "nothing written until the pass ends");
+    d.exec("playhead.set", json!({"seconds": 3.0}));
+    let r = d.exec("mixer.recordStop", json!({}));
+    assert_eq!(r["lanes"], 1, "{r}");
+    let a1 = d.strip("A1");
+    let kfs = a1["lanes"]["volume"].as_array().unwrap().clone();
+    assert!(kfs.len() >= 3, "{kfs:?}");
+    // the lane in the timeline: header button → Volume
+    d.click("timeline.track.A1.keyframes");
+    d.click("timeline.track.A1.keyframes.volume");
+    let ids = d.ids("timeline.track.A1.lane");
+    assert!(ids.iter().any(|i| i == "timeline.track.A1.lane"), "{ids:?}");
+    assert!(ids.iter().filter(|i| i.contains(".kf.")).count() >= 1, "diamonds: {ids:?}");
+    // the pen tool adds a keyframe on the lane
+    d.ok("ui.set", json!({"tool": "Pen"}));
+    d.frames(2);
+    let lane = d.element("timeline.track.A1.lane").unwrap();
+    d.ok("ui.click", json!({"x": lane[0] + lane[2] * 0.9, "y": lane[1] + lane[3] * 0.5}));
+    d.frames(3);
+    let n = d.strip("A1")["lanes"]["volume"].as_array().unwrap().len();
+    assert_eq!(n, kfs.len() + 1, "pen click adds a track keyframe");
+    d.ok("ui.set", json!({"tool": "Selection"}));
+    d.snapshot("mixer-timeline-track-keyframes", Some("timeline.track.A"));
+    d.snapshot("mixer-audio-workspace", None);
+}
+
+#[test]
+fn clip_mixer_strips_follow_the_playhead() {
+    let mut d = Driver::demo();
+    d.ok("ui.panel.show", json!({"panel": "AudioClipMixer"}));
+    d.frames(3);
+    let ids = d.ids("clipMixer.");
+    assert!(ids.iter().any(|i| i == "clipMixer.A1.fader"), "{ids:?}");
+    d.exec("playhead.set", json!({"seconds": 1.0}));
+    d.drag_frames("clipMixer.A1.fader", 40.0, 5, |_, _| {});
+    let seq = d.exec("sequence.inspect", json!({}));
+    let fx = &seq["audio"][0]["items"][0]["effects"];
+    let vol = fx.as_array().unwrap().iter().find(|e| e["effect"] == "volume").unwrap();
+    let level: f64 = vol["params"]["level"]["value"].as_str().and_then(|v| v.strip_prefix("Float(")?.strip_suffix(')')?.parse().ok()).unwrap();
+    assert!(level < -8.0, "clip volume lowered from the demo's -8 dB: {level}");
+    d.snapshot("mixer-clip-mixer", Some("clipMixer."));
+}
+
+#[test]
+fn audio_gain_dialog_normalizes_the_selection() {
+    let mut d = Driver::demo();
+    let seq = d.exec("sequence.inspect", json!({}));
+    let clip = seq["audio"][0]["items"][0]["clip"].as_u64().unwrap();
+    d.exec("timeline.select", json!({"clips": [clip]}));
+    let r = d.ok("ui.menu.invoke", json!({"id": "clip.audioGain"}));
+    assert_eq!(r["dialog"], "audioGain", "{r}");
+    d.frames(3);
+    let ids = d.ids("audioGain.");
+    for id in ["audioGain.set", "audioGain.adjust", "audioGain.normalizeMax", "audioGain.normalizeAll", "audioGain.ok", "audioGain.peak"] {
+        assert!(ids.iter().any(|i| i == id), "{id} missing: {ids:?}");
+    }
+    d.click("audioGain.normalizeMax");
+    d.snapshot("mixer-audio-gain-dialog", Some("audioGain."));
+    d.click("audioGain.ok");
+    let pk = d.exec("clip.audioPeak", json!({"clips": [clip]}));
+    assert!(pk["peakDb"].as_f64().unwrap().abs() < 1e-6, "normalized to 0 dB: {pk}");
+    assert!(d.ids("audioGain.").is_empty(), "dialog closed");
+}
diff --git a/crates/ui-egui/tests/scripted.rs b/crates/ui-egui/tests/scripted.rs
new file mode 100644
index 000000000..86d9cc4cd
--- /dev/null
+++ b/crates/ui-egui/tests/scripted.rs
@@ -0,0 +1,444 @@
+//! Scripted UI tests: the real `FilmcraftApp` runs headless under `egui_kittest` (no window, no
+//! GPU) and is driven through the same JSON control channel that agents use over TCP/MCP
+//! (`docs/control-protocol.md`). Each test opens the demo project, sends control requests
+//! (`engine.execute`, `ui.menu.invoke`, `ui.click`, `ui.inspect`, …) between frames and asserts on
+//! the replies and on `sequence.inspect` JSON.
+//!
+//! The harness steps egui frames itself: synthetic input queued by `ui.click`/`ui.key` is moved
+//! into the next frame's `RawInput` through the app's own `raw_input_hook`, exactly as eframe does.
+//! Screenshots (`ui.screenshot`) need a real viewport and are not covered here.
+
+use std::sync::mpsc::{Sender, channel};
+
+use egui_kittest::Harness;
+use filmcraft_engine::Session;
+use filmcraft_ui_egui::FilmcraftApp;
+use filmcraft_ui_egui::control::ControlRequest;
+use serde_json::{Value, json};
+
+struct Driver {
+    harness: Harness<'static, FilmcraftApp>,
+    tx: Sender<ControlRequest>,
+}
+
+impl Driver {
+    /// The app with the demo project open, after its first frames (theme and fonts installed).
+    fn demo() -> Self {
+        Self::demo_with(false)
+    }
+
+    /// `render`: with a wgpu renderer so `Harness::render` can take screenshots (needs a GPU).
+    fn demo_with(render: bool) -> Self {
+        let mut session = Session::default();
+        session.execute("file.openDemoProject", json!({})).expect("demo project");
+        let (tx, rx) = channel();
+        let app = FilmcraftApp::new(session).with_control(rx);
+        let mut b = Harness::builder().with_size(egui::vec2(1600.0, 980.0)).with_max_steps(10_000);
+        if render {
+            b = b.wgpu();
+        }
+        let harness = b.build_eframe(move |_cc| app);
+        let mut d = Driver { harness, tx };
+        d.frames(4);
+        d
+    }
+
+    /// Run `n` frames, feeding queued synthetic input like eframe's `raw_input_hook`.
+    fn frames(&mut self, n: usize) {
+        for _ in 0..n {
+            let ctx = self.harness.ctx.clone();
+            let mut raw = std::mem::take(self.harness.input_mut());
+            eframe::App::raw_input_hook(self.harness.state_mut(), &ctx, &mut raw);
+            *self.harness.input_mut() = raw;
+            self.harness.step();
+        }
+    }
+
+    /// Send a control request and run frames until it is answered.
+    fn call(&mut self, method: &str, params: Value) -> Value {
+        let (req, reply) = ControlRequest::new(method, params.clone());
+        self.tx.send(req).unwrap();
+        for _ in 0..600 {
+            self.frames(1);
+            if let Ok(v) = reply.try_recv() {
+                return v;
+            }
+        }
+        panic!("no reply to {method} {params}");
+    }
+
+    /// `call` that must succeed; returns `result`.
+    fn ok(&mut self, method: &str, params: Value) -> Value {
+        let v = self.call(method, params.clone());
+        assert_eq!(v["ok"], json!(true), "{method} {params} failed: {v}");
+        v["result"].clone()
+    }
+
+    fn exec(&mut self, command: &str, params: Value) -> Value {
+        self.ok("engine.execute", json!({"command": command, "params": params}))
+    }
+
+    fn sequence(&mut self) -> Value {
+        self.exec("sequence.inspect", json!({}))
+    }
+
+    fn inspect(&mut self) -> Value {
+        self.ok("ui.inspect", json!({}))
+    }
+
+    fn element_ids(&mut self, prefix: &str) -> Vec<String> {
+        let v = self.ok("ui.elements", json!({"prefix": prefix}));
+        v.as_array().unwrap().iter().filter_map(|e| e["id"].as_str().map(str::to_string)).collect()
+    }
+}
+
+/// Clips on a video track in `sequence.inspect` JSON.
+fn track_clips(seq: &Value, track: usize) -> Vec<Value> {
+    seq["video"][track]["items"].as_array().cloned().unwrap_or_default()
+}
+
+#[test]
+fn demo_project_opens_headless_and_registers_widgets() {
+    let mut d = Driver::demo();
+    let ui = d.inspect();
+    assert!(ui["activeSequence"].is_u64(), "demo sequence is active: {ui}");
+    assert!(ui["elements"].as_u64().unwrap() > 50, "widgets registered: {}", ui["elements"]);
+    let panels = d.element_ids("panel.");
+    for p in ["panel.Timeline", "panel.Program", "panel.Project", "panel.tab.Timeline"] {
+        assert!(panels.iter().any(|x| x == p), "{p} missing from {panels:?}");
+    }
+    let tools = d.element_ids("tools.");
+    assert!(tools.len() >= 5, "tool buttons: {tools:?}");
+    let seq = d.sequence();
+    assert_eq!(track_clips(&seq, 0).len(), 6, "demo V1 clips: {seq}");
+}
+
+#[test]
+fn razor_then_undo_through_the_control_channel() {
+    let mut d = Driver::demo();
+    let before = track_clips(&d.sequence(), 0).len();
+    d.exec("playhead.set", json!({"seconds": 2.0}));
+    let r = d.exec("timeline.razor", json!({"track": "V1"}));
+    assert_eq!(r["cuts"], json!(1), "{r}");
+    let after = track_clips(&d.sequence(), 0);
+    assert_eq!(after.len(), before + 1);
+    // the timeline shows the new clip on the next frame
+    d.frames(2);
+    let new_clip = after[1]["clip"].as_u64().unwrap();
+    let at = d.ok("ui.timeline.locate", json!({"clip": new_clip}));
+    assert!(at["x"].as_f64().is_some(), "{at}");
+    // Undo from the menu path (UI command dispatch), then Redo by shortcut-free command id.
+    d.ok("ui.menu.invoke", json!({"id": "edit.undo"}));
+    assert_eq!(track_clips(&d.sequence(), 0).len(), before);
+    d.exec("edit.redo", json!({}));
+    assert_eq!(track_clips(&d.sequence(), 0).len(), before + 1);
+}
+
+#[test]
+fn insert_from_source_ripples_the_sequence() {
+    let mut d = Driver::demo();
+    let project = d.exec("project.inspect", json!({}));
+    let item = first_media_item(&project).unwrap_or_else(|| panic!("no media item in {project}"));
+    let dur0 = d.sequence()["duration"].as_i64().unwrap();
+    d.exec("source.open", json!({"item": item}));
+    let rate = &d.sequence()["settings"]["frame_rate"];
+    let (num, den) = (rate["num"].as_i64().unwrap(), rate["den"].as_i64().unwrap());
+    let tick = |f: i64| f * 254_016_000_000 * den / num;
+    d.exec("project.setMarks", json!({"item": item, "in": tick(24), "out": tick(47)}));
+    d.exec("playhead.set", json!({"frame": 0}));
+    d.exec("source.insert", json!({}));
+    let dur1 = d.sequence()["duration"].as_i64().unwrap();
+    assert!(dur1 > dur0, "insert lengthens the sequence: {dur0} → {dur1}");
+    d.frames(2);
+}
+
+/// First movie item id anywhere in `project.inspect` JSON.
+fn first_media_item(v: &Value) -> Option<u64> {
+    match v {
+        Value::Object(m) => {
+            if let Some(id) = m.get("item").and_then(Value::as_u64)
+                && m.get("type").and_then(Value::as_str).is_some_and(|t| t == "Movie")
+            {
+                return Some(id);
+            }
+            m.values().find_map(first_media_item)
+        }
+        Value::Array(a) => a.iter().find_map(first_media_item),
+        _ => None,
+    }
+}
+
+#[test]
+fn apply_effect_appears_in_effect_controls() {
+    let mut d = Driver::demo();
+    let clip = track_clips(&d.sequence(), 0)[0]["clip"].as_u64().unwrap();
+    d.exec("timeline.select", json!({"clips": [clip]}));
+    d.exec("effects.apply", json!({"effect": "Gaussian Blur"}));
+    let seq = d.sequence();
+    let fx: Vec<String> = track_clips(&seq, 0)[0]["effects"].as_array().unwrap().iter().filter_map(|e| e["effect"].as_str().map(str::to_string)).collect();
+    assert!(fx.iter().any(|e| e == "gaussian_blur"), "{fx:?}");
+    d.ok("ui.panel.show", json!({"panel": "Effect Controls"}));
+    d.frames(3);
+    let ids = d.element_ids("effectControls.effect.");
+    assert!(ids.iter().any(|i| i == "effectControls.effect.gaussian_blur"), "{ids:?}");
+    d.ok("ui.menu.invoke", json!({"id": "edit.undo"}));
+    d.frames(2);
+    assert!(!d.element_ids("effectControls.effect.").iter().any(|i| i == "effectControls.effect.gaussian_blur"));
+}
+
+#[test]
+fn playback_toggle_and_stop() {
+    let mut d = Driver::demo();
+    assert_eq!(d.inspect()["playback"]["playing"], json!(false));
+    let r = d.ok("ui.menu.invoke", json!({"id": "playback.toggle"}));
+    assert_eq!(r["playing"], json!(true), "{r}");
+    d.frames(5);
+    assert_eq!(d.inspect()["playback"]["playing"], json!(true));
+    let r = d.ok("ui.playback", json!({"action": "stop"}));
+    assert_eq!(r["playing"], json!(false), "{r}");
+    assert_eq!(d.inspect()["playback"]["playing"], json!(false));
+}
+
+#[test]
+fn clicking_a_tool_button_by_automation_id() {
+    let mut d = Driver::demo();
+    assert_ne!(d.inspect()["ui"]["tool"], json!("Razor"));
+    d.ok("ui.click", json!({"id": "tools.Razor"}));
+    d.frames(2);
+    let ui = d.inspect();
+    assert_eq!(ui["ui"]["tool"], json!("Razor"), "{}", ui["ui"]["tool"]);
+    d.ok("ui.set", json!({"tool": "selection"}));
+    assert_eq!(d.inspect()["ui"]["tool"], json!("Selection"));
+}
+
+#[test]
+fn unknown_methods_and_commands_fail_cleanly() {
+    let mut d = Driver::demo();
+    let v = d.call("ui.nope", json!({}));
+    assert_eq!(v["ok"], json!(false));
+    let v = d.call("engine.execute", json!({"command": "no.such.command"}));
+    assert_eq!(v["ok"], json!(false));
+}
+
+/// End of the first V1 clip (ticks).
+fn first_cut(d: &mut Driver) -> (u64, i64) {
+    let c = &track_clips(&d.sequence(), 0)[0];
+    (c["clip"].as_u64().unwrap(), c["start"].as_i64().unwrap() + c["duration"].as_i64().unwrap())
+}
+
+#[test]
+fn trim_monitor_buttons_and_dynamic_jkl_trimming() {
+    let mut d = Driver::demo();
+    for t in ["V2", "V3", "A2", "A3"] {
+        d.exec("timeline.setTrack", json!({"track": t, "syncLock": false}));
+    }
+    let (clip, cut) = first_cut(&mut d);
+    let fd = {
+        let rate = &d.sequence()["settings"]["frame_rate"];
+        254_016_000_000 * rate["den"].as_i64().unwrap() / rate["num"].as_i64().unwrap()
+    };
+    // Selecting an edit point turns the Program monitor into the Trim Monitor.
+    assert!(d.element_ids("trimMonitor.").is_empty());
+    d.exec("trim.selectEditPoint", json!({"clip": clip, "edge": "out", "kind": "roll"}));
+    d.frames(3);
+    let ids = d.element_ids("trimMonitor.");
+    for id in [
+        "trimMonitor.outgoing",
+        "trimMonitor.incoming",
+        "trimMonitor.outShift",
+        "trimMonitor.inShift",
+        "trimMonitor.forward",
+        "trimMonitor.backwardMany",
+        "trimMonitor.applyTransition",
+    ] {
+        assert!(ids.iter().any(|x| x == id), "{id} missing from {ids:?}");
+    }
+    // +1 button rolls the cut one frame
+    d.ok("ui.click", json!({"id": "trimMonitor.forward"}));
+    d.frames(2);
+    assert_eq!(first_cut(&mut d).1, cut + fd);
+    let info = d.exec("trim.monitor", json!({}));
+    assert_eq!(info["outShift"], json!(1), "{info}");
+    let undo0 = d.exec("history.list", json!({}))["undo"].as_array().unwrap().len();
+
+    // L starts a dynamic trim; the edit moves while frames run; K commits one undo step.
+    d.ok("ui.key", json!({"key": "L"}));
+    d.frames(4);
+    let live = d.exec("trim.monitor", json!({}));
+    assert!(live["dynamic"]["offsetFrames"].as_i64().unwrap() > 0, "trimming live: {live}");
+    assert_eq!(d.exec("history.list", json!({}))["undo"].as_array().unwrap().len(), undo0, "no undo steps while trimming");
+    d.ok("ui.key", json!({"key": "K"}));
+    d.frames(2);
+    let after = first_cut(&mut d).1;
+    assert!(after > cut + fd, "the cut moved later: {cut} -> {after}");
+    let hist = d.exec("history.list", json!({}));
+    let undo = hist["undo"].as_array().unwrap();
+    assert_eq!(undo.len(), undo0 + 1, "{hist}");
+    assert_eq!(undo.last().unwrap(), &json!("Dynamic Rolling Edit"));
+    assert!(d.exec("trim.monitor", json!({}))["dynamic"].is_null());
+    // J trims backward
+    d.ok("ui.key", json!({"key": "J"}));
+    d.frames(2);
+    d.ok("ui.key", json!({"key": "K"}));
+    d.frames(1);
+    assert!(first_cut(&mut d).1 < after, "J trimmed backward");
+    // Undo twice: back to the +1 state, then Space loops around the edit
+    d.ok("ui.menu.invoke", json!({"id": "edit.undo"}));
+    d.ok("ui.menu.invoke", json!({"id": "edit.undo"}));
+    assert_eq!(first_cut(&mut d).1, cut + fd);
+    d.ok("ui.key", json!({"key": "Space"}));
+    d.frames(2);
+    assert!(d.exec("trim.monitor", json!({}))["playAround"].is_object());
+    d.ok("ui.key", json!({"key": "Space"}));
+    d.frames(1);
+    assert!(d.exec("trim.monitor", json!({}))["playAround"].is_null());
+    // exit trim mode: the normal Program monitor returns
+    d.ok("ui.click", json!({"id": "trimMonitor.exit"}));
+    d.frames(2);
+    assert!(d.element_ids("trimMonitor.").is_empty());
+    assert!(d.element_ids("program.").iter().any(|x| x == "program.picture"));
+}
+
+impl Driver {
+    /// Let background frame workers deliver, then render the window to `<tmp>/<name>.png`.
+    fn screenshot(&mut self, name: &str) -> std::path::PathBuf {
+        for _ in 0..30 {
+            std::thread::sleep(std::time::Duration::from_millis(40));
+            self.frames(1);
+        }
+        let img = self.harness.render().expect("render");
+        let png = filmcraft_ui_egui::control::encode_png(img.as_raw(), img.width(), img.height()).expect("png");
+        let dir = std::path::PathBuf::from(env!("CARGO_TARGET_TMPDIR")).join("ui-screenshots");
+        std::fs::create_dir_all(&dir).unwrap();
+        let path = dir.join(format!("{name}.png"));
+        std::fs::write(&path, png).unwrap();
+        eprintln!("screenshot: {}", path.display());
+        path
+    }
+}
+
+/// Renders the Trim Monitor and the Keyboard Shortcuts dialog to PNGs for visual review (needs a
+/// GPU): `cargo test -p filmcraft-ui-egui --test scripted -- --ignored screenshots`.
+#[test]
+#[ignore]
+fn screenshots() {
+    let mut d = Driver::demo_with(true);
+    for t in ["V2", "V3", "A2", "A3"] {
+        d.exec("timeline.setTrack", json!({"track": t, "syncLock": false}));
+    }
+    d.exec("playhead.set", json!({"seconds": 4.5}));
+    d.exec("trim.selectNearest", json!({"kind": "rippleOut"}));
+    d.exec("trim.forwardMany", json!({}));
+    d.screenshot("trim-monitor-ripple");
+    d.exec("trim.toggleType", json!({}));
+    d.ok("ui.key", json!({"key": "L"}));
+    d.frames(3);
+    d.screenshot("trim-monitor-dynamic-roll");
+    d.ok("ui.key", json!({"key": "K"}));
+    d.frames(2);
+    d.exec("trim.clear", json!({}));
+    // Keyboard Shortcuts dialog: Premiere-compatible preset, Timeline panel context, key K selected
+    d.ok("ui.key", json!({"key": "Cmd+Alt+K"}));
+    d.frames(2);
+    d.screenshot("shortcuts-dialog");
+    d.ok("ui.click", json!({"id": "shortcuts.context"}));
+    d.frames(2);
+    d.ok("ui.click", json!({"id": "shortcuts.context.Timeline"}));
+    d.ok("ui.click", json!({"id": "shortcuts.key.K"}));
+    d.ok("ui.click", json!({"id": "shortcuts.search"}));
+    d.ok("ui.type", json!({"text": "trim"}));
+    d.frames(2);
+    d.screenshot("shortcuts-dialog-timeline-trim");
+    d.ok("ui.click", json!({"id": "shortcuts.mod.Cmd"}));
+    d.frames(2);
+    d.screenshot("shortcuts-dialog-cmd");
+}
+
+#[test]
+fn keyboard_shortcuts_dialog_assigns_live_and_cancel_restores() {
+    let mut d = Driver::demo();
+    let menu_shortcut = |d: &mut Driver, id: &str| -> Value {
+        let items = d.ok("ui.menu.list", json!({}));
+        items.as_array().unwrap().iter().find(|i| i["id"] == id).map(|i| i["shortcut"].clone()).unwrap_or(Value::Null)
+    };
+    assert_eq!(menu_shortcut(&mut d, "sequence.addEdit"), json!("Cmd+K"));
+    assert_eq!(menu_shortcut(&mut d, "app.keyboardShortcuts"), json!("Cmd+Alt+K"));
+    // Edit ▸ Keyboard Shortcuts… by its shortcut
+    d.ok("ui.key", json!({"key": "Cmd+Alt+K"}));
+    d.frames(2);
+    assert_eq!(d.inspect()["dialog"], json!("Shortcuts"));
+    let keys = d.element_ids("shortcuts.key.");
+    assert!(keys.len() > 60, "drawn keyboard: {}", keys.len());
+    // search, then click the Shortcut cell and press new keys
+    d.ok("ui.click", json!({"id": "shortcuts.search"}));
+    d.ok("ui.type", json!({"text": "add edit"}));
+    d.frames(2);
+    assert!(d.element_ids("shortcuts.row.").iter().any(|x| x == "shortcuts.row.sequence.addEdit"));
+    d.ok("ui.click", json!({"id": "shortcuts.cell.sequence.addEdit"}));
+    d.frames(1);
+    d.ok("ui.key", json!({"key": "Cmd+Shift+J"}));
+    d.frames(2);
+    assert_eq!(menu_shortcut(&mut d, "sequence.addEdit"), json!("Cmd+Shift+J"), "the menu shows the new key live");
+    let cmds = d.ok("engine.commands", json!({}));
+    let ae = cmds.as_array().unwrap().iter().find(|c| c["id"] == "sequence.addEdit").unwrap().clone();
+    assert_eq!(ae["shortcut"], json!("Cmd+Shift+J"), "command list too: {ae}");
+    // reassigning a used key takes it from the other command (and says so)
+    d.ok("ui.click", json!({"id": "shortcuts.cell.sequence.addEdit"}));
+    d.frames(1);
+    d.ok("ui.key", json!({"key": "Cmd+Shift+K"}));
+    d.frames(2);
+    assert_eq!(menu_shortcut(&mut d, "sequence.addEditAllTracks"), Value::Null);
+    let msg = d.element_ids("shortcuts.message");
+    assert_eq!(msg.len(), 1);
+    // Undo / Redo inside the dialog
+    d.ok("ui.click", json!({"id": "shortcuts.undo"}));
+    d.frames(1);
+    assert_eq!(menu_shortcut(&mut d, "sequence.addEditAllTracks"), json!("Cmd+Shift+K"));
+    assert_eq!(menu_shortcut(&mut d, "sequence.addEdit"), json!("Cmd+Shift+J"));
+    d.ok("ui.click", json!({"id": "shortcuts.redo"}));
+    d.frames(1);
+    assert_eq!(menu_shortcut(&mut d, "sequence.addEdit"), json!("Cmd+Shift+K"));
+    // Cancel restores everything
+    d.ok("ui.click", json!({"id": "shortcuts.cancel"}));
+    d.frames(2);
+    assert!(d.inspect()["dialog"].is_null());
+    assert_eq!(menu_shortcut(&mut d, "sequence.addEdit"), json!("Cmd+K"));
+    assert_eq!(menu_shortcut(&mut d, "sequence.addEditAllTracks"), json!("Cmd+Shift+K"));
+
+    // Assign + OK, then the new key really runs the command
+    d.ok("ui.menu.invoke", json!({"id": "app.keyboardShortcuts"}));
+    d.frames(2);
+    d.ok("ui.click", json!({"id": "shortcuts.search"}));
+    d.ok("ui.type", json!({"text": "add edit"}));
+    d.frames(2);
+    d.ok("ui.click", json!({"id": "shortcuts.add.sequence.addEdit"}));
+    d.frames(1);
+    d.ok("ui.key", json!({"key": "Cmd+Shift+J"}));
+    d.frames(2);
+    d.ok("ui.click", json!({"id": "shortcuts.ok"}));
+    d.frames(2);
+    let n0 = track_clips(&d.sequence(), 0).len();
+    d.exec("playhead.set", json!({"seconds": 2.0}));
+    d.ok("ui.set", json!({"focused": "Timeline"}));
+    d.ok("ui.key", json!({"key": "Cmd+Shift+J"}));
+    d.frames(2);
+    assert_eq!(track_clips(&d.sequence(), 0).len(), n0 + 1, "Cmd+Shift+J adds an edit");
+    d.ok("ui.key", json!({"key": "Cmd+K"}));
+    d.frames(2);
+    d.exec("playhead.set", json!({"seconds": 3.0}));
+    d.ok("ui.key", json!({"key": "Cmd+K"}));
+    d.frames(2);
+    assert_eq!(track_clips(&d.sequence(), 0).len(), n0 + 2, "the original Cmd+K was kept (added, not replaced)");
+
+    // Panel-specific: Left in the History panel is Undo; in the Timeline it steps back
+    d.ok("ui.set", json!({"focused": "History"}));
+    d.ok("ui.key", json!({"key": "Left"}));
+    d.frames(2);
+    assert_eq!(track_clips(&d.sequence(), 0).len(), n0 + 1, "History ▸ Left = Step Backward (undo)");
+    d.ok("ui.set", json!({"focused": "Timeline"}));
+    let ph = d.sequence()["playhead"].as_i64().unwrap();
+    d.ok("ui.key", json!({"key": "Left"}));
+    d.frames(2);
+    assert!(d.sequence()["playhead"].as_i64().unwrap() < ph, "Timeline ▸ Left steps back");
+    assert_eq!(track_clips(&d.sequence(), 0).len(), n0 + 1);
+}
diff --git a/crates/vp9/Cargo.toml b/crates/vp9/Cargo.toml
new file mode 100644
index 000000000..5e9fd06e3
--- /dev/null
+++ b/crates/vp9/Cargo.toml
@@ -0,0 +1,21 @@
+[package]
+name = "filmcraft-vp9"
+description = "Clean-room pure-Rust VP9 decoder (VP9 Bitstream & Decoding Process Specification)"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+rust-version.workspace = true
+
+[lints]
+workspace = true
+
+[features]
+default = ["threads"]
+threads = ["dep:rayon"]
+
+[dependencies]
+filmcraft-bitstream = { workspace = true }
+thiserror = { workspace = true }
+rayon = { workspace = true, optional = true }
+
+[dev-dependencies]
diff --git a/crates/vp9/README.md b/crates/vp9/README.md
new file mode 100644
index 000000000..665b42bb9
--- /dev/null
+++ b/crates/vp9/README.md
@@ -0,0 +1,176 @@
+# filmcraft-vp9
+
+Clean-room, pure-Rust (no `unsafe`) VP9 decoder, implemented from the public *VP9 Bitstream &
+Decoding Process Specification* v0.6 (WebM project). It is an L0 crate: it depends only on
+`filmcraft-bitstream`, `thiserror`, and optionally `rayon` (default feature `threads`), and builds
+for `wasm32-unknown-unknown` with and without `threads`.
+
+The constant tables (probability defaults, scans, coefficient bands, quantizer lookups, Pareto
+table, interpolation filters, `mv_ref_blocks`...) were extracted from the specification text by
+[`tools/extract_tables.py`](tools/extract_tables.py) into `src/spec_tables.rs`. The 1D inverse
+DCT / ADST butterflies are generated by [`tools/gen_transforms.py`](tools/gen_transforms.py),
+which symbolically executes the step lists of spec section 8.7.1 into `src/transform_gen.rs`.
+No code was taken or ported from libvpx, FFmpeg or any other decoder; ffmpeg (with libvpx-vp9)
+is used only as an external fixture generator and test oracle.
+
+## Status
+
+| Area | Status |
+|---|---|
+| Profiles 0 / 2 (8, 10, 12-bit 4:2:0) | done, bit-exact |
+| Profiles 1 / 3 (4:2:2, 4:4:0, 4:4:4; 8 / 10 / 12-bit) | done, bit-exact |
+| Uncompressed + compressed headers, superframe index (Annex B) | done |
+| Boolean decoder, forward updates (`diff_update_prob`, MV probs), backward adaptation (8.4) | done |
+| Segmentation (tree / temporal prediction, all four features), loop filter (levels, sharpness, ref / mode deltas, segment levels) | done |
+| All 10 intra modes incl. edge rules, sub-8x8 blocks | done |
+| Inter: 8-tap regular / smooth / sharp + bilinear, compound prediction, MV prediction (incl. previous-frame MVs, sub-8x8 append), reference scaling (8.5.2.3) | done |
+| DCT / ADST 4..32, WHT (lossless) | done |
+| Tiles (columns and rows); tile columns decode in parallel | done |
+| Hidden frames, show_existing_frame, intra-only frames, resolution changes, error resilient / frame parallel modes | done |
+| Loop filter in parallel (superblock wavefront) | done |
+| Frame-level threading (overlapping consecutive frames) | not yet |
+
+## API
+
+```rust
+use filmcraft_vp9::{Decoder, Plane};
+
+let mut dec = Decoder::new(); // or Decoder::with_threads(n)
+for (pts, chunk) in chunks {  // one IVF / WebM block / MP4 sample each (frame or superframe)
+    for pic in dec.decode(chunk, pts)? {
+        // pic.width / pic.height (frame size), pic.render_width / render_height (render_size),
+        // pic.bit_depth, pic.subsampling_x / subsampling_y, pic.chroma_width / chroma_height,
+        // pic.y / pic.u / pic.v: Plane::U8(Vec<u8>) for 8-bit, Plane::U16(Vec<u16>) above,
+        // pic.y_stride / pic.uv_stride, pic.pts, pic.key, pic.intra_only,
+        // pic.color { color_space (0..7 as coded), full_range }
+    }
+}
+let _ = dec.flush(); // VP9 has no reordering: always empty, kept for API symmetry
+dec.reset(); // forget references / contexts (seek), keeps the thread pool
+let stats = dec.stats(); // what the stream exercised (frame kinds, tiles, compound, scaling...)
+
+// Random access points: does a container sample start with a key frame (and its parameters)?
+let key: bool = filmcraft_vp9::is_keyframe(chunk);
+let info: Option<filmcraft_vp9::KeyframeInfo> = filmcraft_vp9::keyframe_info(chunk);
+```
+
+`filmcraft-codecs` wires the decoder into Matroska / WebM (`V_VP9`, profile / bit depth from
+`CodecPrivate`, colour from `Colour`) and MP4 (`vp09` + `vpcC`) import; its GOP cache asks
+`is_keyframe` before starting a decode at a container sync sample, so wrongly flagged samples
+(e.g. an MP4 without `stss`) still seek correctly.
+
+A superframe produces every shown frame it contains (normally one); hidden frames produce none.
+
+### Architecture
+
+The calling thread parses the uncompressed and compressed headers and manages the eight reference
+slots, the four probability contexts, segmentation map and previous-frame motion vectors. Each tile
+column is decoded by one `TileDecoder` (rayon pool) into a private strip of samples and mode info
+(tile rows of a column are decoded in order — they share above contexts); strips are then
+assembled, the loop filter runs as a superblock wavefront (superblock (r, c) waits for (r-1, c+1);
+each superblock filters a private copy of its area plus 8 samples above / left and writes it
+back), counts are merged for backward adaptation and the frame is stored. Samples are `u16`
+internally for every bit depth.
+
+Modules: `header` (6.2 / 6.3, superframes), `boolcoder` (9.2), `probs` (frame contexts, counts,
+8.4), `tile` (partition / mode info / MV prediction), `tile::recon` (residual, tokens, intra /
+inter prediction calls, reconstruction), `intra`, `inter`, `transform`, `loopfilter`, `decoder`.
+
+## Tests
+
+`cargo test --release -p filmcraft-vp9`. Fixtures are generated on first use into
+`target/fixtures/vp9/` with ffmpeg + libvpx-vp9 (tests print a message and skip when ffmpeg or
+libvpx is unavailable). Every frame is compared sample-exactly with `ffmpeg -c:v vp9 -f rawvideo`
+output, single-threaded and with the default thread pool; the first mismatch reports frame, plane,
+position and superblock.
+
+- Unit tests: boolean decoder against a literal model of 9.2, tables / trees, inverse DCT / ADST
+  against floating-point bases, DC-only shortcut vs. full transform, scaled MC path vs. unscaled,
+  superframe index, `inv_remap_prob`, probability merging.
+- Conformance (`tests/conformance.rs`): the fixture matrix below plus a stream concatenating two
+  sizes. `compare_detects_mismatch` guards the harness. `coverage_report` (ignored) prints the
+  decoder statistics for each fixture.
+- Synthetic (`tests/synthetic.rs`): headers of libvpx output are rewritten to produce what ffmpeg's
+  libvpx wrapper cannot: inter frames of a stream encoded at another size spliced after a 352x288
+  key frame with explicit frame sizes, i.e. **scaled reference prediction** (downscale 256x208,
+  upscale 480x400, odd 301x199; a same-size splice is the control); a key frame rewritten as a
+  hidden **intra-only frame** (reset_frame_context 3 / 2 / 0, various refresh masks) shown with
+  **show_existing_frame**; show_existing_frame of every slot, also inside a superframe.
+- Robustness (`tests/robustness.rs`): bit flips, byte replacement and truncation of real streams,
+  truncated frames, random data and oversized frames never panic (debug and release) or hang,
+  single- and multi-threaded.
+
+### Fixture matrix (all bit-exact, 1 thread and thread pool)
+
+Backward adaptation is on (`-frame-parallel 0`) unless noted.
+
+| fixture | content | configuration |
+|---|---|---|
+| intra_only_keyframes | 352x288 | `-g 1` (key frames only, frame parallel) |
+| default_good | 352x288, 20 frames | 800 kb/s |
+| profile2_10bit / profile2_12bit | 352x288 / 176x144 | profile 2, 10 / 12-bit |
+| profile1_444 / _422 / _440 | 176x144 | profile 1, 4:4:4 / 4:2:2 / 4:4:0 |
+| profile3_444_10bit / profile3_422_12bit | 176x144 | profile 3 |
+| lossless / lossless_10bit | 176x144 | `-lossless 1` (WHT) |
+| tiles_cols4 | 1280x720 | 4 tile columns |
+| tiles_rows_cols / tiles_rows4 | 1280x720 / 640x480 | tile columns + rows / 4 tile rows |
+| altref_hidden / altref_10bit / altref_tiles | 352x288 / 720p | 2-pass, `-auto-alt-ref 1`: hidden frames, superframes, compound prediction |
+| frame_parallel | 352x288 | `-frame-parallel 1` (no backward adaptation) |
+| error_resilient | 352x288 | `-error-resilient 1` |
+| odd_size / tiny_odd | 347x251 / 33x17 | odd sizes, partial superblocks |
+| row_mt | 640x360 | `-row-mt 1`, 2 tile columns |
+| speed0 .. speed8 | 176x144 / 352x288 | every speed (0 two-pass, 5..8 realtime) |
+| cq_low / cq_q4 / cq_high / cq_10bit_low / cq_12bit_high | | `-crf 0 / 4 / 63 / 2 / 60` |
+| aq_segmentation / aq_variance / aq_complexity | 352x288 | `-aq-mode 3 / 1 / 2` (segmentation, temporal segment-id prediction) |
+| sharpness | 352x288 | `-sharpness 5` |
+| fade_intra_heavy | 352x288 | fade-in, key frame every 8 |
+| hd_1080p | 1920x1080 | realtime speed 5 |
+| resize_concatenated | 352x288 then 347x251 | size change at a key frame |
+
+## Performance
+
+`cargo test --release -p filmcraft-vp9 --test perf -- --ignored --nocapture` (bit-exactness is
+verified first), or `VP9_THREADS=n VP9_LOOPS=k cargo run --release -p filmcraft-vp9 --example
+vp9dec -- in.ivf` (decodes the file k times and prints the statistics).
+
+Apple M4 Pro (14 cores), 1080p 8-bit `bench_1080p` fixture (libvpx speed 4, 4 MB/s, 4 tile
+columns), 120 frames per run, before / after binaries alternated. The machine was shared with
+other builds (load average 80-110 during the multi-thread runs, up to 200 earlier), so
+wall-clock numbers are the best of 3 runs and still well below what an idle machine gives;
+single-thread CPU time is the stable figure.
+
+| | before (5e9d7d9) | now |
+|---|---|---|
+| 1 thread, CPU time | 52-55 fps | 98-102 fps |
+| 14 threads, wall clock (best of 3, load ~90) | 82-89 fps | 143-145 fps |
+
+What made the difference:
+
+- Loop filter: each group of 8 samples along an edge is filtered as 8 lanes at once (16-bit lanes
+  for 8 / 10-bit, 32-bit for 12-bit); the mask / flat / flat2 decisions are lane-wise and every
+  filter result is selected per lane, so the arithmetic vectorizes. Per-group decisions use masks
+  instead of divisions and skip groups with no edge before looking up levels. The parallel loop
+  filter (superblock wavefront) locks per superblock-row band only while copying, instead of
+  holding one frame-wide lock.
+- Motion compensation: the 8-tap filters run tap-outer over fixed-width rows (4..64) and no longer
+  zero a 10 KB edge window per block; the 2D inverse transform buffers are sized per transform.
+- Memory: strip / frame planes and mode-info grids are recycled through a pool (no per-frame
+  multi-megabyte allocations and page faults); assembling tile strips into the frame and the
+  cropping / 8-bit narrowing of output pictures run in parallel chunks of rows.
+
+The loop filter is still the largest single cost (~30% single-threaded), followed by inter
+prediction and coefficient decoding.
+
+## Known gaps
+
+- No frame-level threading: parallelism is tile columns + loop filter wavefront + row-parallel
+  copies, so streams with a single tile column (narrower than 512 pixels or encoded without tile
+  columns) decode mostly on one thread, and 1080p (at most 4 tile columns) uses 4 threads for
+  coefficient decoding and prediction.
+- Scaled references combined with compound prediction are not covered by a fixture (both are
+  verified separately; libvpx through ffmpeg cannot change size mid-stream and the synthetic
+  splice cannot keep the compound streams' probability contexts intact).
+- Frames larger than 16384x16384 are rejected (`Error::Invalid`) to bound memory.
+- Damaged streams are decoded as far as the data allows (the boolean decoder reads zeros past the
+  end, as specified); there is no concealment beyond that, and inter frames whose reference slots
+  are empty return `Error::MissingReference`.
diff --git a/crates/vp9/examples/vp9dec.rs b/crates/vp9/examples/vp9dec.rs
new file mode 100644
index 000000000..cf44408b5
--- /dev/null
+++ b/crates/vp9/examples/vp9dec.rs
@@ -0,0 +1,43 @@
+//! Decode an IVF file: `cargo run --release -p filmcraft-vp9 --example vp9dec -- in.ivf [out.yuv]`.
+//! Writes raw planar output (8-bit or 16-bit little endian) and prints decoder statistics.
+
+use std::io::Write;
+
+fn main() {
+    let args: Vec<String> = std::env::args().collect();
+    let data = std::fs::read(&args[1]).expect("read input");
+    let mut out = args.get(2).map(|p| std::io::BufWriter::new(std::fs::File::create(p).expect("create output")));
+    let threads = std::env::var("VP9_THREADS").ok().and_then(|s| s.parse().ok()).unwrap_or(0);
+    let mut dec = if threads > 0 { filmcraft_vp9::Decoder::with_threads(threads) } else { filmcraft_vp9::Decoder::new() };
+    // VP9_LOOPS=n decodes the file n times (for profiling; the stream starts with a key frame).
+    let loops = std::env::var("VP9_LOOPS").ok().and_then(|s| s.parse().ok()).unwrap_or(1usize);
+    let hl = u16::from_le_bytes([data[6], data[7]]) as usize;
+    let mut i = 0i64;
+    let t0 = std::time::Instant::now();
+    let mut n = 0;
+    for _ in 0..loops {
+        let mut p = hl;
+        while p + 12 <= data.len() {
+            let sz = u32::from_le_bytes(data[p..p + 4].try_into().unwrap()) as usize;
+            p += 12;
+            let Some(frame) = data.get(p..p + sz) else { break };
+            p += sz;
+            match dec.decode(frame, i) {
+                Ok(pics) => {
+                    for pic in pics {
+                        n += 1;
+                        if let Some(o) = out.as_mut() {
+                            for pl in [&pic.y, &pic.u, &pic.v] {
+                                o.write_all(&pl.to_le_bytes()).unwrap();
+                            }
+                        }
+                    }
+                }
+                Err(e) => eprintln!("chunk {i}: {e}"),
+            }
+            i += 1;
+        }
+    }
+    eprintln!("{n} pictures in {:.3}s", t0.elapsed().as_secs_f64());
+    eprintln!("{:#?}", dec.stats());
+}
diff --git a/crates/vp9/src/boolcoder.rs b/crates/vp9/src/boolcoder.rs
new file mode 100644
index 000000000..da8cb5967
--- /dev/null
+++ b/crates/vp9/src/boolcoder.rs
@@ -0,0 +1,173 @@
+//! Boolean (arithmetic) decoder of section 9.2.
+//!
+//! The specification keeps an 8-bit `BoolValue` and shifts in one bit per renormalisation step.
+//! This implementation keeps `BoolValue` in the top 8 bits of a 64-bit window whose lower bits
+//! hold the next bits of the input, which is equivalent and needs a refill only every few bytes.
+//! Reading past the end of the data yields zero bits, as the specification does once
+//! `BoolMaxBits` is exhausted.
+
+pub struct BoolDecoder<'a> {
+    data: &'a [u8],
+    pos: usize,
+    /// BoolValue in bits 56..63, followed by `count` valid input bits.
+    value: u64,
+    count: i32,
+    range: u32,
+}
+
+impl<'a> BoolDecoder<'a> {
+    /// init_bool (9.2.1): the marker bit is read and returned in `Err` position when non-zero is
+    /// not treated as fatal (libvpx ignores it too), so this only returns the decoder.
+    pub fn new(data: &'a [u8]) -> Self {
+        let mut d = BoolDecoder { data, pos: 0, value: 0, count: -8, range: 255 };
+        d.fill();
+        d.read_bool(128);
+        d
+    }
+
+    #[inline]
+    fn fill(&mut self) {
+        // Room for whole bytes below the top 8 bits and the `count` valid bits.
+        let mut shift = 48 - self.count;
+        if self.pos + 8 <= self.data.len() {
+            let bytes: [u8; 8] = self.data[self.pos..self.pos + 8].try_into().expect("8 bytes");
+            let v = u64::from_be_bytes(bytes);
+            let n = ((shift + 8) / 8) as usize; // bytes that fit
+            let n = n.min(7);
+            // Take the top n bytes of v.
+            let take = v >> (64 - 8 * n);
+            self.value |= take << (shift + 8 - 8 * n as i32);
+            self.pos += n;
+            self.count += 8 * n as i32;
+            return;
+        }
+        while shift >= 0 {
+            let b = if self.pos < self.data.len() {
+                let b = self.data[self.pos];
+                self.pos += 1;
+                b
+            } else {
+                0
+            };
+            self.value |= (b as u64) << shift;
+            self.count += 8;
+            shift -= 8;
+        }
+    }
+
+    /// read_bool (9.2.2).
+    #[inline(always)]
+    pub fn read_bool(&mut self, p: u8) -> bool {
+        if self.count < 8 {
+            self.fill();
+        }
+        let split = 1 + (((self.range - 1) * p as u32) >> 8);
+        let bigsplit = (split as u64) << 56;
+        let bit = if self.value >= bigsplit {
+            self.range -= split;
+            self.value -= bigsplit;
+            true
+        } else {
+            self.range = split;
+            false
+        };
+        let shift = self.range.leading_zeros() - 24;
+        self.range <<= shift;
+        self.value <<= shift;
+        self.count -= shift as i32;
+        bit
+    }
+
+    /// read_literal (9.2.4).
+    pub fn read_literal(&mut self, n: u32) -> u32 {
+        let mut x = 0;
+        for _ in 0..n {
+            x = (x << 1) | self.read_bool(128) as u32;
+        }
+        x
+    }
+
+    /// Tree decoding process (9.3.3) with probabilities `probs[node]`.
+    #[inline]
+    pub fn read_tree(&mut self, tree: &[i8], probs: &[u8]) -> u8 {
+        let mut n = 0i8;
+        loop {
+            n = tree[(n + self.read_bool(probs[(n >> 1) as usize]) as i8) as usize];
+            if n <= 0 {
+                return (-n) as u8;
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Straightforward implementation of 9.2.2 for comparison.
+    struct SpecDecoder<'a> {
+        data: &'a [u8],
+        bitpos: usize,
+        value: u32,
+        range: u32,
+        max_bits: i64,
+    }
+
+    impl<'a> SpecDecoder<'a> {
+        fn new(data: &'a [u8]) -> Self {
+            let mut d = SpecDecoder { data, bitpos: 0, value: 0, range: 255, max_bits: 8 * data.len() as i64 - 8 };
+            for _ in 0..8 {
+                d.value = (d.value << 1) | d.bit();
+            }
+            d.read(128);
+            d
+        }
+        fn bit(&mut self) -> u32 {
+            let b = self.data.get(self.bitpos / 8).map(|b| (b >> (7 - self.bitpos % 8)) & 1).unwrap_or(0);
+            self.bitpos += 1;
+            b as u32
+        }
+        fn read(&mut self, p: u8) -> bool {
+            let split = 1 + (((self.range - 1) * p as u32) >> 8);
+            let bit = if self.value < split {
+                self.range = split;
+                false
+            } else {
+                self.range -= split;
+                self.value -= split;
+                true
+            };
+            while self.range < 128 {
+                let nb = if self.max_bits > 0 {
+                    self.max_bits -= 1;
+                    self.bit()
+                } else {
+                    0
+                };
+                self.range *= 2;
+                self.value = (self.value << 1) + nb;
+            }
+            bit
+        }
+    }
+
+    #[test]
+    fn matches_spec_model() {
+        let mut seed = 0x1234_5678u32;
+        let mut rnd = || {
+            seed ^= seed << 13;
+            seed ^= seed >> 17;
+            seed ^= seed << 5;
+            seed
+        };
+        for len in [1usize, 2, 3, 7, 8, 9, 15, 16, 17, 100, 1000] {
+            let data: Vec<u8> = (0..len).map(|_| rnd() as u8).collect();
+            let mut a = BoolDecoder::new(&data);
+            let mut b = SpecDecoder::new(&data);
+            for i in 0..len * 12 {
+                let p = (rnd() % 255 + 1) as u8;
+                assert_eq!(a.read_bool(p), b.read(p), "len {len} bit {i}");
+            }
+        }
+    }
+}
diff --git a/crates/vp9/src/decoder.rs b/crates/vp9/src/decoder.rs
new file mode 100644
index 000000000..117903e63
--- /dev/null
+++ b/crates/vp9/src/decoder.rs
@@ -0,0 +1,658 @@
+//! Top-level decoder: superframes, frame header handling, tile scheduling (tile columns in
+//! parallel), frame assembly, loop filter (superblock wavefront in parallel), probability
+//! adaptation and reference frame management.
+
+use crate::error::{Error, Result, ensure};
+use crate::frame::{Frame, MiGrid, MiInfo, Plane as FPlane, Pools, plane_geometry};
+use crate::header::{FrameHeader, HeaderState, KEY_FRAME, RefInfo, parse_compressed, parse_uncompressed, split_superframe};
+use crate::loopfilter::{LfFrame, PlaneView, filter_superblock};
+use crate::probs::{Counts, adapt_coef_probs, adapt_noncoef_probs};
+use crate::tables::*;
+use crate::tile::{FrameShared, RefUse, Strip, TileDecoder};
+use crate::{ColorInfo, Picture, Plane};
+use std::sync::Arc;
+
+/// Counters describing what the decoder has seen (useful to check test coverage).
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct DecodeStats {
+    pub frames: u64,
+    pub shown: u64,
+    pub hidden: u64,
+    pub key_frames: u64,
+    pub intra_only: u64,
+    pub inter_frames: u64,
+    pub show_existing: u64,
+    pub superframes: u64,
+    pub error_resilient: u64,
+    pub no_backward_adaptation: u64,
+    pub size_changes: u64,
+    pub scaled_ref_blocks: u64,
+    pub compound_blocks: u64,
+    pub intra_blocks: u64,
+    pub inter_blocks: u64,
+    pub lossless_frames: u64,
+    pub max_tile_cols: u32,
+    pub max_tile_rows: u32,
+    pub segmentation_frames: u64,
+    pub tx_select_frames: u64,
+    pub switchable_interp_frames: u64,
+    pub high_precision_mv_frames: u64,
+    pub compound_frames: u64,
+    pub bit_depths: [u64; 3],
+    pub profiles: [u64; 4],
+}
+
+/// VP9 decoder.
+pub struct Decoder {
+    st: HeaderState,
+    slots: [Option<Arc<Frame>>; 8],
+    prev_mi: Option<Arc<MiGrid>>,
+    prev_seg_ids: Vec<u8>,
+    last_size: Option<(u32, u32)>,
+    last_show_frame: bool,
+    stats: DecodeStats,
+    threads: usize,
+    bufs: Pools,
+    #[cfg(feature = "threads")]
+    pool: Option<rayon::ThreadPool>,
+}
+
+impl Default for Decoder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+fn default_threads() -> usize {
+    #[cfg(all(feature = "threads", not(target_arch = "wasm32")))]
+    {
+        std::thread::available_parallelism().map(|n| n.get()).unwrap_or(1).min(16)
+    }
+    #[cfg(not(all(feature = "threads", not(target_arch = "wasm32"))))]
+    {
+        1
+    }
+}
+
+/// get_tile_offset (6.4.1).
+fn tile_offset(i: usize, mis: usize, log2: u32) -> usize {
+    let sbs = (mis + 7) >> 3;
+    (((i * sbs) >> log2) << 3).min(mis)
+}
+
+impl Decoder {
+    /// A decoder using all available cores (with the `threads` feature).
+    pub fn new() -> Self {
+        Self::with_threads(default_threads())
+    }
+
+    /// A decoder using up to `threads` worker threads (1 = decode on the calling thread).
+    pub fn with_threads(threads: usize) -> Self {
+        #[cfg(feature = "threads")]
+        let pool = if threads > 1 && cfg!(not(target_arch = "wasm32")) {
+            rayon::ThreadPoolBuilder::new().num_threads(threads).thread_name(|i| format!("vp9-{i}")).build().ok()
+        } else {
+            None
+        };
+        Decoder {
+            st: HeaderState::default(),
+            slots: Default::default(),
+            prev_mi: None,
+            prev_seg_ids: Vec::new(),
+            last_size: None,
+            last_show_frame: false,
+            stats: DecodeStats::default(),
+            threads: threads.max(1),
+            bufs: Pools::default(),
+            #[cfg(feature = "threads")]
+            pool,
+        }
+    }
+
+    /// Statistics accumulated so far.
+    pub fn stats(&self) -> DecodeStats {
+        self.stats.clone()
+    }
+
+    /// Decode one chunk (a frame or a superframe, as stored in one IVF / WebM / MP4 sample).
+    /// Returns the frames to show, in order; each carries `pts`.
+    pub fn decode(&mut self, data: &[u8], pts: i64) -> Result<Vec<Picture>> {
+        let frames = split_superframe(data);
+        if frames.len() > 1 {
+            self.stats.superframes += 1;
+        }
+        let mut out = Vec::new();
+        for f in frames {
+            if f.is_empty() {
+                continue;
+            }
+            if let Some(frame) = self.decode_frame(f)? {
+                out.push(make_picture(&frame, pts, self.par()));
+            }
+        }
+        Ok(out)
+    }
+
+    /// End of stream. VP9 has no reordering delay, so this always returns no pictures.
+    pub fn flush(&mut self) -> Vec<Picture> {
+        Vec::new()
+    }
+
+    /// Forget all decoding state (references, probability contexts, segmentation), e.g. before
+    /// decoding from another key frame after a seek. The thread pool and statistics are kept.
+    pub fn reset(&mut self) {
+        self.st = HeaderState::default();
+        self.slots = Default::default();
+        self.prev_mi = None;
+        self.prev_seg_ids = Vec::new();
+        self.last_size = None;
+        self.last_show_frame = false;
+    }
+
+    fn decode_frame(&mut self, data: &[u8]) -> Result<Option<Arc<Frame>>> {
+        let refs: [Option<RefInfo>; 8] = std::array::from_fn(|i| self.slots[i].as_ref().map(|f| RefInfo { width: f.width, height: f.height }));
+        let mut h = parse_uncompressed(data, &mut self.st, &refs)?;
+        if h.show_existing_frame {
+            self.stats.show_existing += 1;
+            let f = self.slots[h.frame_to_show_map_idx as usize]
+                .clone()
+                .ok_or_else(|| Error::MissingReference(format!("show_existing_frame of empty slot {}", h.frame_to_show_map_idx)))?;
+            self.stats.shown += 1;
+            return Ok(Some(f));
+        }
+        ensure!(h.width <= 16384 && h.height <= 16384, "frame size {}x{} too large", h.width, h.height);
+        let (mi_rows, mi_cols) = (h.mi_rows as usize, h.mi_cols as usize);
+        // compute_image_size semantics (7.2.6).
+        let size = (h.width, h.height);
+        let size_changed = self.last_size != Some(size);
+        if size_changed && self.last_size.is_some() {
+            self.stats.size_changes += 1;
+        }
+        if self.st.reset_segment_map || size_changed || self.prev_seg_ids.len() != mi_rows * mi_cols {
+            self.prev_seg_ids = vec![0; mi_rows * mi_cols];
+            self.st.reset_segment_map = false;
+        }
+        let use_prev = !size_changed
+            && self.last_show_frame
+            && !h.error_resilient_mode
+            && !h.frame_is_intra
+            && self.prev_mi.as_ref().is_some_and(|m| m.rows == mi_rows && m.cols == mi_cols);
+        self.last_size = Some(size);
+        self.last_show_frame = h.show_frame;
+
+        let off = h.uncompressed_size;
+        let hs = h.header_size_in_bytes as usize;
+        ensure!(off + hs <= data.len(), "compressed header exceeds frame data");
+        let mut fc = self.st.contexts[h.frame_context_idx as usize].clone();
+        parse_compressed(&data[off..off + hs], &mut h, &mut fc)?;
+        self.count_frame(&h);
+
+        // References (8.5.2.3).
+        let mut refs: [Option<RefUse>; 3] = [None, None, None];
+        let ref_frames: Vec<Option<Arc<Frame>>> =
+            (0..3).map(|i| if h.frame_is_intra { None } else { self.slots[h.ref_frame_idx[i] as usize].clone() }).collect();
+        if !h.frame_is_intra {
+            for i in 0..3 {
+                let Some(rf) = &ref_frames[i] else {
+                    return Err(Error::MissingReference(format!("reference slot {} is empty", h.ref_frame_idx[i])));
+                };
+                ensure!(
+                    rf.bit_depth == h.color.bit_depth && rf.ss_x == h.color.subsampling_x && rf.ss_y == h.color.subsampling_y,
+                    "reference frame format differs from the current frame"
+                );
+                let (rw, rh) = (rf.width as i64, rf.height as i64);
+                let (w, hh) = (h.width as i64, h.height as i64);
+                if 2 * w >= rw && 2 * hh >= rh && w <= 16 * rw && hh <= 16 * rh {
+                    let x_scale = ((rw << 14) / w) as i32;
+                    let y_scale = ((rh << 14) / hh) as i32;
+                    refs[i] = Some(RefUse { frame: rf, x_scale, y_scale, x_step: (16 * x_scale) >> 14, y_step: (16 * y_scale) >> 14 });
+                }
+            }
+        }
+        // Quantizers per segment (8.6.1).
+        let bd_idx = ((h.color.bit_depth - 8) >> 1) as usize;
+        let seg = self.st.seg.clone();
+        let mut seg_q = [[[0i32; 2]; 2]; 8];
+        for (s, q) in seg_q.iter_mut().enumerate() {
+            let qindex = if seg.feature_active(s as u8, SEG_LVL_ALT_Q) {
+                let d = seg.feature_data[s][SEG_LVL_ALT_Q] as i32;
+                (if seg.abs_or_delta_update { d } else { h.base_q_idx as i32 + d }).clamp(0, 255)
+            } else {
+                h.base_q_idx as i32
+            };
+            let dc = |b: i32| DC_QLOOKUP[bd_idx * 256 + b.clamp(0, 255) as usize];
+            let ac = |b: i32| AC_QLOOKUP[bd_idx * 256 + b.clamp(0, 255) as usize];
+            q[0] = [dc(qindex + h.delta_q_y_dc as i32), ac(qindex)];
+            q[1] = [dc(qindex + h.delta_q_uv_dc as i32), ac(qindex + h.delta_q_uv_ac as i32)];
+        }
+        // Tile layout and data (6.4).
+        let tile_cols = 1usize << h.tile_cols_log2;
+        let tile_rows = 1usize << h.tile_rows_log2;
+        let mut pos = off + hs;
+        let mut tile_data: Vec<Vec<&[u8]>> = vec![Vec::with_capacity(tile_rows); tile_cols];
+        for tr in 0..tile_rows {
+            for (tc, td) in tile_data.iter_mut().enumerate() {
+                let last = tr == tile_rows - 1 && tc == tile_cols - 1;
+                let sz = if last {
+                    data.len() - pos
+                } else {
+                    ensure!(pos + 4 <= data.len(), "tile size beyond frame data");
+                    let s = u32::from_be_bytes(data[pos..pos + 4].try_into().expect("4 bytes")) as usize;
+                    pos += 4;
+                    ensure!(s <= data.len() - pos, "tile size {s} beyond frame data");
+                    s
+                };
+                td.push(&data[pos..pos + sz]);
+                pos += sz;
+            }
+        }
+        let counting = !h.error_resilient_mode && !h.frame_parallel_decoding_mode;
+        let prev_mi = if use_prev { self.prev_mi.clone() } else { None };
+        let shared =
+            FrameShared { h: &h, fc: &fc, seg: &seg, prev_seg_ids: &self.prev_seg_ids, prev_mi: prev_mi.as_deref(), refs, seg_q, counting, pools: &self.bufs };
+        let col_bounds: Vec<(usize, usize)> =
+            (0..tile_cols).map(|i| (tile_offset(i, mi_cols, h.tile_cols_log2), tile_offset(i + 1, mi_cols, h.tile_cols_log2))).collect();
+        let row_bounds: Vec<(usize, usize)> =
+            (0..tile_rows).map(|i| (tile_offset(i, mi_rows, h.tile_rows_log2), tile_offset(i + 1, mi_rows, h.tile_rows_log2))).collect();
+        let decode_col = |ci: usize| -> (Strip, Option<Error>) {
+            let (cs, ce) = col_bounds[ci];
+            let mut td = TileDecoder::new(&shared, cs, ce);
+            let mut err = None;
+            if ce > cs {
+                for (ri, &(rs, re)) in row_bounds.iter().enumerate() {
+                    if !td.decode_tile(tile_data[ci][ri], rs, re) {
+                        err = Some(Error::Invalid("tile data exhausted".into()));
+                        break;
+                    }
+                }
+            }
+            let e = td.error.take().or(err);
+            (td.strip, e)
+        };
+        let results: Vec<(Strip, Option<Error>)> = self.run_parallel(tile_cols, &decode_col);
+        let mut counts = Counts::default();
+        let mut strips = Vec::with_capacity(results.len());
+        for (s, e) in results {
+            if let Some(e) = e {
+                return Err(e);
+            }
+            if counting {
+                counts.add(&s.counts);
+            }
+            self.stats.compound_blocks += s.compound_blocks;
+            self.stats.scaled_ref_blocks += s.scaled_blocks;
+            self.stats.intra_blocks += s.intra_blocks;
+            self.stats.inter_blocks += s.inter_blocks;
+            strips.push(s);
+        }
+        // Release the references before the slots are refreshed, so that evicted frames can be
+        // recycled.
+        drop(ref_frames);
+        drop(prev_mi);
+        // Assemble the frame and mode info.
+        let geo = plane_geometry(h.width, h.height, h.color.subsampling_x, h.color.subsampling_y);
+        let (planes, mi, seg_ids) = assemble(strips, &geo, mi_rows, mi_cols, &self.bufs, self.par());
+        let mut frame = Frame {
+            planes,
+            width: h.width,
+            height: h.height,
+            ss_x: h.color.subsampling_x,
+            ss_y: h.color.subsampling_y,
+            bit_depth: h.color.bit_depth,
+            color_space: h.color.color_space,
+            color_range: h.color.color_range,
+            render_width: h.render_width,
+            render_height: h.render_height,
+            key: h.frame_type == KEY_FRAME,
+            intra_only: h.intra_only,
+        };
+        // Loop filter (8.8).
+        if self.st.lf.level > 0 {
+            let lf = LfFrame::new(&self.st.lf, &seg, mi_rows, mi_cols, h.color.subsampling_x, h.color.subsampling_y, h.color.bit_depth);
+            self.loop_filter(&mut frame, &mi, &lf);
+        }
+        // refresh_probs (6.1.2).
+        if counting {
+            let saved = &self.st.contexts[h.frame_context_idx as usize];
+            let mut a = saved.clone();
+            a.tx = fc.tx;
+            a.skip = fc.skip;
+            adapt_coef_probs(&mut a, &counts, h.frame_is_intra, self.st.last_frame_type == KEY_FRAME);
+            if !h.frame_is_intra {
+                a.tx = saved.tx;
+                a.skip = saved.skip;
+                adapt_noncoef_probs(&mut a, &counts, h.interp_filter == SWITCHABLE, h.tx_mode == TX_MODE_SELECT, h.allow_high_precision_mv);
+            }
+            fc = a;
+        }
+        if h.refresh_frame_context {
+            self.st.contexts[h.frame_context_idx as usize] = fc;
+        }
+        if seg.enabled && seg.update_map {
+            self.prev_seg_ids = seg_ids;
+        }
+        let frame = Arc::new(frame);
+        let mut evicted = Vec::new();
+        for i in 0..8 {
+            if (h.refresh_frame_flags >> i) & 1 == 1 {
+                evicted.extend(self.slots[i].replace(frame.clone()));
+            }
+        }
+        // Recycle the planes of frames no longer referenced anywhere.
+        for f in evicted {
+            if let Ok(f) = Arc::try_unwrap(f) {
+                for p in f.planes {
+                    self.bufs.samples.put(p.data);
+                }
+            }
+        }
+        if let Some(old) = self.prev_mi.replace(Arc::new(mi))
+            && let Ok(old) = Arc::try_unwrap(old)
+        {
+            self.bufs.mi.put(old.mi);
+        }
+        if h.show_frame {
+            self.stats.shown += 1;
+            Ok(Some(frame))
+        } else {
+            self.stats.hidden += 1;
+            Ok(None)
+        }
+    }
+
+    fn count_frame(&mut self, h: &FrameHeader) {
+        let s = &mut self.stats;
+        s.frames += 1;
+        if h.frame_type == KEY_FRAME {
+            s.key_frames += 1;
+        } else if h.intra_only {
+            s.intra_only += 1;
+        } else {
+            s.inter_frames += 1;
+        }
+        s.error_resilient += h.error_resilient_mode as u64;
+        s.no_backward_adaptation += (h.error_resilient_mode || h.frame_parallel_decoding_mode) as u64;
+        s.lossless_frames += h.lossless as u64;
+        s.max_tile_cols = s.max_tile_cols.max(1 << h.tile_cols_log2);
+        s.max_tile_rows = s.max_tile_rows.max(1 << h.tile_rows_log2);
+        s.segmentation_frames += self.st.seg.enabled as u64;
+        s.tx_select_frames += (h.tx_mode == TX_MODE_SELECT) as u64;
+        s.switchable_interp_frames += (!h.frame_is_intra && h.interp_filter == SWITCHABLE) as u64;
+        s.high_precision_mv_frames += (!h.frame_is_intra && h.allow_high_precision_mv) as u64;
+        s.compound_frames += (!h.frame_is_intra && h.reference_mode != 0) as u64;
+        s.bit_depths[((h.color.bit_depth - 8) >> 1) as usize] += 1;
+        s.profiles[h.profile as usize] += 1;
+    }
+
+    fn par(&self) -> Par<'_> {
+        #[cfg(feature = "threads")]
+        {
+            Par(self.pool.as_ref())
+        }
+        #[cfg(not(feature = "threads"))]
+        {
+            Par(std::marker::PhantomData)
+        }
+    }
+
+    /// Run `f(0..n)`, in parallel when a pool is available.
+    fn run_parallel<T: Send>(&self, n: usize, f: &(dyn Fn(usize) -> T + Sync)) -> Vec<T> {
+        #[cfg(feature = "threads")]
+        if let Some(pool) = &self.pool
+            && n > 1
+        {
+            use rayon::prelude::*;
+            return pool.install(|| (0..n).into_par_iter().map(f).collect());
+        }
+        (0..n).map(f).collect()
+    }
+
+    fn loop_filter(&self, frame: &mut Frame, mi: &MiGrid, lf: &LfFrame) {
+        let sb_rows = lf.mi_rows.div_ceil(8);
+        let sb_cols = lf.mi_cols.div_ceil(8);
+        #[cfg(feature = "threads")]
+        if let Some(pool) = &self.pool
+            && sb_rows > 1
+        {
+            lf_parallel(pool, self.threads, frame, mi, lf, sb_rows, sb_cols);
+            return;
+        }
+        let _ = self.threads;
+        let [p0, p1, p2] = &mut frame.planes;
+        let mut views = [
+            PlaneView { stride: p0.stride, data: &mut p0.data, ox: 0, oy: 0 },
+            PlaneView { stride: p1.stride, data: &mut p1.data, ox: 0, oy: 0 },
+            PlaneView { stride: p2.stride, data: &mut p2.data, ox: 0, oy: 0 },
+        ];
+        for r in 0..sb_rows {
+            for c in 0..sb_cols {
+                filter_superblock(&mut views, mi, lf, r * 8, c * 8);
+            }
+        }
+    }
+}
+
+/// Loop filter with a superblock wavefront: superblock (r, c) runs once (r - 1, c + 1) is done.
+/// The planes are split into superblock-row bands, each behind its own lock. Each superblock
+/// copies the samples it may touch (its area plus 8 samples above / left, i.e. the bottom rows
+/// of band r - 1 and its own band) out, filters them locally and writes them back; the locks are
+/// only held while copying, and only neighbouring rows ever contend.
+#[cfg(feature = "threads")]
+fn lf_parallel(pool: &rayon::ThreadPool, threads: usize, frame: &mut Frame, mi: &MiGrid, lf: &LfFrame, sb_rows: usize, sb_cols: usize) {
+    use rayon::prelude::*;
+    use std::sync::atomic::{AtomicUsize, Ordering};
+    use std::sync::{Condvar, Mutex};
+    let strides = [frame.planes[0].stride, frame.planes[1].stride, frame.planes[2].stride];
+    let sub = [(0usize, 0usize), (lf.ss_x, lf.ss_y), (lf.ss_x, lf.ss_y)];
+    let band_h = [64usize, 64 >> lf.ss_y, 64 >> lf.ss_y];
+    // bands[r][p]: rows [r * band_h[p], (r + 1) * band_h[p]) of plane p.
+    let bands: Vec<Mutex<[&mut [u16]; 3]>> = {
+        let [a, b, c] = &mut frame.planes;
+        let mut ia = a.data.chunks_mut(band_h[0] * strides[0]);
+        let mut ib = b.data.chunks_mut(band_h[1] * strides[1]);
+        let mut ic = c.data.chunks_mut(band_h[2] * strides[2]);
+        (0..sb_rows).map(|_| Mutex::new([ia.next().unwrap_or_default(), ib.next().unwrap_or_default(), ic.next().unwrap_or_default()])).collect()
+    };
+    let progress = Mutex::new(vec![0usize; sb_rows]);
+    let cv = Condvar::new();
+    let next = AtomicUsize::new(0);
+    // Copy rows [ry, ry + rh) x [rx, rx + rw) of plane p between the bands and `buf` (row-major,
+    // stride rw); `to_buf` selects the direction.
+    let xfer = |r: usize, p: usize, rx: usize, ry: usize, rw: usize, rh: usize, buf: &mut [u16], to_buf: bool| {
+        let bh = band_h[p];
+        let mut yy = 0;
+        while yy < rh {
+            let y = ry + yy;
+            let br = y / bh;
+            let n = ((br + 1) * bh - y).min(rh - yy);
+            debug_assert!(br + 1 >= r && br <= r);
+            let mut g = bands[br].lock().expect("lf band");
+            let band = &mut g[p];
+            for k in 0..n {
+                let s = (y + k - br * bh) * strides[p] + rx;
+                let b = (yy + k) * rw;
+                if to_buf {
+                    buf[b..b + rw].copy_from_slice(&band[s..s + rw]);
+                } else {
+                    band[s..s + rw].copy_from_slice(&buf[b..b + rw]);
+                }
+            }
+            yy += n;
+        }
+    };
+    pool.install(|| {
+        (0..threads.min(sb_rows)).into_par_iter().for_each(|_| {
+            let mut bufs: [Vec<u16>; 3] = [vec![0; 72 * 72], vec![0; 72 * 72], vec![0; 72 * 72]];
+            loop {
+                let r = next.fetch_add(1, Ordering::Relaxed);
+                if r >= sb_rows {
+                    break;
+                }
+                for c in 0..sb_cols {
+                    if r > 0 {
+                        let need = (c + 2).min(sb_cols);
+                        let mut p = progress.lock().expect("lf progress");
+                        while p[r - 1] < need {
+                            p = cv.wait(p).expect("lf progress");
+                        }
+                    }
+                    // Region of each plane: [x0 - 8, x0 + size) x [y0 - 8, y0 + size).
+                    let mut regions = [(0usize, 0usize, 0usize, 0usize); 3];
+                    for p in 0..3 {
+                        let (sx, sy) = sub[p];
+                        let (x0, y0) = ((c * 64) >> sx, (r * 64) >> sy);
+                        let (rx, ry) = (x0.saturating_sub(8), y0.saturating_sub(8));
+                        let rw = (x0 + (64 >> sx)).min(strides[p]) - rx;
+                        let rh = (y0 + band_h[p]) - ry;
+                        regions[p] = (rx, ry, rw, rh);
+                        xfer(r, p, rx, ry, rw, rh, &mut bufs[p], true);
+                    }
+                    {
+                        let [b0, b1, b2] = &mut bufs;
+                        let mut views = [
+                            PlaneView { data: b0, stride: regions[0].2, ox: regions[0].0, oy: regions[0].1 },
+                            PlaneView { data: b1, stride: regions[1].2, ox: regions[1].0, oy: regions[1].1 },
+                            PlaneView { data: b2, stride: regions[2].2, ox: regions[2].0, oy: regions[2].1 },
+                        ];
+                        filter_superblock(&mut views, mi, lf, r * 8, c * 8);
+                    }
+                    for p in 0..3 {
+                        let (rx, ry, rw, rh) = regions[p];
+                        xfer(r, p, rx, ry, rw, rh, &mut bufs[p], false);
+                    }
+                    let mut p = progress.lock().expect("lf progress");
+                    p[r] = c + 1;
+                    cv.notify_all();
+                }
+            }
+        });
+    });
+}
+
+/// Optional thread pool for data-parallel copies.
+#[derive(Clone, Copy)]
+struct Par<'a>(#[cfg(feature = "threads")] Option<&'a rayon::ThreadPool>, #[cfg(not(feature = "threads"))] std::marker::PhantomData<&'a ()>);
+
+impl Par<'_> {
+    /// `f(i, chunk)` for the consecutive `chunk_len`-element chunks of `data`.
+    fn chunks<T: Send>(self, data: &mut [T], chunk_len: usize, f: impl Fn(usize, &mut [T]) + Sync) {
+        let chunk_len = chunk_len.max(1);
+        #[cfg(feature = "threads")]
+        if let Some(pool) = self.0
+            && data.len() > chunk_len
+        {
+            use rayon::prelude::*;
+            pool.install(|| data.par_chunks_mut(chunk_len).enumerate().for_each(|(i, c)| f(i, c)));
+            return;
+        }
+        for (i, c) in data.chunks_mut(chunk_len).enumerate() {
+            f(i, c);
+        }
+    }
+}
+
+/// Rows per chunk of the parallel frame copies.
+const COPY_ROWS: usize = 64;
+
+/// Build full-frame planes, mode info and segment ids from the tile column strips.
+fn assemble(
+    mut strips: Vec<Strip>,
+    geo: &[(usize, usize, usize, usize); 3],
+    mi_rows: usize,
+    mi_cols: usize,
+    pools: &Pools,
+    par: Par,
+) -> ([FPlane; 3], MiGrid, Vec<u8>) {
+    if strips.len() == 1 {
+        let s = strips.pop().expect("one strip");
+        let [a, b, c] = s.planes;
+        let mk = |d: Vec<u16>, g: (usize, usize, usize, usize)| FPlane { data: d, stride: g.0, width: g.2, height: g.3 };
+        return ([mk(a, geo[0]), mk(b, geo[1]), mk(c, geo[2])], MiGrid { cols: mi_cols, rows: mi_rows, mi: s.mi }, s.seg_ids);
+    }
+    let mk = |g: (usize, usize, usize, usize)| FPlane { data: pools.samples.take(g.0 * g.1, 0), stride: g.0, width: g.2, height: g.3 };
+    let mut planes = [mk(geo[0]), mk(geo[1]), mk(geo[2])];
+    let mut mi = pools.mi.take(mi_rows * mi_cols, MiInfo::default());
+    let mut seg = vec![0u8; mi_rows * mi_cols];
+    for (p, plane) in planes.iter_mut().enumerate() {
+        let fs = plane.stride;
+        // Each chunk of destination rows gathers its part of every strip.
+        par.chunks(&mut plane.data, COPY_ROWS * fs, |ci, dst| {
+            let y0 = ci * COPY_ROWS;
+            for s in &strips {
+                let ss = s.strides[p];
+                let x0 = s.x_off[p];
+                let w = ss.min(fs - x0);
+                for (k, row) in dst.chunks_mut(fs).enumerate() {
+                    let y = y0 + k;
+                    if let Some(src) = s.planes[p].get(y * ss..y * ss + w) {
+                        row[x0..x0 + w].copy_from_slice(src);
+                    }
+                }
+            }
+        });
+    }
+    for s in &strips {
+        let mw = s.mi_col_end - s.mi_col_start;
+        for r in 0..mi_rows {
+            mi[r * mi_cols + s.mi_col_start..r * mi_cols + s.mi_col_end].copy_from_slice(&s.mi[r * mw..r * mw + mw]);
+            seg[r * mi_cols + s.mi_col_start..r * mi_cols + s.mi_col_end].copy_from_slice(&s.seg_ids[r * mw..r * mw + mw]);
+        }
+    }
+    for s in strips {
+        for p in s.planes {
+            pools.samples.put(p);
+        }
+        pools.mi.put(s.mi);
+    }
+    (planes, MiGrid { cols: mi_cols, rows: mi_rows, mi }, seg)
+}
+
+fn make_picture(f: &Frame, pts: i64, par: Par) -> Picture {
+    // Crop (and narrow 8-bit samples), in parallel chunks of rows.
+    let conv = |p: &FPlane| -> Plane {
+        let w = p.width;
+        if w == 0 || p.height == 0 {
+            return if f.bit_depth == 8 { Plane::U8(Vec::new()) } else { Plane::U16(Vec::new()) };
+        }
+        if f.bit_depth == 8 {
+            let mut out = vec![0u8; w * p.height];
+            par.chunks(&mut out, COPY_ROWS * w, |ci, dst| {
+                for (k, row) in dst.chunks_mut(w).enumerate() {
+                    for (d, &s) in row.iter_mut().zip(&p.row(ci * COPY_ROWS + k)[..w]) {
+                        *d = s as u8;
+                    }
+                }
+            });
+            Plane::U8(out)
+        } else {
+            let mut out = vec![0u16; w * p.height];
+            par.chunks(&mut out, COPY_ROWS * w, |ci, dst| {
+                for (k, row) in dst.chunks_mut(w).enumerate() {
+                    row.copy_from_slice(&p.row(ci * COPY_ROWS + k)[..w]);
+                }
+            });
+            Plane::U16(out)
+        }
+    };
+    let [y, u, v] = &f.planes;
+    Picture {
+        width: f.width,
+        height: f.height,
+        chroma_width: u.width as u32,
+        chroma_height: u.height as u32,
+        bit_depth: f.bit_depth as u32,
+        subsampling_x: f.ss_x,
+        subsampling_y: f.ss_y,
+        y: conv(y),
+        u: conv(u),
+        v: conv(v),
+        y_stride: y.width,
+        uv_stride: u.width,
+        pts,
+        key: f.key,
+        intra_only: f.intra_only,
+        color: ColorInfo { color_space: f.color_space, full_range: f.color_range },
+        render_width: f.render_width,
+        render_height: f.render_height,
+    }
+}
diff --git a/crates/vp9/src/error.rs b/crates/vp9/src/error.rs
new file mode 100644
index 000000000..77e59a27b
--- /dev/null
+++ b/crates/vp9/src/error.rs
@@ -0,0 +1,31 @@
+use filmcraft_bitstream::BitError;
+
+/// Errors produced by the decoder.
+#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
+pub enum Error {
+    /// The uncompressed header ended early.
+    #[error("bitstream error: {0}")]
+    Bitstream(#[from] BitError),
+    /// A syntax element had a value outside its legal range, or a size did not fit the data.
+    #[error("invalid bitstream: {0}")]
+    Invalid(String),
+    /// A valid feature this decoder does not implement.
+    #[error("unsupported: {0}")]
+    Unsupported(String),
+    /// An inter frame referenced a reference slot that was never filled (e.g. decoding started
+    /// at a non-key frame).
+    #[error("missing reference frame: {0}")]
+    MissingReference(String),
+}
+
+pub type Result<T> = std::result::Result<T, Error>;
+
+/// `ensure!(cond, "message")` returns `Error::Invalid` when `cond` is false.
+macro_rules! ensure {
+    ($cond:expr, $($arg:tt)+) => {
+        if !$cond {
+            return Err($crate::error::Error::Invalid(format!($($arg)+)));
+        }
+    };
+}
+pub(crate) use ensure;
diff --git a/crates/vp9/src/frame.rs b/crates/vp9/src/frame.rs
new file mode 100644
index 000000000..3b2a6861e
--- /dev/null
+++ b/crates/vp9/src/frame.rs
@@ -0,0 +1,158 @@
+//! Decoded frame storage and the per-8x8 mode info grid.
+
+use crate::tables::{INTRA_FRAME, NONE};
+
+/// A motion vector in 1/8 sample units.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub struct Mv {
+    pub row: i16,
+    pub col: i16,
+}
+
+impl Mv {
+    pub const ZERO: Mv = Mv { row: 0, col: 0 };
+    pub fn new(row: i32, col: i32) -> Mv {
+        Mv { row: row as i16, col: col as i16 }
+    }
+}
+
+/// Mode info of one 8x8 block (the arrays of 6.4.4: Skips, TxSizes, MiSizes, YModes, SubModes,
+/// RefFrames, InterpFilters, Mvs / SubMvs).
+#[derive(Clone, Copy, Debug)]
+pub struct MiInfo {
+    pub sb_size: u8,
+    pub skip: bool,
+    pub tx_size: u8,
+    pub y_mode: u8,
+    pub sub_modes: [u8; 4],
+    pub seg_id: u8,
+    pub ref_frame: [i8; 2],
+    pub interp_filter: u8,
+    /// SubMvs[refList][b]; Mvs[refList] is `mv[refList][3]`.
+    pub mv: [[Mv; 4]; 2],
+}
+
+impl Default for MiInfo {
+    fn default() -> Self {
+        MiInfo {
+            sb_size: 0,
+            skip: false,
+            tx_size: 0,
+            y_mode: 0,
+            sub_modes: [0; 4],
+            seg_id: 0,
+            ref_frame: [INTRA_FRAME, NONE],
+            interp_filter: 0,
+            mv: [[Mv::ZERO; 4]; 2],
+        }
+    }
+}
+
+/// Mode info of a whole frame (MiRows x MiCols).
+#[derive(Clone, Debug, Default)]
+pub struct MiGrid {
+    pub cols: usize,
+    pub rows: usize,
+    pub mi: Vec<MiInfo>,
+}
+
+impl MiGrid {
+    #[inline]
+    pub fn at(&self, r: usize, c: usize) -> &MiInfo {
+        &self.mi[r * self.cols + c]
+    }
+}
+
+/// One plane of samples. The allocation covers whole 64x64 superblocks; `width` x `height` is the
+/// visible (cropped) area.
+#[derive(Clone, Debug, Default)]
+pub struct Plane {
+    pub data: Vec<u16>,
+    pub stride: usize,
+    pub width: usize,
+    pub height: usize,
+}
+
+impl Plane {
+    #[inline]
+    pub fn row(&self, y: usize) -> &[u16] {
+        &self.data[y * self.stride..(y + 1) * self.stride]
+    }
+}
+
+/// A decoded frame (also used as reference).
+#[derive(Clone, Debug)]
+pub struct Frame {
+    pub planes: [Plane; 3],
+    pub width: u32,
+    pub height: u32,
+    pub ss_x: bool,
+    pub ss_y: bool,
+    pub bit_depth: u8,
+    pub color_space: u8,
+    pub color_range: bool,
+    pub render_width: u32,
+    pub render_height: u32,
+    pub key: bool,
+    pub intra_only: bool,
+}
+
+/// Geometry of the frame planes: allocation sizes for (MiCols, MiRows) rounded to superblocks.
+pub fn plane_geometry(width: u32, height: u32, ss_x: bool, ss_y: bool) -> [(usize, usize, usize, usize); 3] {
+    let sb_cols = (width as usize).div_ceil(64);
+    let sb_rows = (height as usize).div_ceil(64);
+    let (aw, ah) = (sb_cols * 64, sb_rows * 64);
+    let (sx, sy) = (ss_x as usize, ss_y as usize);
+    let cw = (width as usize + sx) >> sx;
+    let ch = (height as usize + sy) >> sy;
+    [(aw, ah, width as usize, height as usize), (aw >> sx, ah >> sy, cw, ch), (aw >> sx, ah >> sy, cw, ch)]
+}
+
+/// Recycled buffers (strip / frame planes, mode info), so that steady-state decoding does not
+/// allocate (and page-fault) megabytes per frame.
+pub struct Pool<T> {
+    bufs: std::sync::Mutex<Vec<Vec<T>>>,
+}
+
+impl<T> Default for Pool<T> {
+    fn default() -> Self {
+        Pool { bufs: Default::default() }
+    }
+}
+
+impl<T: Clone> Pool<T> {
+    const MAX: usize = 32;
+
+    /// A buffer of `len` copies of `fill` (recycled memory when available).
+    pub fn take(&self, len: usize, fill: T) -> Vec<T> {
+        let found = {
+            let mut b = self.bufs.lock().expect("buffer pool");
+            b.iter().position(|v| v.capacity() >= len).map(|i| b.swap_remove(i))
+        };
+        match found {
+            Some(mut v) => {
+                v.resize(len, fill);
+                v
+            }
+            None => vec![fill; len],
+        }
+    }
+
+    pub fn put(&self, mut v: Vec<T>) {
+        if v.capacity() == 0 {
+            return;
+        }
+        v.clear();
+        let mut b = self.bufs.lock().expect("buffer pool");
+        if b.len() < Self::MAX {
+            b.push(v);
+        }
+    }
+}
+
+/// The decoder's buffer pools.
+#[derive(Default)]
+pub struct Pools {
+    pub samples: Pool<u16>,
+    pub mi: Pool<MiInfo>,
+}
diff --git a/crates/vp9/src/header.rs b/crates/vp9/src/header.rs
new file mode 100644
index 000000000..2d76f302f
--- /dev/null
+++ b/crates/vp9/src/header.rs
@@ -0,0 +1,661 @@
+//! Uncompressed header (6.2) and compressed header (6.3) parsing, plus the state that persists
+//! between frames (loop filter deltas, segmentation parameters, colour configuration).
+
+use crate::boolcoder::BoolDecoder;
+use crate::error::{Error, Result, ensure};
+use crate::probs::FrameContext;
+use crate::tables::*;
+use filmcraft_bitstream::BitReader;
+
+pub const KEY_FRAME: u8 = 0;
+
+/// Loop filter parameters (6.2.8); the deltas persist across frames.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct LoopFilterParams {
+    pub level: u8,
+    pub sharpness: u8,
+    pub delta_enabled: bool,
+    pub ref_deltas: [i8; 4],
+    pub mode_deltas: [i8; 2],
+}
+
+/// Segmentation parameters (6.2.11); feature data persists across frames.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct Segmentation {
+    pub enabled: bool,
+    pub update_map: bool,
+    pub tree_probs: [u8; 7],
+    pub pred_probs: [u8; 3],
+    pub temporal_update: bool,
+    pub abs_or_delta_update: bool,
+    pub feature_enabled: [[bool; 4]; 8],
+    pub feature_data: [[i16; 4]; 8],
+}
+
+impl Segmentation {
+    #[inline]
+    pub fn feature_active(&self, segment_id: u8, feature: usize) -> bool {
+        self.enabled && self.feature_enabled[segment_id as usize][feature]
+    }
+}
+
+/// Colour configuration (6.2.2); persists for inter frames.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct ColorConfig {
+    pub bit_depth: u8,
+    pub color_space: u8,
+    pub color_range: bool,
+    pub subsampling_x: bool,
+    pub subsampling_y: bool,
+}
+
+impl Default for ColorConfig {
+    fn default() -> Self {
+        ColorConfig { bit_depth: 8, color_space: 0, color_range: false, subsampling_x: true, subsampling_y: true }
+    }
+}
+
+/// Everything read from the headers of one frame.
+#[derive(Clone, Debug, Default)]
+pub struct FrameHeader {
+    pub profile: u8,
+    pub show_existing_frame: bool,
+    pub frame_to_show_map_idx: u8,
+    pub frame_type: u8,
+    pub show_frame: bool,
+    pub error_resilient_mode: bool,
+    pub intra_only: bool,
+    pub reset_frame_context: u8,
+    pub color: ColorConfig,
+    pub refresh_frame_flags: u8,
+    pub ref_frame_idx: [u8; 3],
+    /// Indexed by reference frame (LAST_FRAME..ALTREF_FRAME); index 0 unused.
+    pub ref_frame_sign_bias: [bool; 4],
+    pub width: u32,
+    pub height: u32,
+    pub render_width: u32,
+    pub render_height: u32,
+    pub allow_high_precision_mv: bool,
+    pub interp_filter: u8,
+    pub refresh_frame_context: bool,
+    pub frame_parallel_decoding_mode: bool,
+    pub frame_context_idx: u8,
+    pub base_q_idx: u8,
+    pub delta_q_y_dc: i8,
+    pub delta_q_uv_dc: i8,
+    pub delta_q_uv_ac: i8,
+    pub lossless: bool,
+    pub tile_cols_log2: u32,
+    pub tile_rows_log2: u32,
+    pub header_size_in_bytes: u32,
+    /// Size of the uncompressed header in bytes.
+    pub uncompressed_size: usize,
+    // Compressed header.
+    pub tx_mode: u8,
+    pub reference_mode: u8,
+    pub comp_fixed_ref: i8,
+    pub comp_var_ref: [i8; 2],
+    // Derived.
+    pub mi_cols: u32,
+    pub mi_rows: u32,
+    pub sb64_cols: u32,
+    pub sb64_rows: u32,
+    pub frame_is_intra: bool,
+    /// The frame size was taken from reference `found_ref` (for statistics).
+    pub size_from_ref: bool,
+}
+
+/// Reference slot information needed while parsing (frame_size_with_refs).
+#[derive(Clone, Copy, Debug)]
+pub struct RefInfo {
+    pub width: u32,
+    pub height: u32,
+}
+
+/// State carried between frames that header parsing reads and updates.
+pub struct HeaderState {
+    pub contexts: [FrameContext; 4],
+    pub lf: LoopFilterParams,
+    pub seg: Segmentation,
+    pub color: ColorConfig,
+    pub last_frame_type: u8,
+    pub frame_type: u8,
+    /// Set by setup_past_independence; cleared once consumed by the decoder (PrevSegmentIds reset).
+    pub reset_segment_map: bool,
+}
+
+impl Default for HeaderState {
+    fn default() -> Self {
+        let fc = FrameContext::default();
+        HeaderState {
+            contexts: [fc.clone(), fc.clone(), fc.clone(), fc],
+            lf: LoopFilterParams { ref_deltas: [1, 0, -1, -1], delta_enabled: true, ..Default::default() },
+            seg: Segmentation::default(),
+            color: ColorConfig::default(),
+            last_frame_type: KEY_FRAME,
+            frame_type: KEY_FRAME,
+            reset_segment_map: false,
+        }
+    }
+}
+
+fn read_s(r: &mut BitReader, bits: u32) -> Result<i32> {
+    let v = r.read_bits(bits)? as i32;
+    Ok(if r.read_flag()? { -v } else { v })
+}
+
+fn read_delta_q(r: &mut BitReader) -> Result<i8> {
+    Ok(if r.read_flag()? { read_s(r, 4)? as i8 } else { 0 })
+}
+
+fn read_prob(r: &mut BitReader) -> Result<u8> {
+    Ok(if r.read_flag()? { r.read_bits(8)? as u8 } else { 255 })
+}
+
+fn frame_sync_code(r: &mut BitReader) -> Result<()> {
+    let (a, b, c) = (r.read_bits(8)?, r.read_bits(8)?, r.read_bits(8)?);
+    ensure!(a == 0x49 && b == 0x83 && c == 0x42, "invalid frame sync code");
+    Ok(())
+}
+
+fn color_config(r: &mut BitReader, profile: u8) -> Result<ColorConfig> {
+    let bit_depth = if profile >= 2 { if r.read_flag()? { 12 } else { 10 } } else { 8 };
+    let color_space = r.read_bits(3)? as u8;
+    let mut c = ColorConfig { bit_depth, color_space, color_range: true, subsampling_x: true, subsampling_y: true };
+    if color_space != 7 {
+        c.color_range = r.read_flag()?;
+        if profile == 1 || profile == 3 {
+            c.subsampling_x = r.read_flag()?;
+            c.subsampling_y = r.read_flag()?;
+            ensure!(!(c.subsampling_x && c.subsampling_y), "4:2:0 subsampling in profile {profile}");
+            ensure!(!r.read_flag()?, "reserved bit set in color config");
+        }
+    } else {
+        ensure!(profile == 1 || profile == 3, "RGB color space in profile {profile}");
+        c.subsampling_x = false;
+        c.subsampling_y = false;
+        ensure!(!r.read_flag()?, "reserved bit set in color config");
+    }
+    Ok(c)
+}
+
+fn frame_size(r: &mut BitReader, h: &mut FrameHeader) -> Result<()> {
+    h.width = r.read_bits(16)? + 1;
+    h.height = r.read_bits(16)? + 1;
+    Ok(())
+}
+
+fn render_size(r: &mut BitReader, h: &mut FrameHeader) -> Result<()> {
+    if r.read_flag()? {
+        h.render_width = r.read_bits(16)? + 1;
+        h.render_height = r.read_bits(16)? + 1;
+    } else {
+        h.render_width = h.width;
+        h.render_height = h.height;
+    }
+    Ok(())
+}
+
+fn compute_image_size(h: &mut FrameHeader) {
+    h.mi_cols = (h.width + 7) >> 3;
+    h.mi_rows = (h.height + 7) >> 3;
+    h.sb64_cols = (h.mi_cols + 7) >> 3;
+    h.sb64_rows = (h.mi_rows + 7) >> 3;
+}
+
+/// setup_past_independence (7.2): resets segmentation features, loop filter deltas and the
+/// probabilities of `fc`.
+fn setup_past_independence(st: &mut HeaderState, fc: &mut FrameContext) {
+    st.seg.feature_data = [[0; 4]; 8];
+    st.seg.feature_enabled = [[false; 4]; 8];
+    st.seg.abs_or_delta_update = false;
+    st.lf.delta_enabled = true;
+    st.lf.ref_deltas = [1, 0, -1, -1];
+    st.lf.mode_deltas = [0, 0];
+    st.reset_segment_map = true;
+    *fc = FrameContext::default();
+}
+
+/// Parse the uncompressed header (6.2). `refs` gives the sizes of the eight reference slots.
+/// Updates the persistent state (probability contexts on reset, loop filter deltas,
+/// segmentation, colour configuration).
+pub fn parse_uncompressed(data: &[u8], st: &mut HeaderState, refs: &[Option<RefInfo>; 8]) -> Result<FrameHeader> {
+    let mut r = BitReader::new(data);
+    let mut h = FrameHeader::default();
+    ensure!(r.read_bits(2)? == 2, "invalid frame marker");
+    let lo = r.read_bits(1)? as u8;
+    let hi = r.read_bits(1)? as u8;
+    h.profile = (hi << 1) | lo;
+    if h.profile == 3 {
+        ensure!(r.read_bits(1)? == 0, "reserved bit set after profile");
+    }
+    h.show_existing_frame = r.read_flag()?;
+    if h.show_existing_frame {
+        h.frame_to_show_map_idx = r.read_bits(3)? as u8;
+        h.show_frame = true;
+        h.uncompressed_size = r.position().div_ceil(8);
+        return Ok(h);
+    }
+    st.last_frame_type = st.frame_type;
+    h.frame_type = r.read_bits(1)? as u8;
+    h.show_frame = r.read_flag()?;
+    h.error_resilient_mode = r.read_flag()?;
+    if h.frame_type == KEY_FRAME {
+        frame_sync_code(&mut r)?;
+        h.color = color_config(&mut r, h.profile)?;
+        frame_size(&mut r, &mut h)?;
+        render_size(&mut r, &mut h)?;
+        h.refresh_frame_flags = 0xff;
+        h.frame_is_intra = true;
+    } else {
+        h.intra_only = if h.show_frame { false } else { r.read_flag()? };
+        h.frame_is_intra = h.intra_only;
+        h.reset_frame_context = if h.error_resilient_mode { 0 } else { r.read_bits(2)? as u8 };
+        if h.intra_only {
+            frame_sync_code(&mut r)?;
+            h.color = if h.profile > 0 {
+                color_config(&mut r, h.profile)?
+            } else {
+                ColorConfig { bit_depth: 8, color_space: 1, color_range: false, subsampling_x: true, subsampling_y: true }
+            };
+            h.refresh_frame_flags = r.read_bits(8)? as u8;
+            frame_size(&mut r, &mut h)?;
+            render_size(&mut r, &mut h)?;
+        } else {
+            h.color = st.color;
+            h.refresh_frame_flags = r.read_bits(8)? as u8;
+            for i in 0..3 {
+                h.ref_frame_idx[i] = r.read_bits(3)? as u8;
+                h.ref_frame_sign_bias[LAST_FRAME as usize + i] = r.read_flag()?;
+            }
+            // frame_size_with_refs (6.2.5)
+            let mut found = false;
+            for i in 0..3 {
+                if r.read_flag()? {
+                    let idx = h.ref_frame_idx[i] as usize;
+                    let Some(info) = refs[idx] else {
+                        return Err(Error::MissingReference(format!("frame size from empty slot {idx}")));
+                    };
+                    h.width = info.width;
+                    h.height = info.height;
+                    found = true;
+                    break;
+                }
+            }
+            if !found {
+                frame_size(&mut r, &mut h)?;
+            }
+            h.size_from_ref = found;
+            render_size(&mut r, &mut h)?;
+            h.allow_high_precision_mv = r.read_flag()?;
+            // read_interpolation_filter (6.2.7)
+            h.interp_filter = if r.read_flag()? { SWITCHABLE } else { LITERAL_TO_TYPE[r.read_bits(2)? as usize] };
+        }
+    }
+    compute_image_size(&mut h);
+    if !h.error_resilient_mode {
+        h.refresh_frame_context = r.read_flag()?;
+        h.frame_parallel_decoding_mode = r.read_flag()?;
+    } else {
+        h.refresh_frame_context = false;
+        h.frame_parallel_decoding_mode = true;
+    }
+    h.frame_context_idx = r.read_bits(2)? as u8;
+    if h.frame_is_intra || h.error_resilient_mode {
+        let mut fc = FrameContext::default();
+        setup_past_independence(st, &mut fc);
+        if h.frame_type == KEY_FRAME || h.error_resilient_mode || h.reset_frame_context == 3 {
+            for c in st.contexts.iter_mut() {
+                *c = fc.clone();
+            }
+        } else if h.reset_frame_context == 2 {
+            st.contexts[h.frame_context_idx as usize] = fc.clone();
+        }
+        h.frame_context_idx = 0;
+    }
+    // loop_filter_params (6.2.8)
+    st.lf.level = r.read_bits(6)? as u8;
+    st.lf.sharpness = r.read_bits(3)? as u8;
+    st.lf.delta_enabled = r.read_flag()?;
+    if st.lf.delta_enabled && r.read_flag()? {
+        for i in 0..4 {
+            if r.read_flag()? {
+                st.lf.ref_deltas[i] = read_s(&mut r, 6)? as i8;
+            }
+        }
+        for i in 0..2 {
+            if r.read_flag()? {
+                st.lf.mode_deltas[i] = read_s(&mut r, 6)? as i8;
+            }
+        }
+    }
+    // quantization_params (6.2.9)
+    h.base_q_idx = r.read_bits(8)? as u8;
+    h.delta_q_y_dc = read_delta_q(&mut r)?;
+    h.delta_q_uv_dc = read_delta_q(&mut r)?;
+    h.delta_q_uv_ac = read_delta_q(&mut r)?;
+    h.lossless = h.base_q_idx == 0 && h.delta_q_y_dc == 0 && h.delta_q_uv_dc == 0 && h.delta_q_uv_ac == 0;
+    // segmentation_params (6.2.11)
+    let seg = &mut st.seg;
+    seg.enabled = r.read_flag()?;
+    seg.update_map = false;
+    seg.temporal_update = false;
+    if seg.enabled {
+        seg.update_map = r.read_flag()?;
+        if seg.update_map {
+            for i in 0..7 {
+                seg.tree_probs[i] = read_prob(&mut r)?;
+            }
+            seg.temporal_update = r.read_flag()?;
+            for i in 0..3 {
+                seg.pred_probs[i] = if seg.temporal_update { read_prob(&mut r)? } else { 255 };
+            }
+        }
+        if r.read_flag()? {
+            seg.abs_or_delta_update = r.read_flag()?;
+            for i in 0..MAX_SEGMENTS {
+                for j in 0..4 {
+                    let mut value = 0i32;
+                    let enabled = r.read_flag()?;
+                    seg.feature_enabled[i][j] = enabled;
+                    if enabled {
+                        value = r.read_bits(SEGMENTATION_FEATURE_BITS[j])? as i32;
+                        if SEGMENTATION_FEATURE_SIGNED[j] && r.read_flag()? {
+                            value = -value;
+                        }
+                    }
+                    seg.feature_data[i][j] = value as i16;
+                }
+            }
+        }
+    }
+    // tile_info (6.2.13)
+    let mut min_log2 = 0;
+    while (MAX_TILE_WIDTH_B64 << min_log2) < h.sb64_cols {
+        min_log2 += 1;
+    }
+    let mut max_log2 = 1;
+    while (h.sb64_cols >> max_log2) >= MIN_TILE_WIDTH_B64 {
+        max_log2 += 1;
+    }
+    max_log2 -= 1;
+    h.tile_cols_log2 = min_log2;
+    while h.tile_cols_log2 < max_log2 {
+        if r.read_flag()? {
+            h.tile_cols_log2 += 1;
+        } else {
+            break;
+        }
+    }
+    h.tile_rows_log2 = r.read_bits(1)?;
+    if h.tile_rows_log2 == 1 {
+        h.tile_rows_log2 += r.read_bits(1)?;
+    }
+    h.header_size_in_bytes = r.read_bits(16)?;
+    // trailing_bits
+    h.uncompressed_size = r.position().div_ceil(8);
+    if h.frame_is_intra {
+        st.color = h.color;
+    }
+    st.frame_type = h.frame_type;
+    ensure!(h.header_size_in_bytes > 0, "empty compressed header");
+    Ok(h)
+}
+
+/// diff_update_prob (6.3.3).
+fn diff_update_prob(bd: &mut BoolDecoder, prob: &mut u8) {
+    if bd.read_bool(252) {
+        let delta = decode_term_subexp(bd);
+        *prob = inv_remap_prob(delta, *prob);
+    }
+}
+
+fn decode_term_subexp(bd: &mut BoolDecoder) -> usize {
+    if bd.read_literal(1) == 0 {
+        return bd.read_literal(4) as usize;
+    }
+    if bd.read_literal(1) == 0 {
+        return bd.read_literal(4) as usize + 16;
+    }
+    if bd.read_literal(1) == 0 {
+        return bd.read_literal(5) as usize + 32;
+    }
+    let v = bd.read_literal(7) as usize;
+    if v < 65 {
+        return v + 64;
+    }
+    let bit = bd.read_literal(1) as usize;
+    (v << 1) - 1 + bit
+}
+
+fn inv_recenter_nonneg(v: i32, m: i32) -> i32 {
+    if v > 2 * m {
+        v
+    } else if v & 1 != 0 {
+        m - ((v + 1) >> 1)
+    } else {
+        m + (v >> 1)
+    }
+}
+
+fn inv_remap_prob(delta: usize, prob: u8) -> u8 {
+    let v = INV_MAP_TABLE[delta.min(254)] as i32;
+    let m = prob as i32 - 1;
+    let r = if (m << 1) <= 255 { 1 + inv_recenter_nonneg(v, m) } else { 255 - inv_recenter_nonneg(v, 255 - 1 - m) };
+    r.clamp(1, 255) as u8
+}
+
+/// update_mv_prob (6.3.17).
+fn update_mv_prob(bd: &mut BoolDecoder, prob: &mut u8) {
+    if bd.read_bool(252) {
+        *prob = ((bd.read_literal(7) << 1) | 1) as u8;
+    }
+}
+
+/// Parse the compressed header (6.3) into `h` and the probabilities `fc`.
+pub fn parse_compressed(data: &[u8], h: &mut FrameHeader, fc: &mut FrameContext) -> Result<()> {
+    let mut bd = BoolDecoder::new(data);
+    // read_tx_mode (6.3.1)
+    h.tx_mode = if h.lossless {
+        0
+    } else {
+        let mut m = bd.read_literal(2) as u8;
+        if m == 3 {
+            m += bd.read_literal(1) as u8;
+        }
+        m
+    };
+    if h.tx_mode == TX_MODE_SELECT {
+        for i in 0..2 {
+            diff_update_prob(&mut bd, &mut fc.tx[1][i][0]);
+        }
+        for i in 0..2 {
+            for j in 0..2 {
+                diff_update_prob(&mut bd, &mut fc.tx[2][i][j]);
+            }
+        }
+        for i in 0..2 {
+            for j in 0..3 {
+                diff_update_prob(&mut bd, &mut fc.tx[3][i][j]);
+            }
+        }
+    }
+    // read_coef_probs (6.3.7)
+    let max_tx = TX_MODE_TO_BIGGEST_TX_SIZE[h.tx_mode as usize] as usize;
+    for tx in 0..=max_tx {
+        if bd.read_literal(1) == 1 {
+            for i in 0..2 {
+                for j in 0..2 {
+                    for k in 0..6 {
+                        let max_l = if k == 0 { 3 } else { 6 };
+                        for l in 0..max_l {
+                            for m in 0..3 {
+                                diff_update_prob(&mut bd, &mut fc.coef[tx][i][j][k][l][m]);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    for i in 0..3 {
+        diff_update_prob(&mut bd, &mut fc.skip[i]);
+    }
+    if !h.frame_is_intra {
+        for i in 0..7 {
+            for j in 0..3 {
+                diff_update_prob(&mut bd, &mut fc.inter_mode[i][j]);
+            }
+        }
+        if h.interp_filter == SWITCHABLE {
+            for j in 0..4 {
+                for i in 0..2 {
+                    diff_update_prob(&mut bd, &mut fc.interp_filter[j][i]);
+                }
+            }
+        }
+        for i in 0..4 {
+            diff_update_prob(&mut bd, &mut fc.is_inter[i]);
+        }
+        // frame_reference_mode (6.3.12)
+        let bias = h.ref_frame_sign_bias;
+        let compound_allowed = bias[2] != bias[1] || bias[3] != bias[1];
+        h.reference_mode = 0;
+        if compound_allowed {
+            if bd.read_literal(1) == 1 {
+                h.reference_mode = if bd.read_literal(1) == 1 { 2 } else { 1 };
+            }
+            // setup_compound_reference_mode (6.3.18)
+            if bias[LAST_FRAME as usize] == bias[GOLDEN_FRAME as usize] {
+                h.comp_fixed_ref = ALTREF_FRAME;
+                h.comp_var_ref = [LAST_FRAME, GOLDEN_FRAME];
+            } else if bias[LAST_FRAME as usize] == bias[ALTREF_FRAME as usize] {
+                h.comp_fixed_ref = GOLDEN_FRAME;
+                h.comp_var_ref = [LAST_FRAME, ALTREF_FRAME];
+            } else {
+                h.comp_fixed_ref = LAST_FRAME;
+                h.comp_var_ref = [GOLDEN_FRAME, ALTREF_FRAME];
+            }
+        }
+        // frame_reference_mode_probs (6.3.13)
+        if h.reference_mode == 2 {
+            for i in 0..5 {
+                diff_update_prob(&mut bd, &mut fc.comp_mode[i]);
+            }
+        }
+        if h.reference_mode != 1 {
+            for i in 0..5 {
+                diff_update_prob(&mut bd, &mut fc.single_ref[i][0]);
+                diff_update_prob(&mut bd, &mut fc.single_ref[i][1]);
+            }
+        }
+        if h.reference_mode != 0 {
+            for i in 0..5 {
+                diff_update_prob(&mut bd, &mut fc.comp_ref[i]);
+            }
+        }
+        for i in 0..4 {
+            for j in 0..9 {
+                diff_update_prob(&mut bd, &mut fc.y_mode[i][j]);
+            }
+        }
+        for i in 0..16 {
+            for j in 0..3 {
+                diff_update_prob(&mut bd, &mut fc.partition[i][j]);
+            }
+        }
+        // mv_probs (6.3.16)
+        for j in 0..3 {
+            update_mv_prob(&mut bd, &mut fc.mv_joint[j]);
+        }
+        for i in 0..2 {
+            update_mv_prob(&mut bd, &mut fc.mv_sign[i]);
+            for j in 0..10 {
+                update_mv_prob(&mut bd, &mut fc.mv_class[i][j]);
+            }
+            update_mv_prob(&mut bd, &mut fc.mv_class0_bit[i]);
+            for j in 0..10 {
+                update_mv_prob(&mut bd, &mut fc.mv_bits[i][j]);
+            }
+        }
+        for i in 0..2 {
+            for j in 0..2 {
+                for k in 0..3 {
+                    update_mv_prob(&mut bd, &mut fc.mv_class0_fr[i][j][k]);
+                }
+            }
+            for k in 0..3 {
+                update_mv_prob(&mut bd, &mut fc.mv_fr[i][k]);
+            }
+        }
+        if h.allow_high_precision_mv {
+            for i in 0..2 {
+                update_mv_prob(&mut bd, &mut fc.mv_class0_hp[i]);
+                update_mv_prob(&mut bd, &mut fc.mv_hp[i]);
+            }
+        }
+    }
+    Ok(())
+}
+
+/// Superframe index parsing (Annex B): the frames of a chunk.
+pub fn split_superframe(data: &[u8]) -> Vec<&[u8]> {
+    if let Some(&last) = data.last()
+        && last & 0xe0 == 0xc0
+    {
+        let sz_bytes = ((last >> 3) & 3) as usize + 1;
+        let num = (last & 7) as usize + 1;
+        let index_size = 2 + num * sz_bytes;
+        if data.len() >= index_size && data[data.len() - index_size] == last {
+            let mut frames = Vec::with_capacity(num);
+            let mut pos = 0usize;
+            let mut p = data.len() - index_size + 1;
+            let end = data.len() - index_size;
+            for _ in 0..num {
+                let mut sz = 0usize;
+                for b in 0..sz_bytes {
+                    sz |= (data[p + b] as usize) << (8 * b);
+                }
+                p += sz_bytes;
+                if pos + sz > end {
+                    frames.push(&data[pos..end]);
+                    return frames;
+                }
+                frames.push(&data[pos..pos + sz]);
+                pos += sz;
+            }
+            return frames;
+        }
+    }
+    vec![data]
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn superframe_index() {
+        // Two frames of 3 and 2 bytes, 1 byte per size.
+        let mut d = vec![1u8, 2, 3, 4, 5];
+        let marker = 0xc0 | 1; // 2 frames, 1 byte sizes
+        d.extend([marker, 3, 2, marker]);
+        let f = split_superframe(&d);
+        assert_eq!(f, vec![&[1u8, 2, 3][..], &[4u8, 5][..]]);
+        // Not a superframe: last byte is a marker but the first index byte does not match.
+        let d2 = vec![9u8, 9, 0xc1];
+        assert_eq!(split_superframe(&d2), vec![&d2[..]]);
+    }
+
+    #[test]
+    fn inv_remap_is_bijective_per_prob() {
+        for p in 1..=255u8 {
+            let mut seen = std::collections::HashSet::new();
+            for d in 0..254 {
+                seen.insert(inv_remap_prob(d, p));
+            }
+            // Every other probability value is reachable.
+            assert!(seen.len() >= 253, "p {p}: {}", seen.len());
+        }
+    }
+}
diff --git a/crates/vp9/src/inter.rs b/crates/vp9/src/inter.rs
new file mode 100644
index 000000000..0598c5d87
--- /dev/null
+++ b/crates/vp9/src/inter.rs
@@ -0,0 +1,234 @@
+//! Block inter prediction process (8.5.2.4): separable 8-tap sub-sample interpolation with edge
+//! clamping, for unscaled (step 16) and scaled references.
+
+use crate::tables::SUBPEL_FILTERS;
+
+/// Filter taps of `filter` (0..3) at sub-sample position `frac` (0..15).
+#[inline(always)]
+fn taps(filter: u8, frac: usize) -> &'static [i16] {
+    let o = (filter as usize * 16 + frac) * 8;
+    &SUBPEL_FILTERS[o..o + 8]
+}
+
+/// A reference plane: samples addressed `data[y * stride + x]`, valid for x <= last_x, y <= last_y.
+pub struct RefPlane<'a> {
+    pub data: &'a [u16],
+    pub stride: usize,
+    pub last_x: i32,
+    pub last_y: i32,
+}
+
+/// Predict a `w` x `h` block whose top-left sample is at (`x`, `y`) in 1/16 sample units of the
+/// reference, stepping `step_x` / `step_y` (16 = unscaled). Output samples go to `out` (stride
+/// `w`). `tmp` must hold at least `(h * step_y / 16 + 8) * w` entries, `win` at least
+/// `(w + 7) * (h + 7)` (edge-clamped source window).
+#[allow(clippy::too_many_arguments)]
+pub fn predict(
+    r: &RefPlane,
+    x: i32,
+    y: i32,
+    step_x: i32,
+    step_y: i32,
+    w: usize,
+    h: usize,
+    filter: u8,
+    bit_depth: u8,
+    out: &mut [u16],
+    tmp: &mut [u16],
+    win: &mut [u16],
+) {
+    if step_x == 16 && step_y == 16 {
+        predict_unscaled(r, x, y, w, h, filter, bit_depth, out, tmp, win);
+    } else {
+        predict_scaled(r, x, y, step_x, step_y, w, h, filter, bit_depth, out, tmp);
+    }
+}
+
+/// Copy the (w + 7) x (h + 7) source window starting at (x0 - 3, y0 - 3) with edge clamping.
+fn fetch_window(r: &RefPlane, x0: i32, y0: i32, w: usize, h: usize, win: &mut [u16]) -> usize {
+    let ws = w + 7;
+    for row in 0..h + 7 {
+        let yy = (y0 - 3 + row as i32).clamp(0, r.last_y) as usize;
+        let src = &r.data[yy * r.stride..];
+        let dst = &mut win[row * ws..row * ws + ws];
+        let xs = x0 - 3;
+        if xs >= 0 && xs + ws as i32 - 1 <= r.last_x {
+            dst.copy_from_slice(&src[xs as usize..xs as usize + ws]);
+        } else {
+            for (c, d) in dst.iter_mut().enumerate() {
+                *d = src[(xs + c as i32).clamp(0, r.last_x) as usize];
+            }
+        }
+    }
+    ws
+}
+
+#[allow(clippy::too_many_arguments)]
+fn predict_unscaled(r: &RefPlane, x: i32, y: i32, w: usize, h: usize, filter: u8, bit_depth: u8, out: &mut [u16], tmp: &mut [u16], win: &mut [u16]) {
+    let (x0, y0) = (x >> 4, y >> 4);
+    let (fx, fy) = ((x & 15) as usize, (y & 15) as usize);
+    let max = (1i32 << bit_depth) - 1;
+    let inside = x0 - 3 >= 0 && y0 - 3 >= 0 && x0 + w as i32 + 4 <= r.last_x && y0 + h as i32 + 4 <= r.last_y;
+    // Source view with origin at (x0 - 3, y0 - 3).
+    let (src, ss, so): (&[u16], usize, usize) = if inside {
+        (r.data, r.stride, (y0 - 3) as usize * r.stride + (x0 - 3) as usize)
+    } else {
+        let ws = fetch_window(r, x0, y0, w, h, win);
+        (&win[..], ws, 0)
+    };
+    match (fx, fy) {
+        (0, 0) => {
+            for i in 0..h {
+                let s = so + (i + 3) * ss + 3;
+                out[i * w..i * w + w].copy_from_slice(&src[s..s + w]);
+            }
+        }
+        (_, 0) => {
+            let f = taps(filter, fx);
+            for i in 0..h {
+                filter_h(&src[so + (i + 3) * ss..], f, max, &mut out[i * w..i * w + w]);
+            }
+        }
+        (0, _) => {
+            let f = taps(filter, fy);
+            for i in 0..h {
+                filter_v(&src[so + i * ss + 3..], ss, f, max, &mut out[i * w..i * w + w]);
+            }
+        }
+        _ => {
+            let fh = taps(filter, fx);
+            let fv = taps(filter, fy);
+            for i in 0..h + 7 {
+                filter_h(&src[so + i * ss..], fh, max, &mut tmp[i * w..i * w + w]);
+            }
+            for i in 0..h {
+                filter_v(&tmp[i * w..], w, fv, max, &mut out[i * w..i * w + w]);
+            }
+        }
+    }
+}
+
+/// Horizontal 8-tap filter of one row: `o[j]` from `s[j..j + 8]`. The taps are the outer loop
+/// so that the row vectorizes (same sums, same order of the exact integer additions).
+#[inline(always)]
+fn filter_h(s: &[u16], f: &[i16], max: i32, o: &mut [u16]) {
+    match o.len() {
+        4 => filter_h_n::<4>(s, f, max, o),
+        8 => filter_h_n::<8>(s, f, max, o),
+        16 => filter_h_n::<16>(s, f, max, o),
+        32 => filter_h_n::<32>(s, f, max, o),
+        64 => filter_h_n::<64>(s, f, max, o),
+        _ => {
+            for (j, d) in o.iter_mut().enumerate() {
+                let acc: i32 = (0..8).map(|t| f[t] as i32 * s[j + t] as i32).sum();
+                *d = ((acc + 64) >> 7).clamp(0, max) as u16;
+            }
+        }
+    }
+}
+
+#[inline(always)]
+fn filter_h_n<const W: usize>(s: &[u16], f: &[i16], max: i32, o: &mut [u16]) {
+    let o: &mut [u16; W] = (&mut o[..W]).try_into().expect("row");
+    let mut acc = [64i32; W];
+    for t in 0..8 {
+        let c = f[t] as i32;
+        let p: &[u16; W] = s[t..t + W].try_into().expect("row");
+        for j in 0..W {
+            acc[j] += c * p[j] as i32;
+        }
+    }
+    for j in 0..W {
+        o[j] = (acc[j] >> 7).clamp(0, max) as u16;
+    }
+}
+
+/// Vertical 8-tap filter of one row: `o[j]` from `s[j + t * ss]`, t = 0..8.
+#[inline(always)]
+fn filter_v(s: &[u16], ss: usize, f: &[i16], max: i32, o: &mut [u16]) {
+    match o.len() {
+        4 => filter_v_n::<4>(s, ss, f, max, o),
+        8 => filter_v_n::<8>(s, ss, f, max, o),
+        16 => filter_v_n::<16>(s, ss, f, max, o),
+        32 => filter_v_n::<32>(s, ss, f, max, o),
+        64 => filter_v_n::<64>(s, ss, f, max, o),
+        _ => {
+            for (j, d) in o.iter_mut().enumerate() {
+                let acc: i32 = (0..8).map(|t| f[t] as i32 * s[j + t * ss] as i32).sum();
+                *d = ((acc + 64) >> 7).clamp(0, max) as u16;
+            }
+        }
+    }
+}
+
+#[inline(always)]
+fn filter_v_n<const W: usize>(s: &[u16], ss: usize, f: &[i16], max: i32, o: &mut [u16]) {
+    let o: &mut [u16; W] = (&mut o[..W]).try_into().expect("row");
+    let mut acc = [64i32; W];
+    for t in 0..8 {
+        let c = f[t] as i32;
+        let p: &[u16; W] = s[t * ss..t * ss + W].try_into().expect("row");
+        for j in 0..W {
+            acc[j] += c * p[j] as i32;
+        }
+    }
+    for j in 0..W {
+        o[j] = (acc[j] >> 7).clamp(0, max) as u16;
+    }
+}
+
+/// General process of 8.5.2.4 (any step).
+#[allow(clippy::too_many_arguments)]
+fn predict_scaled(r: &RefPlane, x: i32, y: i32, step_x: i32, step_y: i32, w: usize, h: usize, filter: u8, bit_depth: u8, out: &mut [u16], tmp: &mut [u16]) {
+    let max = (1i32 << bit_depth) - 1;
+    let ih = ((((h as i32 - 1) * step_y + 15) >> 4) + 8) as usize;
+    for row in 0..ih {
+        let yy = ((y >> 4) + row as i32 - 3).clamp(0, r.last_y) as usize;
+        let src = &r.data[yy * r.stride..];
+        for c in 0..w {
+            let p = x + step_x * c as i32;
+            let f = taps(filter, (p & 15) as usize);
+            let mut acc = 0i32;
+            for t in 0..8 {
+                acc += f[t] as i32 * src[((p >> 4) + t as i32 - 3).clamp(0, r.last_x) as usize] as i32;
+            }
+            tmp[row * w + c] = ((acc + 64) >> 7).clamp(0, max) as u16;
+        }
+    }
+    for rr in 0..h {
+        let p = (y & 15) + step_y * rr as i32;
+        let f = taps(filter, (p & 15) as usize);
+        let base = (p >> 4) as usize;
+        for c in 0..w {
+            let mut acc = 0i32;
+            for t in 0..8 {
+                acc += f[t] as i32 * tmp[(base + t) * w + c] as i32;
+            }
+            out[rr * w + c] = ((acc + 64) >> 7).clamp(0, max) as u16;
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn scaled_path_with_unit_step_matches_unscaled() {
+        let (w, h) = (40usize, 30usize);
+        let data: Vec<u16> = (0..w * h).map(|i| ((i * 37 + (i / w) * 11) % 256) as u16).collect();
+        let r = RefPlane { data: &data, stride: w, last_x: w as i32 - 1, last_y: h as i32 - 1 };
+        let mut tmp = vec![0u16; 80 * 80];
+        for filter in 0..4u8 {
+            for &(x, y) in &[(0, 0), (5, 3), (16 * 7 + 5, 16 * 9 + 11), (-40, -3), (16 * 36 + 1, 16 * 25 + 15), (16 * 10, 16 * 10 + 8)] {
+                for &(bw, bh) in &[(4usize, 4usize), (8, 8), (16, 8)] {
+                    let mut a = vec![0u16; bw * bh];
+                    let mut b = vec![0u16; bw * bh];
+                    predict_unscaled(&r, x, y, bw, bh, filter, 8, &mut a, &mut tmp, &mut [0u16; 71 * 71]);
+                    predict_scaled(&r, x, y, 16, 16, bw, bh, filter, 8, &mut b, &mut tmp);
+                    assert_eq!(a, b, "filter {filter} pos ({x},{y}) {bw}x{bh}");
+                }
+            }
+        }
+    }
+}
diff --git a/crates/vp9/src/intra.rs b/crates/vp9/src/intra.rs
new file mode 100644
index 000000000..9c797eea3
--- /dev/null
+++ b/crates/vp9/src/intra.rs
@@ -0,0 +1,214 @@
+//! Intra prediction process (8.5.1).
+
+use crate::tables::*;
+
+/// Edge availability and geometry of one intra-predicted transform block.
+pub struct IntraEdge {
+    pub have_left: bool,
+    pub have_above: bool,
+    pub not_on_right: bool,
+    pub tx_size: u8,
+    /// Last valid column / row of the plane (in plane coordinates).
+    pub max_x: usize,
+    pub max_y: usize,
+    pub bit_depth: u8,
+}
+
+/// Predict a `4 << tx_size` square block at (`x`, `y`) of a plane buffer. `buf` is addressed as
+/// `buf[y * stride + x - x_off]` (the buffer may be a tile-column strip starting at column `x_off`).
+pub fn predict(buf: &mut [u16], stride: usize, x_off: usize, x: usize, y: usize, mode: u8, e: &IntraEdge) {
+    let log2 = e.tx_size as usize + 2;
+    let size = 1usize << log2;
+    let base = 1i32 << (e.bit_depth - 1);
+    let at = |xx: usize, yy: usize| yy * stride + xx - x_off;
+    // aboveRow[-1..2*size) stored at above[0..2*size+1); leftCol[0..size).
+    let mut above = [0i32; 65];
+    let mut left = [0i32; 32];
+    if !e.have_above {
+        above[1..=2 * size].fill(base - 1);
+    } else {
+        let row = (y - 1) * stride;
+        for i in 0..size {
+            above[1 + i] = buf[row + (x + i).min(e.max_x) - x_off] as i32;
+        }
+        if e.not_on_right && e.tx_size == 0 {
+            for i in size..2 * size {
+                above[1 + i] = buf[row + (x + i).min(e.max_x) - x_off] as i32;
+            }
+        } else {
+            let v = above[size];
+            above[1 + size..=2 * size].fill(v);
+        }
+    }
+    above[0] = if e.have_above && e.have_left {
+        buf[at((x - 1).min(e.max_x), y - 1)] as i32
+    } else if e.have_above {
+        base + 1
+    } else {
+        base - 1
+    };
+    if e.have_left {
+        for i in 0..size {
+            left[i] = buf[at(x - 1, (y + i).min(e.max_y))] as i32;
+        }
+    } else {
+        left[..size].fill(base + 1);
+    }
+    let a = |i: isize| above[(i + 1) as usize];
+    let max = (1i32 << e.bit_depth) - 1;
+    let o = at(x, y);
+    let mut put = |i: usize, j: usize, v: i32| buf[o + i * stride + j] = v as u16;
+    let r1 = |v: i32| (v + 1) >> 1;
+    let r2 = |v: i32| (v + 2) >> 2;
+    match mode {
+        V_PRED => {
+            for i in 0..size {
+                for j in 0..size {
+                    put(i, j, a(j as isize));
+                }
+            }
+        }
+        H_PRED => {
+            for i in 0..size {
+                for j in 0..size {
+                    put(i, j, left[i]);
+                }
+            }
+        }
+        D207_PRED => {
+            let mut p = [[0i32; 32]; 32];
+            for j in 0..size {
+                p[size - 1][j] = left[size - 1];
+            }
+            for i in 0..size - 1 {
+                p[i][0] = r1(left[i] + left[i + 1]);
+            }
+            for i in 0..size.saturating_sub(2) {
+                p[i][1] = r2(left[i] + 2 * left[i + 1] + left[i + 2]);
+            }
+            p[size - 2][1] = r2(left[size - 2] + 3 * left[size - 1]);
+            for j in 2..size {
+                for i in (0..size - 1).rev() {
+                    p[i][j] = p[i + 1][j - 2];
+                }
+            }
+            for i in 0..size {
+                for j in 0..size {
+                    put(i, j, p[i][j]);
+                }
+            }
+        }
+        D45_PRED => {
+            for i in 0..size {
+                for j in 0..size {
+                    let k = (i + j) as isize;
+                    let v = if i + j + 2 < 2 * size { r2(a(k) + 2 * a(k + 1) + a(k + 2)) } else { a(2 * size as isize - 1) };
+                    put(i, j, v);
+                }
+            }
+        }
+        D63_PRED => {
+            for i in 0..size {
+                for j in 0..size {
+                    let k = (i / 2 + j) as isize;
+                    let v = if i & 1 == 1 { r2(a(k) + 2 * a(k + 1) + a(k + 2)) } else { r1(a(k) + a(k + 1)) };
+                    put(i, j, v);
+                }
+            }
+        }
+        D117_PRED => {
+            let mut p = [[0i32; 32]; 32];
+            for j in 0..size {
+                p[0][j] = r1(a(j as isize - 1) + a(j as isize));
+            }
+            p[1][0] = r2(left[0] + 2 * a(-1) + a(0));
+            for j in 1..size {
+                p[1][j] = r2(a(j as isize - 2) + 2 * a(j as isize - 1) + a(j as isize));
+            }
+            p[2][0] = r2(a(-1) + 2 * left[0] + left[1]);
+            for i in 3..size {
+                p[i][0] = r2(left[i - 3] + 2 * left[i - 2] + left[i - 1]);
+            }
+            for i in 2..size {
+                for j in 1..size {
+                    p[i][j] = p[i - 2][j - 1];
+                }
+            }
+            for i in 0..size {
+                for j in 0..size {
+                    put(i, j, p[i][j]);
+                }
+            }
+        }
+        D135_PRED => {
+            let mut p = [[0i32; 32]; 32];
+            p[0][0] = r2(left[0] + 2 * a(-1) + a(0));
+            for j in 1..size {
+                p[0][j] = r2(a(j as isize - 2) + 2 * a(j as isize - 1) + a(j as isize));
+            }
+            p[1][0] = r2(a(-1) + 2 * left[0] + left[1]);
+            for i in 2..size {
+                p[i][0] = r2(left[i - 2] + 2 * left[i - 1] + left[i]);
+            }
+            for i in 1..size {
+                for j in 1..size {
+                    p[i][j] = p[i - 1][j - 1];
+                }
+            }
+            for i in 0..size {
+                for j in 0..size {
+                    put(i, j, p[i][j]);
+                }
+            }
+        }
+        D153_PRED => {
+            let mut p = [[0i32; 32]; 32];
+            p[0][0] = r1(left[0] + a(-1));
+            for i in 1..size {
+                p[i][0] = r1(left[i - 1] + left[i]);
+            }
+            p[0][1] = r2(left[0] + 2 * a(-1) + a(0));
+            p[1][1] = r2(a(-1) + 2 * left[0] + left[1]);
+            for i in 2..size {
+                p[i][1] = r2(left[i - 2] + 2 * left[i - 1] + left[i]);
+            }
+            for j in 2..size {
+                p[0][j] = r2(a(j as isize - 3) + 2 * a(j as isize - 2) + a(j as isize - 1));
+            }
+            for i in 1..size {
+                for j in 2..size {
+                    p[i][j] = p[i - 1][j - 2];
+                }
+            }
+            for i in 0..size {
+                for j in 0..size {
+                    put(i, j, p[i][j]);
+                }
+            }
+        }
+        TM_PRED => {
+            for i in 0..size {
+                for j in 0..size {
+                    put(i, j, (a(j as isize) + left[i] - a(-1)).clamp(0, max));
+                }
+            }
+        }
+        _ => {
+            // DC_PRED
+            let v = match (e.have_left, e.have_above) {
+                (true, true) => {
+                    let sum: i32 = left[..size].iter().sum::<i32>() + above[1..=size].iter().sum::<i32>();
+                    (sum + size as i32) >> (log2 + 1)
+                }
+                (true, false) => (left[..size].iter().sum::<i32>() + (1 << (log2 - 1))) >> log2,
+                (false, true) => (above[1..=size].iter().sum::<i32>() + (1 << (log2 - 1))) >> log2,
+                (false, false) => base,
+            };
+            for i in 0..size {
+                for j in 0..size {
+                    put(i, j, v);
+                }
+            }
+        }
+    }
+}
diff --git a/crates/vp9/src/lib.rs b/crates/vp9/src/lib.rs
new file mode 100644
index 000000000..3bdfd2be5
--- /dev/null
+++ b/crates/vp9/src/lib.rs
@@ -0,0 +1,166 @@
+//! Clean-room pure-Rust VP9 decoder, implemented from the public VP9 Bitstream & Decoding Process
+//! Specification (v0.6, WebM project).
+//!
+//! Supported: profiles 0-3 (8 / 10 / 12-bit; 4:2:0, 4:2:2, 4:4:0, 4:4:4), all coding tools:
+//! boolean decoder, forward and backward probability adaptation, segmentation, loop filter with
+//! deltas, all intra modes, inter prediction (8-tap regular / smooth / sharp and bilinear,
+//! scaled references), compound prediction, motion vector prediction, DCT / ADST 4..32 and the
+//! Walsh-Hadamard lossless transform, tiles (tile columns decode in parallel), superframes,
+//! hidden frames, show_existing_frame, intra-only frames, reference frame resizing and error
+//! resilient / frame parallel modes.
+//!
+//! ```no_run
+//! let mut dec = filmcraft_vp9::Decoder::new();
+//! let chunk: Vec<u8> = Vec::new(); // one IVF / WebM frame
+//! for pic in dec.decode(&chunk, 0).unwrap() {
+//!     println!("{}x{} {}-bit", pic.width, pic.height, pic.bit_depth);
+//! }
+//! ```
+
+#![allow(clippy::needless_range_loop, clippy::too_many_arguments)]
+
+mod boolcoder;
+mod decoder;
+mod error;
+mod frame;
+mod header;
+mod inter;
+mod intra;
+mod loopfilter;
+mod probs;
+#[rustfmt::skip]
+#[allow(dead_code)]
+mod spec_tables;
+mod tables;
+mod tile;
+mod transform;
+#[rustfmt::skip]
+#[allow(dead_code, clippy::all)]
+mod transform_gen;
+
+pub use decoder::{DecodeStats, Decoder};
+
+/// Stream parameters read from a key frame's uncompressed header (see [`keyframe_info`]).
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct KeyframeInfo {
+    pub profile: u8,
+    pub width: u32,
+    pub height: u32,
+    pub render_width: u32,
+    pub render_height: u32,
+    pub bit_depth: u32,
+    pub subsampling_x: bool,
+    pub subsampling_y: bool,
+    pub color: ColorInfo,
+}
+
+/// If the first frame of `chunk` (one container sample: a frame or a superframe) is a key frame,
+/// i.e. a random access point, its stream parameters. Intra-only frames and show_existing_frame
+/// are not random access points.
+pub fn keyframe_info(chunk: &[u8]) -> Option<KeyframeInfo> {
+    let first = header::split_superframe(chunk).into_iter().find(|f| !f.is_empty())?;
+    let mut st = header::HeaderState::default();
+    let h = header::parse_uncompressed(first, &mut st, &[None; 8]).ok()?;
+    if h.show_existing_frame || h.frame_type != header::KEY_FRAME {
+        return None;
+    }
+    Some(KeyframeInfo {
+        profile: h.profile,
+        width: h.width,
+        height: h.height,
+        render_width: h.render_width,
+        render_height: h.render_height,
+        bit_depth: h.color.bit_depth as u32,
+        subsampling_x: h.color.subsampling_x,
+        subsampling_y: h.color.subsampling_y,
+        color: ColorInfo { color_space: h.color.color_space, full_range: h.color.color_range },
+    })
+}
+
+/// Whether `chunk` starts with a key frame (decoding can start there).
+pub fn is_keyframe(chunk: &[u8]) -> bool {
+    keyframe_info(chunk).is_some()
+}
+pub use error::{Error, Result};
+
+/// Colour information from the uncompressed header.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct ColorInfo {
+    /// `color_space` (0 unknown, 1 BT.601, 2 BT.709, 3 SMPTE-170, 4 SMPTE-240, 5 BT.2020,
+    /// 6 reserved, 7 sRGB).
+    pub color_space: u8,
+    /// `color_range`: full swing when true, studio swing otherwise.
+    pub full_range: bool,
+}
+
+/// Samples of one plane: 8-bit streams produce `U8`, higher bit depths `U16`.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum Plane {
+    U8(Vec<u8>),
+    U16(Vec<u16>),
+}
+
+impl Plane {
+    pub fn len(&self) -> usize {
+        match self {
+            Plane::U8(v) => v.len(),
+            Plane::U16(v) => v.len(),
+        }
+    }
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+    pub fn as_u8(&self) -> Option<&[u8]> {
+        match self {
+            Plane::U8(v) => Some(v),
+            Plane::U16(_) => None,
+        }
+    }
+    pub fn as_u16(&self) -> Option<&[u16]> {
+        match self {
+            Plane::U8(_) => None,
+            Plane::U16(v) => Some(v),
+        }
+    }
+    /// Sample `i` widened to u16.
+    pub fn get(&self, i: usize) -> u16 {
+        match self {
+            Plane::U8(v) => v[i] as u16,
+            Plane::U16(v) => v[i],
+        }
+    }
+    /// Raw bytes as written by ffmpeg `rawvideo` (8-bit, or 16-bit little endian).
+    pub fn to_le_bytes(&self) -> Vec<u8> {
+        match self {
+            Plane::U8(v) => v.clone(),
+            Plane::U16(v) => v.iter().flat_map(|s| s.to_le_bytes()).collect(),
+        }
+    }
+}
+
+/// A decoded, cropped planar picture.
+#[derive(Clone, Debug)]
+pub struct Picture {
+    /// Frame width / height (decoded size).
+    pub width: u32,
+    pub height: u32,
+    pub chroma_width: u32,
+    pub chroma_height: u32,
+    pub bit_depth: u32,
+    pub subsampling_x: bool,
+    pub subsampling_y: bool,
+    pub y: Plane,
+    pub u: Plane,
+    pub v: Plane,
+    /// Strides in samples.
+    pub y_stride: usize,
+    pub uv_stride: usize,
+    /// `pts` passed to [`Decoder::decode`] with the chunk that produced this picture.
+    pub pts: i64,
+    pub key: bool,
+    pub intra_only: bool,
+    pub color: ColorInfo,
+    /// Intended display size (render_size); has no effect on decoding.
+    pub render_width: u32,
+    pub render_height: u32,
+}
diff --git a/crates/vp9/src/loopfilter.rs b/crates/vp9/src/loopfilter.rs
new file mode 100644
index 000000000..21ad99b4f
--- /dev/null
+++ b/crates/vp9/src/loopfilter.rs
@@ -0,0 +1,368 @@
+//! Loop filter process (8.8).
+
+use crate::frame::{MiGrid, MiInfo};
+use crate::header::{LoopFilterParams, Segmentation};
+use crate::tables::*;
+
+/// Frame-level loop filter setup (8.8.1) plus the per-level limits of 8.8.4.
+pub struct LfFrame {
+    /// LvlLookup[segment_id][ref][modeType].
+    pub lvl: [[[u8; 2]; 4]; 8],
+    /// (limit, blimit, thresh) per filter level.
+    pub limits: [(i32, i32, i32); 64],
+    pub mi_rows: usize,
+    pub mi_cols: usize,
+    pub ss_x: usize,
+    pub ss_y: usize,
+    pub bit_depth: u8,
+}
+
+impl LfFrame {
+    pub fn new(lf: &LoopFilterParams, seg: &Segmentation, mi_rows: usize, mi_cols: usize, ss_x: bool, ss_y: bool, bit_depth: u8) -> LfFrame {
+        let mut lvl = [[[0u8; 2]; 4]; 8];
+        let n_shift = lf.level >> 5;
+        for (seg_id, l) in lvl.iter_mut().enumerate() {
+            let mut lvl_seg = lf.level as i32;
+            if seg.feature_active(seg_id as u8, SEG_LVL_ALT_L) {
+                let d = seg.feature_data[seg_id][SEG_LVL_ALT_L] as i32;
+                lvl_seg = if seg.abs_or_delta_update { d } else { d + lf.level as i32 };
+                lvl_seg = lvl_seg.clamp(0, MAX_LOOP_FILTER);
+            }
+            if !lf.delta_enabled {
+                *l = [[lvl_seg as u8; 2]; 4];
+            } else {
+                let intra = lvl_seg + ((lf.ref_deltas[0] as i32) << n_shift);
+                l[0][0] = intra.clamp(0, MAX_LOOP_FILTER) as u8;
+                l[0][1] = l[0][0];
+                for rf in 1..4 {
+                    for mode in 0..2 {
+                        let v = lvl_seg + ((lf.ref_deltas[rf] as i32) << n_shift) + ((lf.mode_deltas[mode] as i32) << n_shift);
+                        l[rf][mode] = v.clamp(0, MAX_LOOP_FILTER) as u8;
+                    }
+                }
+            }
+        }
+        let mut limits = [(0, 0, 0); 64];
+        let sh = lf.sharpness as i32;
+        let shift = if sh > 4 {
+            2
+        } else if sh > 0 {
+            1
+        } else {
+            0
+        };
+        for (l, e) in limits.iter_mut().enumerate() {
+            let l = l as i32;
+            let limit = if sh > 0 { (l >> shift).clamp(1, 9 - sh) } else { (l >> shift).max(1) };
+            *e = (limit, 2 * (l + 2) + limit, l >> 4);
+        }
+        LfFrame { lvl, limits, mi_rows, mi_cols, ss_x: ss_x as usize, ss_y: ss_y as usize, bit_depth }
+    }
+
+    fn level(&self, mi: &MiInfo) -> u8 {
+        let mode_type = matches!(mi.y_mode, NEARESTMV | NEARMV | NEWMV) as usize;
+        let rf = mi.ref_frame[0].max(0) as usize;
+        self.lvl[mi.seg_id as usize & 7][rf][mode_type]
+    }
+}
+
+/// A mutable view of one plane: sample (x, y) of the plane is `data[(y - oy) * stride + x - ox]`.
+pub struct PlaneView<'a> {
+    pub data: &'a mut [u16],
+    pub stride: usize,
+    pub ox: usize,
+    pub oy: usize,
+}
+
+/// Loop filter one superblock (all planes, both passes) at (`row`, `col`) in MI units (8.8.2).
+pub fn filter_superblock(views: &mut [PlaneView; 3], mi: &MiGrid, f: &LfFrame, row: usize, col: usize) {
+    for (plane, view) in views.iter_mut().enumerate() {
+        for pass in 0..2 {
+            filter_sb_plane(view, mi, f, plane, pass, row, col);
+        }
+    }
+}
+
+fn filter_sb_plane(v: &mut PlaneView, mi: &MiGrid, f: &LfFrame, plane: usize, pass: usize, row: usize, col: usize) {
+    let (sub_x, sub_y) = if plane > 0 { (f.ss_x, f.ss_y) } else { (0, 0) };
+    let (sub, edge_len) = if pass == 0 { (sub_x, 64 >> sub_y) } else { (sub_y, 64 >> sub_x) };
+    let (mi_rows, mi_cols) = (f.mi_rows, f.mi_cols);
+    // Step between the samples across the edge.
+    let across = if pass == 0 { 1isize } else { v.stride as isize };
+    for edge in 0..(16 >> sub) {
+        let mut i = 0;
+        while i < edge_len {
+            // Group of 8 samples sharing loopRow / loopCol.
+            let (x, y) =
+                if pass == 0 { (col * 8 + edge * (4 << sub_x), row * 8 + (i << sub_y)) } else { (col * 8 + (i << sub_x), row * 8 + edge * (4 << sub_y)) };
+            // Skip groups entirely off screen (the varying coordinate is re-checked per sample).
+            if x >= 8 * mi_cols || y >= 8 * mi_rows || (pass == 0 && x == 0) || (pass == 1 && y == 0) {
+                i += 8;
+                continue;
+            }
+            let loop_col = ((x >> 3) >> sub_x) << sub_x;
+            let loop_row = ((y >> 3) >> sub_y) << sub_y;
+            let m = mi.at(loop_row, loop_col);
+            let tx_sz = if plane > 0 {
+                if m.sb_size < BLOCK_8X8 { 0 } else { m.tx_size.min(MAX_TXSIZE[SS_SIZE_LOOKUP[m.sb_size as usize][f.ss_x][f.ss_y].min(12) as usize]) }
+            } else {
+                m.tx_size
+            };
+            let sb_size = if sub == 0 { m.sb_size } else { m.sb_size.max(BLOCK_16X16) } as usize;
+            let is_intra = m.ref_frame[0] <= INTRA_FRAME;
+            // Block sizes are powers of two, so the modulo is a mask.
+            let is_block_edge = if pass == 0 { x & (8 * NUM_8X8_WIDE[sb_size] as usize - 1) == 0 } else { y & (8 * NUM_8X8_HIGH[sb_size] as usize - 1) == 0 };
+            let tx_ok = edge & ((1 << tx_sz) - 1) == 0 && (is_intra || !m.skip);
+            if !is_block_edge && !tx_ok {
+                i += 8;
+                continue;
+            }
+            let lvl = f.level(m);
+            if lvl == 0 {
+                i += 8;
+                continue;
+            }
+            let is32 = edge % 8 == 0;
+            let base_size = if tx_sz == TX_4X4 && is32 { TX_8X8 } else { tx_sz.min(TX_16X16) };
+            let filter_size =
+                if base_size == TX_16X16 && ((pass == 0 && sub_x == 1 && (x >> 3) == mi_cols - 1) || (pass == 1 && sub_y == 1 && (y >> 3) == mi_rows - 1)) {
+                    TX_8X8
+                } else {
+                    base_size
+                };
+            let (limit, blimit, thresh) = f.limits[lvl as usize];
+            // Lanes of the group (the 8 samples along the edge) inside the MI grid.
+            let n = if pass == 0 { (8 * mi_rows - y).div_ceil(1 << sub_y) } else { (8 * mi_cols - x).div_ceil(1 << sub_x) }.min(LANES).min(edge_len - i);
+            // A transform edge is not filtered in the last odd chroma column (8.8.2).
+            let odd_last = pass == 1 && sub_x == 1 && mi_cols & 1 == 1 && edge & 1 == 1;
+            let mut apply = [false; LANES];
+            for (l, a) in apply.iter_mut().enumerate().take(n) {
+                let is_tx_edge = tx_ok && !(odd_last && x + (l << sub_x) + 8 >= mi_cols * 8);
+                *a = is_block_edge || is_tx_edge;
+            }
+            if apply.iter().any(|&a| a) {
+                let px = x >> sub_x;
+                let py = y >> sub_y;
+                let pos = (py - v.oy) * v.stride + px - v.ox;
+                let along = if pass == 0 { v.stride } else { 1 };
+                let lim = Limits { apply, limit, blimit, thresh, filter_size, bit_depth: f.bit_depth };
+                let (d, st) = (&mut *v.data, across as usize);
+                match (f.bit_depth <= 10, filter_size == TX_16X16, pass == 1) {
+                    (true, false, false) => lanes16::filter_group::<4, false>(d, pos, along, st, &lim),
+                    (true, false, true) => lanes16::filter_group::<4, true>(d, pos, along, st, &lim),
+                    (true, true, false) => lanes16::filter_group::<8, false>(d, pos, along, st, &lim),
+                    (true, true, true) => lanes16::filter_group::<8, true>(d, pos, along, st, &lim),
+                    (false, false, false) => lanes32::filter_group::<4, false>(d, pos, along, st, &lim),
+                    (false, false, true) => lanes32::filter_group::<4, true>(d, pos, along, st, &lim),
+                    (false, true, false) => lanes32::filter_group::<8, false>(d, pos, along, st, &lim),
+                    (false, true, true) => lanes32::filter_group::<8, true>(d, pos, along, st, &lim),
+                }
+            }
+            i += 8;
+        }
+    }
+}
+
+/// Samples along an edge filtered together.
+const LANES: usize = 8;
+
+/// Per-group filter parameters.
+struct Limits {
+    apply: [bool; LANES],
+    limit: i32,
+    blimit: i32,
+    thresh: i32,
+    filter_size: u8,
+    bit_depth: u8,
+}
+
+/// The group filter, instantiated for 16-bit lanes (bit depths 8 and 10: every intermediate,
+/// including the 16-tap sums of at most 16 * 1023 + 8, fits) and 32-bit lanes (12-bit).
+macro_rules! group_filter {
+    ($m:ident, $t:ty) => {
+        mod $m {
+            use super::{LANES, Limits};
+            use crate::tables::*;
+            type T = $t;
+
+            /// Sample filtering process (8.8.5) for the up to 8 lanes of a group whose `apply` flag is set.
+            /// Lane `l` has its q0 sample at `pos + l * along`; samples across the edge are `step` apart
+            /// (`ROWS`: `along` is 1, i.e. a horizontal edge). `R` samples on each side are read (8 for
+            /// 16x16 filters, else 4). Every lane is computed with every filter and the result chosen per
+            /// lane (8.8.5.1 decides which), so the arithmetic is branch-free and vectorizes; unmodified
+            /// samples are written back unchanged.
+            #[inline(always)]
+            pub(super) fn filter_group<const R: usize, const ROWS: bool>(d: &mut [u16], pos: usize, along: usize, step: usize, g: &Limits) {
+                let Limits { apply, limit, blimit, thresh, filter_size, bit_depth } = *g;
+                let (limit, blimit, thresh) = (limit as T, blimit as T, thresh as T);
+                // v[8 + k][l] = sample at offset k across the edge in lane l.
+                let mut v = [[0 as T; LANES]; 16];
+                let start = pos - R * step;
+                if ROWS {
+                    for k in 0..2 * R {
+                        let row: &[u16; LANES] = d[start + k * step..start + k * step + LANES].try_into().expect("lanes");
+                        v[8 - R + k] = std::array::from_fn(|l| row[l] as T);
+                    }
+                } else {
+                    for l in 0..LANES {
+                        let s = start + l * along;
+                        let line: &[u16] = &d[s..s + 2 * R];
+                        for k in 0..2 * R {
+                            v[8 - R + k][l] = line[k] as T;
+                        }
+                    }
+                }
+                let shift = bit_depth as u32 - 8;
+                let limit_bd = limit << shift;
+                let blimit_bd = blimit << shift;
+                let thresh_bd = thresh << shift;
+                let one = 1 << shift;
+                let (p3, p2, p1, p0, q0, q1, q2, q3) = (&v[4], &v[5], &v[6], &v[7], &v[8], &v[9], &v[10], &v[11]);
+                // Filter mask process (8.8.5.1), with non-short-circuit `&` so that it vectorizes.
+                let mut mask = [false; LANES];
+                let mut hev = [false; LANES];
+                let mut flat = [false; LANES];
+                let mut flat2 = [false; LANES];
+                let can_flat = filter_size >= TX_8X8;
+                let can_flat2 = R == 8 && filter_size >= TX_16X16;
+                for l in 0..LANES {
+                    let d_p1p0 = (p1[l] - p0[l]).abs();
+                    let d_q1q0 = (q1[l] - q0[l]).abs();
+                    mask[l] = apply[l]
+                        & ((p3[l] - p2[l]).abs() <= limit_bd)
+                        & ((p2[l] - p1[l]).abs() <= limit_bd)
+                        & (d_p1p0 <= limit_bd)
+                        & (d_q1q0 <= limit_bd)
+                        & ((q2[l] - q1[l]).abs() <= limit_bd)
+                        & ((q3[l] - q2[l]).abs() <= limit_bd)
+                        & ((p0[l] - q0[l]).abs() * 2 + (p1[l] - q1[l]).abs() / 2 <= blimit_bd);
+                    hev[l] = (d_p1p0 > thresh_bd) | (d_q1q0 > thresh_bd);
+                    flat[l] = can_flat
+                        & mask[l]
+                        & (d_p1p0 <= one)
+                        & (d_q1q0 <= one)
+                        & ((p2[l] - p0[l]).abs() <= one)
+                        & ((q2[l] - q0[l]).abs() <= one)
+                        & ((p3[l] - p0[l]).abs() <= one)
+                        & ((q3[l] - q0[l]).abs() <= one);
+                }
+                if !mask.iter().fold(false, |a, &m| a | m) {
+                    return;
+                }
+                if can_flat2 {
+                    for l in 0..LANES {
+                        flat2[l] = flat[l]
+                            & ((v[0][l] - p0[l]).abs() <= one)
+                            & ((v[1][l] - p0[l]).abs() <= one)
+                            & ((v[2][l] - p0[l]).abs() <= one)
+                            & ((v[3][l] - p0[l]).abs() <= one)
+                            & ((v[12][l] - q0[l]).abs() <= one)
+                            & ((v[13][l] - q0[l]).abs() <= one)
+                            & ((v[14][l] - q0[l]).abs() <= one)
+                            & ((v[15][l] - q0[l]).abs() <= one);
+                    }
+                }
+                let any_flat = flat.iter().fold(false, |a, &f| a | f);
+                let any_flat2 = flat2.iter().fold(false, |a, &f| a | f);
+                // Results per position across the edge; start from the unfiltered samples.
+                let mut out = v;
+                // Narrow filter (8.8.5.2) for lanes that are masked but not flat.
+                {
+                    let lo = -(1 << (bit_depth - 1)) as T;
+                    let hi = ((1 << (bit_depth - 1)) - 1) as T;
+                    let c = |x: T| x.clamp(lo, hi);
+                    let off: T = 0x80 << shift;
+                    for l in 0..LANES {
+                        let (ps1, ps0, qs0, qs1) = (p1[l] - off, p0[l] - off, q0[l] - off, q1[l] - off);
+                        let filter = c(if hev[l] { c(ps1 - qs1) } else { 0 } + 3 * (qs0 - ps0));
+                        let filter1 = c(filter + 4) >> 3;
+                        let filter2 = c(filter + 3) >> 3;
+                        let f = (filter1 + 1) >> 1;
+                        let narrow = mask[l] && !flat[l];
+                        let outer = narrow && !hev[l];
+                        out[8][l] = if narrow { c(qs0 - filter1) + off } else { out[8][l] };
+                        out[7][l] = if narrow { c(ps0 + filter2) + off } else { out[7][l] };
+                        out[9][l] = if outer { c(qs1 - f) + off } else { out[9][l] };
+                        out[6][l] = if outer { c(ps1 + f) + off } else { out[6][l] };
+                    }
+                }
+                // Wide filter (8.8.5.3) with 8 taps for flat lanes (p2..q2) ...
+                if any_flat {
+                    let w8 = wide_filter::<3>(&v);
+                    for k in 5..11 {
+                        for l in 0..LANES {
+                            if flat[l] && !flat2[l] {
+                                out[k][l] = w8[k][l];
+                            }
+                        }
+                    }
+                }
+                // ... and 16 taps for flat2 lanes (p6..q6).
+                if any_flat2 {
+                    let w16 = wide_filter::<4>(&v);
+                    for k in 1..15 {
+                        for l in 0..LANES {
+                            if flat2[l] {
+                                out[k][l] = w16[k][l];
+                            }
+                        }
+                    }
+                }
+                let (lo, hi) = if any_flat2 {
+                    (1, 15)
+                } else if any_flat {
+                    (5, 11)
+                } else {
+                    (6, 10)
+                };
+                if ROWS {
+                    for k in lo..hi {
+                        let o = start + (k + R - 8) * step; // k >= 8 - R
+                        let row: &mut [u16; LANES] = (&mut d[o..o + LANES]).try_into().expect("lanes");
+                        for l in 0..LANES {
+                            row[l] = out[k][l] as u16;
+                        }
+                    }
+                } else {
+                    // Whole lines: unmodified samples are rewritten with their own value.
+                    for l in 0..LANES {
+                        let s = start + l * along;
+                        let line: &mut [u16] = &mut d[s..s + 2 * R];
+                        for k in 0..2 * R {
+                            line[k] = out[8 - R + k][l] as u16;
+                        }
+                    }
+                }
+            }
+
+            /// Wide filter process (8.8.5.3) with 2^LOG2 taps on gathered lanes (positions 8 - 2^(LOG2-1)
+            /// .. 8 + 2^(LOG2-1) - 2 are produced); the sum over j of the specification is computed as a
+            /// sliding window over the clamped indices (identical results).
+            #[inline(always)]
+            fn wide_filter<const LOG2: u32>(v: &[[T; LANES]; 16]) -> [[T; LANES]; 16] {
+                let n = (1isize << (LOG2 - 1)) - 1;
+                let s = |k: isize| &v[(k.clamp(-(n + 1), n) + 8) as usize];
+                let mut out = [[0 as T; LANES]; 16];
+                let mut sum = [0 as T; LANES];
+                for j in -n..=n {
+                    let a = s(-n + j);
+                    for l in 0..LANES {
+                        sum[l] += a[l];
+                    }
+                }
+                let round: T = 1 << (LOG2 - 1);
+                for i in -n..n {
+                    let (cur, add, sub) = (s(i), s(i + 1 + n), s(i - n));
+                    let o = &mut out[(i + 8) as usize];
+                    for l in 0..LANES {
+                        o[l] = (sum[l] + cur[l] + round) >> LOG2;
+                        sum[l] += add[l] - sub[l];
+                    }
+                }
+                out
+            }
+        }
+    };
+}
+group_filter!(lanes16, i16);
+group_filter!(lanes32, i32);
diff --git a/crates/vp9/src/probs.rs b/crates/vp9/src/probs.rs
new file mode 100644
index 000000000..6ed83a30d
--- /dev/null
+++ b/crates/vp9/src/probs.rs
@@ -0,0 +1,315 @@
+//! Probability tables (a "frame context"), syntax element counters and the backward adaptation
+//! processes of section 8.4.
+
+use crate::tables::*;
+
+/// coef_probs[txSz][plane > 0][is_inter][band][ctx][node].
+pub type CoefProbs = [[[[[[u8; 3]; 6]; 6]; 2]; 2]; 4];
+
+/// All adaptive probabilities of one frame context (10.5).
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct FrameContext {
+    /// tx_probs[maxTxSize][ctx][node] (index 0 unused).
+    pub tx: [[[u8; 3]; 2]; 4],
+    pub coef: CoefProbs,
+    pub skip: [u8; 3],
+    pub inter_mode: [[u8; 3]; 7],
+    pub interp_filter: [[u8; 2]; 4],
+    pub is_inter: [u8; 4],
+    pub comp_mode: [u8; 5],
+    pub single_ref: [[u8; 2]; 5],
+    pub comp_ref: [u8; 5],
+    pub y_mode: [[u8; 9]; 4],
+    pub uv_mode: [[u8; 9]; 10],
+    pub partition: [[u8; 3]; 16],
+    pub mv_joint: [u8; 3],
+    pub mv_sign: [u8; 2],
+    pub mv_class: [[u8; 10]; 2],
+    pub mv_class0_bit: [u8; 2],
+    pub mv_bits: [[u8; 10]; 2],
+    pub mv_class0_fr: [[[u8; 3]; 2]; 2],
+    pub mv_fr: [[u8; 3]; 2],
+    pub mv_class0_hp: [u8; 2],
+    pub mv_hp: [u8; 2],
+}
+
+fn arr<const N: usize>(s: &[u8]) -> [u8; N] {
+    s.try_into().expect("table size")
+}
+
+impl Default for FrameContext {
+    fn default() -> Self {
+        let mut coef = [[[[[[0u8; 3]; 6]; 6]; 2]; 2]; 4];
+        let mut k = 0;
+        for t in coef.iter_mut() {
+            for i in t.iter_mut() {
+                for j in i.iter_mut() {
+                    for b in j.iter_mut() {
+                        for c in b.iter_mut() {
+                            *c = arr(&DEFAULT_COEF_PROBS[k..k + 3]);
+                            k += 3;
+                        }
+                    }
+                }
+            }
+        }
+        let mut tx = [[[0u8; 3]; 2]; 4];
+        for (m, t) in tx.iter_mut().enumerate() {
+            for (c, p) in t.iter_mut().enumerate() {
+                *p = arr(&DEFAULT_TX_PROBS[(m * 2 + c) * 3..(m * 2 + c) * 3 + 3]);
+            }
+        }
+        FrameContext {
+            tx,
+            coef,
+            skip: DEFAULT_SKIP_PROB,
+            inter_mode: std::array::from_fn(|i| arr(&DEFAULT_INTER_MODE_PROBS[i * 3..i * 3 + 3])),
+            interp_filter: std::array::from_fn(|i| arr(&DEFAULT_INTERP_FILTER_PROBS[i * 2..i * 2 + 2])),
+            is_inter: DEFAULT_IS_INTER_PROB,
+            comp_mode: DEFAULT_COMP_MODE_PROB,
+            single_ref: std::array::from_fn(|i| arr(&DEFAULT_SINGLE_REF_PROB[i * 2..i * 2 + 2])),
+            comp_ref: DEFAULT_COMP_REF_PROB,
+            y_mode: std::array::from_fn(|i| arr(&DEFAULT_Y_MODE_PROBS[i * 9..i * 9 + 9])),
+            uv_mode: std::array::from_fn(|i| arr(&DEFAULT_UV_MODE_PROBS[i * 9..i * 9 + 9])),
+            partition: std::array::from_fn(|i| arr(&DEFAULT_PARTITION_PROBS[i * 3..i * 3 + 3])),
+            mv_joint: DEFAULT_MV_JOINT_PROBS,
+            mv_sign: DEFAULT_MV_SIGN_PROB,
+            mv_class: std::array::from_fn(|i| arr(&DEFAULT_MV_CLASS_PROBS[i * 10..i * 10 + 10])),
+            mv_class0_bit: DEFAULT_MV_CLASS0_BIT_PROB,
+            mv_bits: std::array::from_fn(|i| arr(&DEFAULT_MV_BITS_PROB[i * 10..i * 10 + 10])),
+            mv_class0_fr: std::array::from_fn(|i| std::array::from_fn(|j| arr(&DEFAULT_MV_CLASS0_FR_PROBS[(i * 2 + j) * 3..(i * 2 + j) * 3 + 3]))),
+            mv_fr: std::array::from_fn(|i| arr(&DEFAULT_MV_FR_PROBS[i * 3..i * 3 + 3])),
+            mv_class0_hp: DEFAULT_MV_CLASS0_HP_PROB,
+            mv_hp: DEFAULT_MV_HP_PROB,
+        }
+    }
+}
+
+/// Syntax element counters (8.3).
+#[derive(Clone, Default)]
+pub struct Counts {
+    pub intra_mode: [[u32; 10]; 4],
+    pub uv_mode: [[u32; 10]; 10],
+    pub partition: [[u32; 4]; 16],
+    pub interp_filter: [[u32; 3]; 4],
+    pub inter_mode: [[u32; 4]; 7],
+    /// tx_size[maxTxSize][ctx][value].
+    pub tx: [[[u32; 4]; 2]; 4],
+    pub is_inter: [[u32; 2]; 4],
+    pub comp_mode: [[u32; 2]; 5],
+    pub single_ref: [[[u32; 2]; 2]; 5],
+    pub comp_ref: [[u32; 2]; 5],
+    pub skip: [[u32; 2]; 3],
+    pub mv_joint: [u32; 4],
+    pub mv_sign: [[u32; 2]; 2],
+    pub mv_class: [[u32; 11]; 2],
+    pub mv_class0_bit: [[u32; 2]; 2],
+    pub mv_class0_fr: [[[u32; 4]; 2]; 2],
+    pub mv_class0_hp: [[u32; 2]; 2],
+    pub mv_bits: [[[u32; 2]; 10]; 2],
+    pub mv_fr: [[u32; 4]; 2],
+    pub mv_hp: [[u32; 2]; 2],
+    /// token[txSz][plane>0][is_inter][band][ctx][min(2, token)].
+    pub token: [[[[[[u32; 3]; 6]; 6]; 2]; 2]; 4],
+    /// more_coefs[txSz][plane>0][is_inter][band][ctx][value].
+    pub more_coefs: [[[[[[u32; 2]; 6]; 6]; 2]; 2]; 4],
+}
+
+fn add_slice(a: &mut [u32], b: &[u32]) {
+    for (x, y) in a.iter_mut().zip(b) {
+        *x += y;
+    }
+}
+
+macro_rules! add_nested {
+    ($a:expr, $b:expr, 1) => {
+        add_slice(&mut $a[..], &$b[..])
+    };
+    ($a:expr, $b:expr, 2) => {
+        for (x, y) in $a.iter_mut().zip($b.iter()) {
+            add_slice(&mut x[..], &y[..]);
+        }
+    };
+    ($a:expr, $b:expr, 3) => {
+        for (x, y) in $a.iter_mut().zip($b.iter()) {
+            add_nested!(x, y, 2);
+        }
+    };
+}
+
+impl Counts {
+    /// Accumulate the counts of another tile.
+    pub fn add(&mut self, o: &Counts) {
+        add_nested!(self.intra_mode, o.intra_mode, 2);
+        add_nested!(self.uv_mode, o.uv_mode, 2);
+        add_nested!(self.partition, o.partition, 2);
+        add_nested!(self.interp_filter, o.interp_filter, 2);
+        add_nested!(self.inter_mode, o.inter_mode, 2);
+        add_nested!(self.tx, o.tx, 3);
+        add_nested!(self.is_inter, o.is_inter, 2);
+        add_nested!(self.comp_mode, o.comp_mode, 2);
+        add_nested!(self.single_ref, o.single_ref, 3);
+        add_nested!(self.comp_ref, o.comp_ref, 2);
+        add_nested!(self.skip, o.skip, 2);
+        add_nested!(self.mv_joint, o.mv_joint, 1);
+        add_nested!(self.mv_sign, o.mv_sign, 2);
+        add_nested!(self.mv_class, o.mv_class, 2);
+        add_nested!(self.mv_class0_bit, o.mv_class0_bit, 2);
+        add_nested!(self.mv_class0_fr, o.mv_class0_fr, 3);
+        add_nested!(self.mv_class0_hp, o.mv_class0_hp, 2);
+        add_nested!(self.mv_bits, o.mv_bits, 3);
+        add_nested!(self.mv_fr, o.mv_fr, 2);
+        add_nested!(self.mv_hp, o.mv_hp, 2);
+        for (a, b) in self.token.iter_mut().zip(o.token.iter()) {
+            for (a, b) in a.iter_mut().zip(b.iter()) {
+                for (a, b) in a.iter_mut().zip(b.iter()) {
+                    for (a, b) in a.iter_mut().zip(b.iter()) {
+                        add_nested!(a, b, 2);
+                    }
+                }
+            }
+        }
+        for (a, b) in self.more_coefs.iter_mut().zip(o.more_coefs.iter()) {
+            for (a, b) in a.iter_mut().zip(b.iter()) {
+                for (a, b) in a.iter_mut().zip(b.iter()) {
+                    for (a, b) in a.iter_mut().zip(b.iter()) {
+                        add_nested!(a, b, 2);
+                    }
+                }
+            }
+        }
+    }
+}
+
+/// merge_prob (8.4.1).
+fn merge_prob(pre: u8, ct0: u32, ct1: u32, count_sat: u32, max_update_factor: u32) -> u8 {
+    let den = ct0 + ct1;
+    let prob = if den == 0 { 128 } else { ((ct0 as u64 * 256 + (den as u64 >> 1)) / den as u64).clamp(1, 255) as u32 };
+    let count = den.min(count_sat);
+    let factor = max_update_factor * count / count_sat;
+    ((pre as u32 * (256 - factor) + prob * factor + 128) >> 8) as u8
+}
+
+/// merge_probs (8.4.2).
+fn merge_probs(tree: &[i8], i: usize, probs: &mut [u8], counts: &[u32], count_sat: u32, max_update_factor: u32) -> u32 {
+    let s = tree[i];
+    let left = if s <= 0 { counts[(-s) as usize] } else { merge_probs(tree, s as usize, probs, counts, count_sat, max_update_factor) };
+    let r = tree[i + 1];
+    let right = if r <= 0 { counts[(-r) as usize] } else { merge_probs(tree, r as usize, probs, counts, count_sat, max_update_factor) };
+    probs[i >> 1] = merge_prob(probs[i >> 1], left, right, count_sat, max_update_factor);
+    left + right
+}
+
+fn adapt_probs(tree: &[i8], probs: &mut [u8], counts: &[u32]) {
+    merge_probs(tree, 0, probs, counts, COUNT_SAT, MAX_UPDATE_FACTOR);
+}
+
+fn adapt_prob(prob: &mut u8, counts: &[u32; 2]) {
+    *prob = merge_prob(*prob, counts[0], counts[1], COUNT_SAT, MAX_UPDATE_FACTOR);
+}
+
+/// Coefficient probability adaptation (8.4.3). `fc` holds the probabilities loaded from the
+/// saved frame context.
+pub fn adapt_coef_probs(fc: &mut FrameContext, counts: &Counts, frame_is_intra: bool, last_frame_was_key: bool) {
+    let update_factor = if frame_is_intra {
+        112
+    } else if last_frame_was_key {
+        128
+    } else {
+        112
+    };
+    for t in 0..4 {
+        for i in 0..2 {
+            for j in 0..2 {
+                for k in 0..6 {
+                    let max_l = if k == 0 { 3 } else { 6 };
+                    for l in 0..max_l {
+                        let p = &mut fc.coef[t][i][j][k][l];
+                        merge_probs(&SMALL_TOKEN_TREE, 2, p, &counts.token[t][i][j][k][l], 24, update_factor);
+                        merge_probs(&BINARY_TREE, 0, p, &counts.more_coefs[t][i][j][k][l], 24, update_factor);
+                    }
+                }
+            }
+        }
+    }
+}
+
+/// Non-coefficient probability adaptation (8.4.4).
+pub fn adapt_noncoef_probs(fc: &mut FrameContext, c: &Counts, interp_switchable: bool, tx_select: bool, allow_hp: bool) {
+    for i in 0..4 {
+        adapt_prob(&mut fc.is_inter[i], &c.is_inter[i]);
+    }
+    for i in 0..5 {
+        adapt_prob(&mut fc.comp_mode[i], &c.comp_mode[i]);
+        adapt_prob(&mut fc.comp_ref[i], &c.comp_ref[i]);
+        for j in 0..2 {
+            adapt_prob(&mut fc.single_ref[i][j], &c.single_ref[i][j]);
+        }
+    }
+    for i in 0..7 {
+        adapt_probs(&INTER_MODE_TREE, &mut fc.inter_mode[i], &c.inter_mode[i]);
+    }
+    for i in 0..4 {
+        adapt_probs(&INTRA_MODE_TREE, &mut fc.y_mode[i], &c.intra_mode[i]);
+    }
+    for i in 0..10 {
+        adapt_probs(&INTRA_MODE_TREE, &mut fc.uv_mode[i], &c.uv_mode[i]);
+    }
+    for i in 0..16 {
+        adapt_probs(&PARTITION_TREE, &mut fc.partition[i], &c.partition[i]);
+    }
+    for i in 0..3 {
+        adapt_prob(&mut fc.skip[i], &c.skip[i]);
+    }
+    if interp_switchable {
+        for i in 0..4 {
+            adapt_probs(&INTERP_FILTER_TREE, &mut fc.interp_filter[i], &c.interp_filter[i]);
+        }
+    }
+    if tx_select {
+        for i in 0..2 {
+            adapt_probs(&TX_SIZE_8_TREE, &mut fc.tx[1][i], &c.tx[1][i]);
+            adapt_probs(&TX_SIZE_16_TREE, &mut fc.tx[2][i], &c.tx[2][i]);
+            adapt_probs(&TX_SIZE_32_TREE, &mut fc.tx[3][i], &c.tx[3][i]);
+        }
+    }
+    adapt_probs(&MV_JOINT_TREE, &mut fc.mv_joint, &c.mv_joint);
+    for i in 0..2 {
+        adapt_prob(&mut fc.mv_sign[i], &c.mv_sign[i]);
+        adapt_probs(&MV_CLASS_TREE, &mut fc.mv_class[i], &c.mv_class[i]);
+        adapt_prob(&mut fc.mv_class0_bit[i], &c.mv_class0_bit[i]);
+        for j in 0..10 {
+            adapt_prob(&mut fc.mv_bits[i][j], &c.mv_bits[i][j]);
+        }
+        for j in 0..2 {
+            adapt_probs(&MV_FR_TREE, &mut fc.mv_class0_fr[i][j], &c.mv_class0_fr[i][j]);
+        }
+        adapt_probs(&MV_FR_TREE, &mut fc.mv_fr[i], &c.mv_fr[i]);
+        if allow_hp {
+            adapt_prob(&mut fc.mv_class0_hp[i], &c.mv_class0_hp[i]);
+            adapt_prob(&mut fc.mv_hp[i], &c.mv_hp[i]);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn merge_prob_identity_without_counts() {
+        for p in 1..=255u8 {
+            assert_eq!(merge_prob(p, 0, 0, 20, 128), p);
+        }
+        // Saturated counts move halfway towards the observed probability.
+        assert_eq!(merge_prob(128, 20, 0, 20, 128), 192);
+    }
+
+    #[test]
+    fn defaults_load() {
+        let fc = FrameContext::default();
+        assert_eq!(fc.coef[0][0][0][0][0], [195, 29, 183]);
+        assert_eq!(fc.tx[3][1], [5, 52, 13]);
+        assert_eq!(fc.mv_class0_fr[1][1], [96, 112, 64]);
+    }
+}
diff --git a/crates/vp9/src/spec_tables.rs b/crates/vp9/src/spec_tables.rs
new file mode 100644
index 000000000..686d64fcf
--- /dev/null
+++ b/crates/vp9/src/spec_tables.rs
@@ -0,0 +1,1427 @@
+// Generated by tools/extract_tables.py from the VP9 Bitstream & Decoding Process Specification
+// v0.6 (section numbers refer to that document). Do not edit by hand.
+
+pub const INV_MAP_TABLE: [u8; 255] = [
+    7, 20, 33, 46, 59, 72, 85, 98, 111, 124, 137, 150, 163, 176, 189, 202,
+    215, 228, 241, 254, 1, 2, 3, 4, 5, 6, 8, 9, 10, 11, 12, 13,
+    14, 15, 16, 17, 18, 19, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
+    31, 32, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 47, 48,
+    49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 60, 61, 62, 63, 64, 65,
+    66, 67, 68, 69, 70, 71, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
+    83, 84, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 99, 100,
+    101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 112, 113, 114, 115, 116, 117,
+    118, 119, 120, 121, 122, 123, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
+    135, 136, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 151, 152,
+    153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 164, 165, 166, 167, 168, 169,
+    170, 171, 172, 173, 174, 175, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186,
+    187, 188, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 203, 204,
+    205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 216, 217, 218, 219, 220, 221,
+    222, 223, 224, 225, 226, 227, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238,
+    239, 240, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 253,
+];
+
+pub const SUBPEL_FILTERS: [i16; 512] = [
+    0, 0, 0, 128, 0, 0, 0, 0,
+    0, 1, -5, 126, 8, -3, 1, 0,
+    -1, 3, -10, 122, 18, -6, 2, 0,
+    -1, 4, -13, 118, 27, -9, 3, -1,
+    -1, 4, -16, 112, 37, -11, 4, -1,
+    -1, 5, -18, 105, 48, -14, 4, -1,
+    -1, 5, -19, 97, 58, -16, 5, -1,
+    -1, 6, -19, 88, 68, -18, 5, -1,
+    -1, 6, -19, 78, 78, -19, 6, -1,
+    -1, 5, -18, 68, 88, -19, 6, -1,
+    -1, 5, -16, 58, 97, -19, 5, -1,
+    -1, 4, -14, 48, 105, -18, 5, -1,
+    -1, 4, -11, 37, 112, -16, 4, -1,
+    -1, 3, -9, 27, 118, -13, 4, -1,
+    0, 2, -6, 18, 122, -10, 3, -1,
+    0, 1, -3, 8, 126, -5, 1, 0,
+    0, 0, 0, 128, 0, 0, 0, 0,
+    -3, -1, 32, 64, 38, 1, -3, 0,
+    -2, -2, 29, 63, 41, 2, -3, 0,
+    -2, -2, 26, 63, 43, 4, -4, 0,
+    -2, -3, 24, 62, 46, 5, -4, 0,
+    -2, -3, 21, 60, 49, 7, -4, 0,
+    -1, -4, 18, 59, 51, 9, -4, 0,
+    -1, -4, 16, 57, 53, 12, -4, -1,
+    -1, -4, 14, 55, 55, 14, -4, -1,
+    -1, -4, 12, 53, 57, 16, -4, -1,
+    0, -4, 9, 51, 59, 18, -4, -1,
+    0, -4, 7, 49, 60, 21, -3, -2,
+    0, -4, 5, 46, 62, 24, -3, -2,
+    0, -4, 4, 43, 63, 26, -2, -2,
+    0, -3, 2, 41, 63, 29, -2, -2,
+    0, -3, 1, 38, 64, 32, -1, -3,
+    0, 0, 0, 128, 0, 0, 0, 0,
+    -1, 3, -7, 127, 8, -3, 1, 0,
+    -2, 5, -13, 125, 17, -6, 3, -1,
+    -3, 7, -17, 121, 27, -10, 5, -2,
+    -4, 9, -20, 115, 37, -13, 6, -2,
+    -4, 10, -23, 108, 48, -16, 8, -3,
+    -4, 10, -24, 100, 59, -19, 9, -3,
+    -4, 11, -24, 90, 70, -21, 10, -4,
+    -4, 11, -23, 80, 80, -23, 11, -4,
+    -4, 10, -21, 70, 90, -24, 11, -4,
+    -3, 9, -19, 59, 100, -24, 10, -4,
+    -3, 8, -16, 48, 108, -23, 10, -4,
+    -2, 6, -13, 37, 115, -20, 9, -4,
+    -2, 5, -10, 27, 121, -17, 7, -3,
+    -1, 3, -6, 17, 125, -13, 5, -2,
+    0, 1, -3, 8, 127, -7, 3, -1,
+    0, 0, 0, 128, 0, 0, 0, 0,
+    0, 0, 0, 120, 8, 0, 0, 0,
+    0, 0, 0, 112, 16, 0, 0, 0,
+    0, 0, 0, 104, 24, 0, 0, 0,
+    0, 0, 0, 96, 32, 0, 0, 0,
+    0, 0, 0, 88, 40, 0, 0, 0,
+    0, 0, 0, 80, 48, 0, 0, 0,
+    0, 0, 0, 72, 56, 0, 0, 0,
+    0, 0, 0, 64, 64, 0, 0, 0,
+    0, 0, 0, 56, 72, 0, 0, 0,
+    0, 0, 0, 48, 80, 0, 0, 0,
+    0, 0, 0, 40, 88, 0, 0, 0,
+    0, 0, 0, 32, 96, 0, 0, 0,
+    0, 0, 0, 24, 104, 0, 0, 0,
+    0, 0, 0, 16, 112, 0, 0, 0,
+    0, 0, 0, 8, 120, 0, 0, 0,
+];
+
+pub const DC_QLOOKUP: [i32; 768] = [
+    4, 8, 8, 9, 10, 11, 12, 12, 13, 14, 15, 16, 17, 18, 19, 19,
+    20, 21, 22, 23, 24, 25, 26, 26, 27, 28, 29, 30, 31, 32, 32, 33,
+    34, 35, 36, 37, 38, 38, 39, 40, 41, 42, 43, 43, 44, 45, 46, 47,
+    48, 48, 49, 50, 51, 52, 53, 53, 54, 55, 56, 57, 57, 58, 59, 60,
+    61, 62, 62, 63, 64, 65, 66, 66, 67, 68, 69, 70, 70, 71, 72, 73,
+    74, 74, 75, 76, 77, 78, 78, 79, 80, 81, 81, 82, 83, 84, 85, 85,
+    87, 88, 90, 92, 93, 95, 96, 98, 99, 101, 102, 104, 105, 107, 108, 110,
+    111, 113, 114, 116, 117, 118, 120, 121, 123, 125, 127, 129, 131, 134, 136, 138,
+    140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 161, 164, 166, 169, 172, 174,
+    177, 180, 182, 185, 187, 190, 192, 195, 199, 202, 205, 208, 211, 214, 217, 220,
+    223, 226, 230, 233, 237, 240, 243, 247, 250, 253, 257, 261, 265, 269, 272, 276,
+    280, 284, 288, 292, 296, 300, 304, 309, 313, 317, 322, 326, 330, 335, 340, 344,
+    349, 354, 359, 364, 369, 374, 379, 384, 389, 395, 400, 406, 411, 417, 423, 429,
+    435, 441, 447, 454, 461, 467, 475, 482, 489, 497, 505, 513, 522, 530, 539, 549,
+    559, 569, 579, 590, 602, 614, 626, 640, 654, 668, 684, 700, 717, 736, 755, 775,
+    796, 819, 843, 869, 896, 925, 955, 988, 1022, 1058, 1098, 1139, 1184, 1232, 1282, 1336,
+    4, 9, 10, 13, 15, 17, 20, 22, 25, 28, 31, 34, 37, 40, 43, 47,
+    50, 53, 57, 60, 64, 68, 71, 75, 78, 82, 86, 90, 93, 97, 101, 105,
+    109, 113, 116, 120, 124, 128, 132, 136, 140, 143, 147, 151, 155, 159, 163, 166,
+    170, 174, 178, 182, 185, 189, 193, 197, 200, 204, 208, 212, 215, 219, 223, 226,
+    230, 233, 237, 241, 244, 248, 251, 255, 259, 262, 266, 269, 273, 276, 280, 283,
+    287, 290, 293, 297, 300, 304, 307, 310, 314, 317, 321, 324, 327, 331, 334, 337,
+    343, 350, 356, 362, 369, 375, 381, 387, 394, 400, 406, 412, 418, 424, 430, 436,
+    442, 448, 454, 460, 466, 472, 478, 484, 490, 499, 507, 516, 525, 533, 542, 550,
+    559, 567, 576, 584, 592, 601, 609, 617, 625, 634, 644, 655, 666, 676, 687, 698,
+    708, 718, 729, 739, 749, 759, 770, 782, 795, 807, 819, 831, 844, 856, 868, 880,
+    891, 906, 920, 933, 947, 961, 975, 988, 1001, 1015, 1030, 1045, 1061, 1076, 1090, 1105,
+    1120, 1137, 1153, 1170, 1186, 1202, 1218, 1236, 1253, 1271, 1288, 1306, 1323, 1342, 1361, 1379,
+    1398, 1416, 1436, 1456, 1476, 1496, 1516, 1537, 1559, 1580, 1601, 1624, 1647, 1670, 1692, 1717,
+    1741, 1766, 1791, 1817, 1844, 1871, 1900, 1929, 1958, 1990, 2021, 2054, 2088, 2123, 2159, 2197,
+    2236, 2276, 2319, 2363, 2410, 2458, 2508, 2561, 2616, 2675, 2737, 2802, 2871, 2944, 3020, 3102,
+    3188, 3280, 3375, 3478, 3586, 3702, 3823, 3953, 4089, 4236, 4394, 4559, 4737, 4929, 5130, 5347,
+    4, 12, 18, 25, 33, 41, 50, 60, 70, 80, 91, 103, 115, 127, 140, 153,
+    166, 180, 194, 208, 222, 237, 251, 266, 281, 296, 312, 327, 343, 358, 374, 390,
+    405, 421, 437, 453, 469, 484, 500, 516, 532, 548, 564, 580, 596, 611, 627, 643,
+    659, 674, 690, 706, 721, 737, 752, 768, 783, 798, 814, 829, 844, 859, 874, 889,
+    904, 919, 934, 949, 964, 978, 993, 1008, 1022, 1037, 1051, 1065, 1080, 1094, 1108, 1122,
+    1136, 1151, 1165, 1179, 1192, 1206, 1220, 1234, 1248, 1261, 1275, 1288, 1302, 1315, 1329, 1342,
+    1368, 1393, 1419, 1444, 1469, 1494, 1519, 1544, 1569, 1594, 1618, 1643, 1668, 1692, 1717, 1741,
+    1765, 1789, 1814, 1838, 1862, 1885, 1909, 1933, 1957, 1992, 2027, 2061, 2096, 2130, 2165, 2199,
+    2233, 2267, 2300, 2334, 2367, 2400, 2434, 2467, 2499, 2532, 2575, 2618, 2661, 2704, 2746, 2788,
+    2830, 2872, 2913, 2954, 2995, 3036, 3076, 3127, 3177, 3226, 3275, 3324, 3373, 3421, 3469, 3517,
+    3565, 3621, 3677, 3733, 3788, 3843, 3897, 3951, 4005, 4058, 4119, 4181, 4241, 4301, 4361, 4420,
+    4479, 4546, 4612, 4677, 4742, 4807, 4871, 4942, 5013, 5083, 5153, 5222, 5291, 5367, 5442, 5517,
+    5591, 5665, 5745, 5825, 5905, 5984, 6063, 6149, 6234, 6319, 6404, 6495, 6587, 6678, 6769, 6867,
+    6966, 7064, 7163, 7269, 7376, 7483, 7599, 7715, 7832, 7958, 8085, 8214, 8352, 8492, 8635, 8788,
+    8945, 9104, 9275, 9450, 9639, 9832, 10031, 10245, 10465, 10702, 10946, 11210, 11482, 11776, 12081, 12409,
+    12750, 13118, 13501, 13913, 14343, 14807, 15290, 15812, 16356, 16943, 17575, 18237, 18949, 19718, 20521, 21387,
+];
+
+pub const AC_QLOOKUP: [i32; 768] = [
+    4, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
+    23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
+    39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
+    55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,
+    71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86,
+    87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102,
+    104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134,
+    136, 138, 140, 142, 144, 146, 148, 150, 152, 155, 158, 161, 164, 167, 170, 173,
+    176, 179, 182, 185, 188, 191, 194, 197, 200, 203, 207, 211, 215, 219, 223, 227,
+    231, 235, 239, 243, 247, 251, 255, 260, 265, 270, 275, 280, 285, 290, 295, 300,
+    305, 311, 317, 323, 329, 335, 341, 347, 353, 359, 366, 373, 380, 387, 394, 401,
+    408, 416, 424, 432, 440, 448, 456, 465, 474, 483, 492, 501, 510, 520, 530, 540,
+    550, 560, 571, 582, 593, 604, 615, 627, 639, 651, 663, 676, 689, 702, 715, 729,
+    743, 757, 771, 786, 801, 816, 832, 848, 864, 881, 898, 915, 933, 951, 969, 988,
+    1007, 1026, 1046, 1066, 1087, 1108, 1129, 1151, 1173, 1196, 1219, 1243, 1267, 1292, 1317, 1343,
+    1369, 1396, 1423, 1451, 1479, 1508, 1537, 1567, 1597, 1628, 1660, 1692, 1725, 1759, 1793, 1828,
+    4, 9, 11, 13, 16, 18, 21, 24, 27, 30, 33, 37, 40, 44, 48, 51,
+    55, 59, 63, 67, 71, 75, 79, 83, 88, 92, 96, 100, 105, 109, 114, 118,
+    122, 127, 131, 136, 140, 145, 149, 154, 158, 163, 168, 172, 177, 181, 186, 190,
+    195, 199, 204, 208, 213, 217, 222, 226, 231, 235, 240, 244, 249, 253, 258, 262,
+    267, 271, 275, 280, 284, 289, 293, 297, 302, 306, 311, 315, 319, 324, 328, 332,
+    337, 341, 345, 349, 354, 358, 362, 367, 371, 375, 379, 384, 388, 392, 396, 401,
+    409, 417, 425, 433, 441, 449, 458, 466, 474, 482, 490, 498, 506, 514, 523, 531,
+    539, 547, 555, 563, 571, 579, 588, 596, 604, 616, 628, 640, 652, 664, 676, 688,
+    700, 713, 725, 737, 749, 761, 773, 785, 797, 809, 825, 841, 857, 873, 889, 905,
+    922, 938, 954, 970, 986, 1002, 1018, 1038, 1058, 1078, 1098, 1118, 1138, 1158, 1178, 1198,
+    1218, 1242, 1266, 1290, 1314, 1338, 1362, 1386, 1411, 1435, 1463, 1491, 1519, 1547, 1575, 1603,
+    1631, 1663, 1695, 1727, 1759, 1791, 1823, 1859, 1895, 1931, 1967, 2003, 2039, 2079, 2119, 2159,
+    2199, 2239, 2283, 2327, 2371, 2415, 2459, 2507, 2555, 2603, 2651, 2703, 2755, 2807, 2859, 2915,
+    2971, 3027, 3083, 3143, 3203, 3263, 3327, 3391, 3455, 3523, 3591, 3659, 3731, 3803, 3876, 3952,
+    4028, 4104, 4184, 4264, 4348, 4432, 4516, 4604, 4692, 4784, 4876, 4972, 5068, 5168, 5268, 5372,
+    5476, 5584, 5692, 5804, 5916, 6032, 6148, 6268, 6388, 6512, 6640, 6768, 6900, 7036, 7172, 7312,
+    4, 13, 19, 27, 35, 44, 54, 64, 75, 87, 99, 112, 126, 139, 154, 168,
+    183, 199, 214, 230, 247, 263, 280, 297, 314, 331, 349, 366, 384, 402, 420, 438,
+    456, 475, 493, 511, 530, 548, 567, 586, 604, 623, 642, 660, 679, 698, 716, 735,
+    753, 772, 791, 809, 828, 846, 865, 884, 902, 920, 939, 957, 976, 994, 1012, 1030,
+    1049, 1067, 1085, 1103, 1121, 1139, 1157, 1175, 1193, 1211, 1229, 1246, 1264, 1282, 1299, 1317,
+    1335, 1352, 1370, 1387, 1405, 1422, 1440, 1457, 1474, 1491, 1509, 1526, 1543, 1560, 1577, 1595,
+    1627, 1660, 1693, 1725, 1758, 1791, 1824, 1856, 1889, 1922, 1954, 1987, 2020, 2052, 2085, 2118,
+    2150, 2183, 2216, 2248, 2281, 2313, 2346, 2378, 2411, 2459, 2508, 2556, 2605, 2653, 2701, 2750,
+    2798, 2847, 2895, 2943, 2992, 3040, 3088, 3137, 3185, 3234, 3298, 3362, 3426, 3491, 3555, 3619,
+    3684, 3748, 3812, 3876, 3941, 4005, 4069, 4149, 4230, 4310, 4390, 4470, 4550, 4631, 4711, 4791,
+    4871, 4967, 5064, 5160, 5256, 5352, 5448, 5544, 5641, 5737, 5849, 5961, 6073, 6185, 6297, 6410,
+    6522, 6650, 6778, 6906, 7034, 7162, 7290, 7435, 7579, 7723, 7867, 8011, 8155, 8315, 8475, 8635,
+    8795, 8956, 9132, 9308, 9484, 9660, 9836, 10028, 10220, 10412, 10604, 10812, 11020, 11228, 11437, 11661,
+    11885, 12109, 12333, 12573, 12813, 13053, 13309, 13565, 13821, 14093, 14365, 14637, 14925, 15213, 15502, 15806,
+    16110, 16414, 16734, 17054, 17390, 17726, 18062, 18414, 18766, 19134, 19502, 19886, 20270, 20670, 21070, 21486,
+    21902, 22334, 22766, 23214, 23662, 24126, 24590, 25070, 25551, 26047, 26559, 27071, 27599, 28143, 28687, 29247,
+];
+
+pub const COS64_LOOKUP: [i32; 33] = [
+    16384, 16364, 16305, 16207, 16069, 15893, 15679, 15426, 15137, 14811, 14449, 14053, 13623, 13160, 12665, 12140,
+    11585, 11003, 10394, 9760, 9102, 8423, 7723, 7005, 6270, 5520, 4756, 3981, 3196, 2404, 1606, 804,
+    0,
+];
+
+pub const DEFAULT_SCAN_4X4: [u16; 16] = [
+    0, 4, 1, 5, 8, 2, 12, 9, 3, 6, 13, 10, 7, 14, 11, 15,
+];
+
+pub const COL_SCAN_4X4: [u16; 16] = [
+    0, 4, 8, 1, 12, 5, 9, 2, 13, 6, 10, 3, 7, 14, 11, 15,
+];
+
+pub const ROW_SCAN_4X4: [u16; 16] = [
+    0, 1, 4, 2, 5, 3, 6, 8, 9, 7, 12, 10, 13, 11, 14, 15,
+];
+
+pub const DEFAULT_SCAN_8X8: [u16; 64] = [
+    0, 8, 1, 16, 9, 2, 17, 24, 10, 3, 18, 25, 32, 11, 4, 26,
+    33, 19, 40, 12, 34, 27, 5, 41, 20, 48, 13, 35, 42, 28, 21, 6,
+    49, 56, 36, 43, 29, 7, 14, 50, 57, 44, 22, 37, 15, 51, 58, 30,
+    45, 23, 52, 59, 38, 31, 60, 53, 46, 39, 61, 54, 47, 62, 55, 63,
+];
+
+pub const COL_SCAN_8X8: [u16; 64] = [
+    0, 8, 16, 1, 24, 9, 32, 17, 2, 40, 25, 10, 33, 18, 48, 3,
+    26, 41, 11, 56, 19, 34, 4, 49, 27, 42, 12, 35, 20, 57, 50, 28,
+    5, 43, 13, 36, 58, 51, 21, 44, 6, 29, 59, 37, 14, 52, 22, 7,
+    45, 60, 30, 15, 38, 53, 23, 46, 31, 61, 39, 54, 47, 62, 55, 63,
+];
+
+pub const ROW_SCAN_8X8: [u16; 64] = [
+    0, 1, 2, 8, 9, 3, 16, 10, 4, 17, 11, 24, 5, 18, 25, 12,
+    19, 26, 32, 6, 13, 20, 33, 27, 7, 34, 40, 21, 28, 41, 14, 35,
+    48, 42, 29, 36, 49, 22, 43, 15, 56, 37, 50, 44, 30, 57, 23, 51,
+    58, 45, 38, 52, 31, 59, 53, 46, 60, 39, 61, 47, 54, 55, 62, 63,
+];
+
+pub const DEFAULT_SCAN_16X16: [u16; 256] = [
+    0, 16, 1, 32, 17, 2, 48, 33, 18, 3, 64, 34, 49, 19, 65, 80,
+    50, 4, 35, 66, 20, 81, 96, 51, 5, 36, 82, 97, 67, 112, 21, 52,
+    98, 37, 83, 113, 6, 68, 128, 53, 22, 99, 114, 84, 7, 129, 38, 69,
+    100, 115, 144, 130, 85, 54, 23, 8, 145, 39, 70, 116, 101, 131, 160, 146,
+    55, 86, 24, 71, 132, 117, 161, 40, 9, 102, 147, 176, 162, 87, 56, 25,
+    133, 118, 177, 148, 72, 103, 41, 163, 10, 192, 178, 88, 57, 134, 149, 119,
+    26, 164, 73, 104, 193, 42, 179, 208, 11, 135, 89, 165, 120, 150, 58, 194,
+    180, 27, 74, 209, 105, 151, 136, 43, 90, 224, 166, 195, 181, 121, 210, 59,
+    12, 152, 106, 167, 196, 75, 137, 225, 211, 240, 182, 122, 91, 28, 197, 13,
+    226, 168, 183, 153, 44, 212, 138, 107, 241, 60, 29, 123, 198, 184, 227, 169,
+    242, 76, 213, 154, 45, 92, 14, 199, 139, 61, 228, 214, 170, 185, 243, 108,
+    77, 155, 30, 15, 200, 229, 124, 215, 244, 93, 46, 186, 171, 201, 109, 140,
+    230, 62, 216, 245, 31, 125, 78, 156, 231, 47, 187, 202, 217, 94, 246, 141,
+    63, 232, 172, 110, 247, 157, 79, 218, 203, 126, 233, 188, 248, 95, 173, 142,
+    219, 111, 249, 234, 158, 127, 189, 204, 250, 235, 143, 174, 220, 205, 159, 251,
+    190, 221, 175, 236, 237, 191, 206, 252, 222, 253, 207, 238, 223, 254, 239, 255,
+];
+
+pub const COL_SCAN_16X16: [u16; 256] = [
+    0, 16, 32, 48, 1, 64, 17, 80, 33, 96, 49, 2, 65, 112, 18, 81,
+    34, 128, 50, 97, 3, 66, 144, 19, 113, 35, 82, 160, 98, 51, 129, 4,
+    67, 176, 20, 114, 145, 83, 36, 99, 130, 52, 192, 5, 161, 68, 115, 21,
+    146, 84, 208, 177, 37, 131, 100, 53, 162, 224, 69, 6, 116, 193, 147, 85,
+    22, 240, 132, 38, 178, 101, 163, 54, 209, 117, 70, 7, 148, 194, 86, 179,
+    225, 23, 133, 39, 164, 8, 102, 210, 241, 55, 195, 118, 149, 71, 180, 24,
+    87, 226, 134, 165, 211, 40, 103, 56, 72, 150, 196, 242, 119, 9, 181, 227,
+    88, 166, 25, 135, 41, 104, 212, 57, 151, 197, 120, 73, 243, 182, 136, 167,
+    213, 89, 10, 228, 105, 152, 198, 26, 42, 121, 183, 244, 168, 58, 137, 229,
+    74, 214, 90, 153, 199, 184, 11, 106, 245, 27, 122, 230, 169, 43, 215, 59,
+    200, 138, 185, 246, 75, 12, 91, 154, 216, 231, 107, 28, 44, 201, 123, 170,
+    60, 247, 232, 76, 139, 13, 92, 217, 186, 248, 155, 108, 29, 124, 45, 202,
+    233, 171, 61, 14, 77, 140, 15, 249, 93, 30, 187, 156, 218, 46, 109, 125,
+    62, 172, 78, 203, 31, 141, 234, 94, 47, 188, 63, 157, 110, 250, 219, 79,
+    126, 204, 173, 142, 95, 189, 111, 235, 158, 220, 251, 127, 174, 143, 205, 236,
+    159, 190, 221, 252, 175, 206, 237, 191, 253, 222, 238, 207, 254, 223, 239, 255,
+];
+
+pub const ROW_SCAN_16X16: [u16; 256] = [
+    0, 1, 2, 16, 3, 17, 4, 18, 32, 5, 33, 19, 6, 34, 48, 20,
+    49, 7, 35, 21, 50, 64, 8, 36, 65, 22, 51, 37, 80, 9, 66, 52,
+    23, 38, 81, 67, 10, 53, 24, 82, 68, 96, 39, 11, 54, 83, 97, 69,
+    25, 98, 84, 40, 112, 55, 12, 70, 99, 113, 85, 26, 41, 56, 114, 100,
+    13, 71, 128, 86, 27, 115, 101, 129, 42, 57, 72, 116, 14, 87, 130, 102,
+    144, 73, 131, 117, 28, 58, 15, 88, 43, 145, 103, 132, 146, 118, 74, 160,
+    89, 133, 104, 29, 59, 147, 119, 44, 161, 148, 90, 105, 134, 162, 120, 176,
+    75, 135, 149, 30, 60, 163, 177, 45, 121, 91, 106, 164, 178, 150, 192, 136,
+    165, 179, 31, 151, 193, 76, 122, 61, 137, 194, 107, 152, 180, 208, 46, 166,
+    167, 195, 92, 181, 138, 209, 123, 153, 224, 196, 77, 168, 210, 182, 240, 108,
+    197, 62, 154, 225, 183, 169, 211, 47, 139, 93, 184, 226, 212, 241, 198, 170,
+    124, 155, 199, 78, 213, 185, 109, 227, 200, 63, 228, 242, 140, 214, 171, 186,
+    156, 229, 243, 125, 94, 201, 244, 215, 216, 230, 141, 187, 202, 79, 172, 110,
+    157, 245, 217, 231, 95, 246, 232, 126, 203, 247, 233, 173, 218, 142, 111, 158,
+    188, 248, 127, 234, 219, 249, 189, 204, 143, 174, 159, 250, 235, 205, 220, 175,
+    190, 251, 221, 191, 206, 236, 207, 237, 252, 222, 253, 223, 238, 239, 254, 255,
+];
+
+pub const DEFAULT_SCAN_32X32: [u16; 1024] = [
+    0, 32, 1, 64, 33, 2, 96, 65, 34, 128, 3, 97, 66, 160, 129, 35,
+    98, 4, 67, 130, 161, 192, 36, 99, 224, 5, 162, 193, 68, 131, 37, 100,
+    225, 194, 256, 163, 69, 132, 6, 226, 257, 288, 195, 101, 164, 38, 258, 7,
+    227, 289, 133, 320, 70, 196, 165, 290, 259, 228, 39, 321, 102, 352, 8, 197,
+    71, 134, 322, 291, 260, 353, 384, 229, 166, 103, 40, 354, 323, 292, 135, 385,
+    198, 261, 72, 9, 416, 167, 386, 355, 230, 324, 104, 293, 41, 417, 199, 136,
+    262, 387, 448, 325, 356, 10, 73, 418, 231, 168, 449, 294, 388, 105, 419, 263,
+    42, 200, 357, 450, 137, 480, 74, 326, 232, 11, 389, 169, 295, 420, 106, 451,
+    481, 358, 264, 327, 201, 43, 138, 512, 482, 390, 296, 233, 170, 421, 75, 452,
+    359, 12, 513, 265, 483, 328, 107, 202, 514, 544, 422, 391, 453, 139, 44, 234,
+    484, 297, 360, 171, 76, 515, 545, 266, 329, 454, 13, 423, 203, 108, 546, 485,
+    576, 298, 235, 140, 361, 330, 172, 547, 45, 455, 267, 577, 486, 77, 204, 362,
+    608, 14, 299, 578, 109, 236, 487, 609, 331, 141, 579, 46, 15, 173, 610, 363,
+    78, 205, 16, 110, 237, 611, 142, 47, 174, 79, 206, 17, 111, 238, 48, 143,
+    80, 175, 112, 207, 49, 18, 239, 81, 113, 19, 50, 82, 114, 51, 83, 115,
+    640, 516, 392, 268, 144, 20, 672, 641, 548, 517, 424, 393, 300, 269, 176, 145,
+    52, 21, 704, 673, 642, 580, 549, 518, 456, 425, 394, 332, 301, 270, 208, 177,
+    146, 84, 53, 22, 736, 705, 674, 643, 612, 581, 550, 519, 488, 457, 426, 395,
+    364, 333, 302, 271, 240, 209, 178, 147, 116, 85, 54, 23, 737, 706, 675, 613,
+    582, 551, 489, 458, 427, 365, 334, 303, 241, 210, 179, 117, 86, 55, 738, 707,
+    614, 583, 490, 459, 366, 335, 242, 211, 118, 87, 739, 615, 491, 367, 243, 119,
+    768, 644, 520, 396, 272, 148, 24, 800, 769, 676, 645, 552, 521, 428, 397, 304,
+    273, 180, 149, 56, 25, 832, 801, 770, 708, 677, 646, 584, 553, 522, 460, 429,
+    398, 336, 305, 274, 212, 181, 150, 88, 57, 26, 864, 833, 802, 771, 740, 709,
+    678, 647, 616, 585, 554, 523, 492, 461, 430, 399, 368, 337, 306, 275, 244, 213,
+    182, 151, 120, 89, 58, 27, 865, 834, 803, 741, 710, 679, 617, 586, 555, 493,
+    462, 431, 369, 338, 307, 245, 214, 183, 121, 90, 59, 866, 835, 742, 711, 618,
+    587, 494, 463, 370, 339, 246, 215, 122, 91, 867, 743, 619, 495, 371, 247, 123,
+    896, 772, 648, 524, 400, 276, 152, 28, 928, 897, 804, 773, 680, 649, 556, 525,
+    432, 401, 308, 277, 184, 153, 60, 29, 960, 929, 898, 836, 805, 774, 712, 681,
+    650, 588, 557, 526, 464, 433, 402, 340, 309, 278, 216, 185, 154, 92, 61, 30,
+    992, 961, 930, 899, 868, 837, 806, 775, 744, 713, 682, 651, 620, 589, 558, 527,
+    496, 465, 434, 403, 372, 341, 310, 279, 248, 217, 186, 155, 124, 93, 62, 31,
+    993, 962, 931, 869, 838, 807, 745, 714, 683, 621, 590, 559, 497, 466, 435, 373,
+    342, 311, 249, 218, 187, 125, 94, 63, 994, 963, 870, 839, 746, 715, 622, 591,
+    498, 467, 374, 343, 250, 219, 126, 95, 995, 871, 747, 623, 499, 375, 251, 127,
+    900, 776, 652, 528, 404, 280, 156, 932, 901, 808, 777, 684, 653, 560, 529, 436,
+    405, 312, 281, 188, 157, 964, 933, 902, 840, 809, 778, 716, 685, 654, 592, 561,
+    530, 468, 437, 406, 344, 313, 282, 220, 189, 158, 996, 965, 934, 903, 872, 841,
+    810, 779, 748, 717, 686, 655, 624, 593, 562, 531, 500, 469, 438, 407, 376, 345,
+    314, 283, 252, 221, 190, 159, 997, 966, 935, 873, 842, 811, 749, 718, 687, 625,
+    594, 563, 501, 470, 439, 377, 346, 315, 253, 222, 191, 998, 967, 874, 843, 750,
+    719, 626, 595, 502, 471, 378, 347, 254, 223, 999, 875, 751, 627, 503, 379, 255,
+    904, 780, 656, 532, 408, 284, 936, 905, 812, 781, 688, 657, 564, 533, 440, 409,
+    316, 285, 968, 937, 906, 844, 813, 782, 720, 689, 658, 596, 565, 534, 472, 441,
+    410, 348, 317, 286, 1000, 969, 938, 907, 876, 845, 814, 783, 752, 721, 690, 659,
+    628, 597, 566, 535, 504, 473, 442, 411, 380, 349, 318, 287, 1001, 970, 939, 877,
+    846, 815, 753, 722, 691, 629, 598, 567, 505, 474, 443, 381, 350, 319, 1002, 971,
+    878, 847, 754, 723, 630, 599, 506, 475, 382, 351, 1003, 879, 755, 631, 507, 383,
+    908, 784, 660, 536, 412, 940, 909, 816, 785, 692, 661, 568, 537, 444, 413, 972,
+    941, 910, 848, 817, 786, 724, 693, 662, 600, 569, 538, 476, 445, 414, 1004, 973,
+    942, 911, 880, 849, 818, 787, 756, 725, 694, 663, 632, 601, 570, 539, 508, 477,
+    446, 415, 1005, 974, 943, 881, 850, 819, 757, 726, 695, 633, 602, 571, 509, 478,
+    447, 1006, 975, 882, 851, 758, 727, 634, 603, 510, 479, 1007, 883, 759, 635, 511,
+    912, 788, 664, 540, 944, 913, 820, 789, 696, 665, 572, 541, 976, 945, 914, 852,
+    821, 790, 728, 697, 666, 604, 573, 542, 1008, 977, 946, 915, 884, 853, 822, 791,
+    760, 729, 698, 667, 636, 605, 574, 543, 1009, 978, 947, 885, 854, 823, 761, 730,
+    699, 637, 606, 575, 1010, 979, 886, 855, 762, 731, 638, 607, 1011, 887, 763, 639,
+    916, 792, 668, 948, 917, 824, 793, 700, 669, 980, 949, 918, 856, 825, 794, 732,
+    701, 670, 1012, 981, 950, 919, 888, 857, 826, 795, 764, 733, 702, 671, 1013, 982,
+    951, 889, 858, 827, 765, 734, 703, 1014, 983, 890, 859, 766, 735, 1015, 891, 767,
+    920, 796, 952, 921, 828, 797, 984, 953, 922, 860, 829, 798, 1016, 985, 954, 923,
+    892, 861, 830, 799, 1017, 986, 955, 893, 862, 831, 1018, 987, 894, 863, 1019, 895,
+    924, 956, 925, 988, 957, 926, 1020, 989, 958, 927, 1021, 990, 959, 1022, 991, 1023,
+];
+
+pub const COEFBAND_4X4: [u8; 16] = [
+    0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 5, 5, 5,
+];
+
+pub const COEFBAND_8X8PLUS: [u8; 1024] = [
+    0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4,
+    4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+];
+
+pub const ENERGY_CLASS: [u8; 12] = [
+    0, 1, 2, 3, 3, 4, 4, 5, 5, 5, 5, 5,
+];
+
+pub const PARETO_TABLE: [u8; 1024] = [
+    3, 86, 128, 6, 86, 23, 88, 29,
+    9, 86, 129, 17, 88, 61, 94, 76,
+    15, 87, 129, 28, 89, 93, 100, 110,
+    20, 88, 130, 38, 91, 118, 106, 136,
+    26, 89, 131, 48, 92, 139, 111, 156,
+    31, 90, 131, 58, 94, 156, 117, 171,
+    37, 90, 132, 66, 95, 171, 122, 184,
+    42, 91, 132, 75, 97, 183, 127, 194,
+    47, 92, 133, 83, 98, 193, 132, 202,
+    52, 93, 133, 90, 100, 201, 137, 208,
+    57, 94, 134, 98, 101, 208, 142, 214,
+    62, 94, 135, 105, 103, 214, 146, 218,
+    66, 95, 135, 111, 104, 219, 151, 222,
+    71, 96, 136, 117, 106, 224, 155, 225,
+    76, 97, 136, 123, 107, 227, 159, 228,
+    80, 98, 137, 129, 109, 231, 162, 231,
+    84, 98, 138, 134, 110, 234, 166, 233,
+    89, 99, 138, 140, 112, 236, 170, 235,
+    93, 100, 139, 145, 113, 238, 173, 236,
+    97, 101, 140, 149, 115, 240, 176, 238,
+    101, 102, 140, 154, 116, 242, 179, 239,
+    105, 103, 141, 158, 118, 243, 182, 240,
+    109, 104, 141, 162, 119, 244, 185, 241,
+    113, 104, 142, 166, 120, 245, 187, 242,
+    116, 105, 143, 170, 122, 246, 190, 243,
+    120, 106, 143, 173, 123, 247, 192, 244,
+    123, 107, 144, 177, 125, 248, 195, 244,
+    127, 108, 145, 180, 126, 249, 197, 245,
+    130, 109, 145, 183, 128, 249, 199, 245,
+    134, 110, 146, 186, 129, 250, 201, 246,
+    137, 111, 147, 189, 131, 251, 203, 246,
+    140, 112, 147, 192, 132, 251, 205, 247,
+    143, 113, 148, 194, 133, 251, 207, 247,
+    146, 114, 149, 197, 135, 252, 208, 248,
+    149, 115, 149, 199, 136, 252, 210, 248,
+    152, 115, 150, 201, 138, 252, 211, 248,
+    155, 116, 151, 204, 139, 253, 213, 249,
+    158, 117, 151, 206, 140, 253, 214, 249,
+    161, 118, 152, 208, 142, 253, 216, 249,
+    163, 119, 153, 210, 143, 253, 217, 249,
+    166, 120, 153, 212, 144, 254, 218, 250,
+    168, 121, 154, 213, 146, 254, 220, 250,
+    171, 122, 155, 215, 147, 254, 221, 250,
+    173, 123, 155, 217, 148, 254, 222, 250,
+    176, 124, 156, 218, 150, 254, 223, 250,
+    178, 125, 157, 220, 151, 254, 224, 251,
+    180, 126, 157, 221, 152, 254, 225, 251,
+    183, 127, 158, 222, 153, 254, 226, 251,
+    185, 128, 159, 224, 155, 255, 227, 251,
+    187, 129, 160, 225, 156, 255, 228, 251,
+    189, 131, 160, 226, 157, 255, 228, 251,
+    191, 132, 161, 227, 159, 255, 229, 251,
+    193, 133, 162, 228, 160, 255, 230, 252,
+    195, 134, 163, 230, 161, 255, 231, 252,
+    197, 135, 163, 231, 162, 255, 231, 252,
+    199, 136, 164, 232, 163, 255, 232, 252,
+    201, 137, 165, 233, 165, 255, 233, 252,
+    202, 138, 166, 233, 166, 255, 233, 252,
+    204, 139, 166, 234, 167, 255, 234, 252,
+    206, 140, 167, 235, 168, 255, 235, 252,
+    207, 141, 168, 236, 169, 255, 235, 252,
+    209, 142, 169, 237, 171, 255, 236, 252,
+    210, 144, 169, 237, 172, 255, 236, 252,
+    212, 145, 170, 238, 173, 255, 237, 252,
+    214, 146, 171, 239, 174, 255, 237, 253,
+    215, 147, 172, 240, 175, 255, 238, 253,
+    216, 148, 173, 240, 176, 255, 238, 253,
+    218, 149, 173, 241, 177, 255, 239, 253,
+    219, 150, 174, 241, 179, 255, 239, 253,
+    220, 152, 175, 242, 180, 255, 240, 253,
+    222, 153, 176, 242, 181, 255, 240, 253,
+    223, 154, 177, 243, 182, 255, 240, 253,
+    224, 155, 178, 244, 183, 255, 241, 253,
+    225, 156, 178, 244, 184, 255, 241, 253,
+    226, 158, 179, 244, 185, 255, 242, 253,
+    228, 159, 180, 245, 186, 255, 242, 253,
+    229, 160, 181, 245, 187, 255, 242, 253,
+    230, 161, 182, 246, 188, 255, 243, 253,
+    231, 163, 183, 246, 189, 255, 243, 253,
+    232, 164, 184, 247, 190, 255, 243, 253,
+    233, 165, 185, 247, 191, 255, 244, 253,
+    234, 166, 185, 247, 192, 255, 244, 253,
+    235, 168, 186, 248, 193, 255, 244, 253,
+    236, 169, 187, 248, 194, 255, 244, 253,
+    236, 170, 188, 248, 195, 255, 245, 253,
+    237, 171, 189, 249, 196, 255, 245, 254,
+    238, 173, 190, 249, 197, 255, 245, 254,
+    239, 174, 191, 249, 198, 255, 245, 254,
+    240, 175, 192, 249, 199, 255, 246, 254,
+    240, 177, 193, 250, 200, 255, 246, 254,
+    241, 178, 194, 250, 201, 255, 246, 254,
+    242, 179, 195, 250, 202, 255, 246, 254,
+    242, 181, 196, 250, 203, 255, 247, 254,
+    243, 182, 197, 251, 204, 255, 247, 254,
+    244, 184, 198, 251, 205, 255, 247, 254,
+    244, 185, 199, 251, 206, 255, 247, 254,
+    245, 186, 200, 251, 207, 255, 247, 254,
+    246, 188, 201, 252, 207, 255, 248, 254,
+    246, 189, 202, 252, 208, 255, 248, 254,
+    247, 191, 203, 252, 209, 255, 248, 254,
+    247, 192, 204, 252, 210, 255, 248, 254,
+    248, 194, 205, 252, 211, 255, 248, 254,
+    248, 195, 206, 252, 212, 255, 249, 254,
+    249, 197, 207, 253, 213, 255, 249, 254,
+    249, 198, 208, 253, 214, 255, 249, 254,
+    250, 200, 210, 253, 215, 255, 249, 254,
+    250, 201, 211, 253, 215, 255, 249, 254,
+    250, 203, 212, 253, 216, 255, 249, 254,
+    251, 204, 213, 253, 217, 255, 250, 254,
+    251, 206, 214, 254, 218, 255, 250, 254,
+    252, 207, 216, 254, 219, 255, 250, 254,
+    252, 209, 217, 254, 220, 255, 250, 254,
+    252, 211, 218, 254, 221, 255, 250, 254,
+    253, 213, 219, 254, 222, 255, 250, 254,
+    253, 214, 221, 254, 223, 255, 250, 254,
+    253, 216, 222, 254, 224, 255, 251, 254,
+    253, 218, 224, 254, 225, 255, 251, 254,
+    254, 220, 225, 254, 225, 255, 251, 254,
+    254, 222, 227, 255, 226, 255, 251, 254,
+    254, 224, 228, 255, 227, 255, 251, 254,
+    254, 226, 230, 255, 228, 255, 251, 254,
+    255, 228, 231, 255, 230, 255, 251, 254,
+    255, 230, 233, 255, 231, 255, 252, 254,
+    255, 232, 235, 255, 232, 255, 252, 254,
+    255, 235, 237, 255, 233, 255, 252, 254,
+    255, 238, 240, 255, 235, 255, 252, 255,
+    255, 241, 243, 255, 236, 255, 252, 254,
+    255, 246, 247, 255, 239, 255, 253, 255,
+];
+
+pub const MV_REF_BLOCKS: [i8; 208] = [
+    -1, 0, 0, -1, -1, -1, -2, 0, 0, -2, -2, -1, -1, -2, -2, -2,
+    -1, 0, 0, -1, -1, -1, -2, 0, 0, -2, -2, -1, -1, -2, -2, -2,
+    -1, 0, 0, -1, -1, -1, -2, 0, 0, -2, -2, -1, -1, -2, -2, -2,
+    -1, 0, 0, -1, -1, -1, -2, 0, 0, -2, -2, -1, -1, -2, -2, -2,
+    0, -1, -1, 0, 1, -1, -1, -1, 0, -2, -2, 0, -2, -1, -1, -2,
+    -1, 0, 0, -1, -1, 1, -1, -1, -2, 0, 0, -2, -1, -2, -2, -1,
+    -1, 0, 0, -1, -1, 1, 1, -1, -1, -1, -3, 0, 0, -3, -3, -3,
+    0, -1, -1, 0, 2, -1, -1, -1, -1, 1, 0, -3, -3, 0, -3, -3,
+    -1, 0, 0, -1, -1, 2, -1, -1, 1, -1, -3, 0, 0, -3, -3, -3,
+    -1, 1, 1, -1, -1, 2, 2, -1, -1, -1, -3, 0, 0, -3, -3, -3,
+    0, -1, -1, 0, 4, -1, -1, 2, -1, -1, 0, -3, -3, 0, 2, -1,
+    -1, 0, 0, -1, -1, 4, 2, -1, -1, -1, -3, 0, 0, -3, -1, 2,
+    -1, 3, 3, -1, -1, 4, 4, -1, -1, -1, -1, 0, 0, -1, -1, 6,
+];
+
+pub const MODE_2_COUNTER: [u8; 14] = [
+    9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 3, 1,
+];
+
+pub const KF_PARTITION_PROBS: [u8; 48] = [
+    158, 97, 94,
+    93, 24, 99,
+    85, 119, 44,
+    62, 59, 67,
+    149, 53, 53,
+    94, 20, 48,
+    83, 53, 24,
+    52, 18, 18,
+    150, 40, 39,
+    78, 12, 26,
+    67, 33, 11,
+    24, 7, 5,
+    174, 35, 49,
+    68, 11, 27,
+    57, 15, 9,
+    12, 3, 3,
+];
+
+pub const KF_Y_MODE_PROBS: [u8; 900] = [
+    137, 30, 42, 148, 151, 207, 70, 52, 91,
+    92, 45, 102, 136, 116, 180, 74, 90, 100,
+    73, 32, 19, 187, 222, 215, 46, 34, 100,
+    91, 30, 32, 116, 121, 186, 93, 86, 94,
+    72, 35, 36, 149, 68, 206, 68, 63, 105,
+    73, 31, 28, 138, 57, 124, 55, 122, 151,
+    67, 23, 21, 140, 126, 197, 40, 37, 171,
+    86, 27, 28, 128, 154, 212, 45, 43, 53,
+    74, 32, 27, 107, 86, 160, 63, 134, 102,
+    59, 67, 44, 140, 161, 202, 78, 67, 119,
+    63, 36, 126, 146, 123, 158, 60, 90, 96,
+    43, 46, 168, 134, 107, 128, 69, 142, 92,
+    44, 29, 68, 159, 201, 177, 50, 57, 77,
+    58, 38, 76, 114, 97, 172, 78, 133, 92,
+    46, 41, 76, 140, 63, 184, 69, 112, 57,
+    38, 32, 85, 140, 46, 112, 54, 151, 133,
+    39, 27, 61, 131, 110, 175, 44, 75, 136,
+    52, 30, 74, 113, 130, 175, 51, 64, 58,
+    47, 35, 80, 100, 74, 143, 64, 163, 74,
+    36, 61, 116, 114, 128, 162, 80, 125, 82,
+    82, 26, 26, 171, 208, 204, 44, 32, 105,
+    55, 44, 68, 166, 179, 192, 57, 57, 108,
+    42, 26, 11, 199, 241, 228, 23, 15, 85,
+    68, 42, 19, 131, 160, 199, 55, 52, 83,
+    58, 50, 25, 139, 115, 232, 39, 52, 118,
+    50, 35, 33, 153, 104, 162, 64, 59, 131,
+    44, 24, 16, 150, 177, 202, 33, 19, 156,
+    55, 27, 12, 153, 203, 218, 26, 27, 49,
+    53, 49, 21, 110, 116, 168, 59, 80, 76,
+    38, 72, 19, 168, 203, 212, 50, 50, 107,
+    103, 26, 36, 129, 132, 201, 83, 80, 93,
+    59, 38, 83, 112, 103, 162, 98, 136, 90,
+    62, 30, 23, 158, 200, 207, 59, 57, 50,
+    67, 30, 29, 84, 86, 191, 102, 91, 59,
+    60, 32, 33, 112, 71, 220, 64, 89, 104,
+    53, 26, 34, 130, 56, 149, 84, 120, 103,
+    53, 21, 23, 133, 109, 210, 56, 77, 172,
+    77, 19, 29, 112, 142, 228, 55, 66, 36,
+    61, 29, 29, 93, 97, 165, 83, 175, 162,
+    47, 47, 43, 114, 137, 181, 100, 99, 95,
+    69, 23, 29, 128, 83, 199, 46, 44, 101,
+    53, 40, 55, 139, 69, 183, 61, 80, 110,
+    40, 29, 19, 161, 180, 207, 43, 24, 91,
+    60, 34, 19, 105, 61, 198, 53, 64, 89,
+    52, 31, 22, 158, 40, 209, 58, 62, 89,
+    44, 31, 29, 147, 46, 158, 56, 102, 198,
+    35, 19, 12, 135, 87, 209, 41, 45, 167,
+    55, 25, 21, 118, 95, 215, 38, 39, 66,
+    51, 38, 25, 113, 58, 164, 70, 93, 97,
+    47, 54, 34, 146, 108, 203, 72, 103, 151,
+    64, 19, 37, 156, 66, 138, 49, 95, 133,
+    46, 27, 80, 150, 55, 124, 55, 121, 135,
+    36, 23, 27, 165, 149, 166, 54, 64, 118,
+    53, 21, 36, 131, 63, 163, 60, 109, 81,
+    40, 26, 35, 154, 40, 185, 51, 97, 123,
+    35, 19, 34, 179, 19, 97, 48, 129, 124,
+    36, 20, 26, 136, 62, 164, 33, 77, 154,
+    45, 18, 32, 130, 90, 157, 40, 79, 91,
+    45, 26, 28, 129, 45, 129, 49, 147, 123,
+    38, 44, 51, 136, 74, 162, 57, 97, 121,
+    75, 17, 22, 136, 138, 185, 32, 34, 166,
+    56, 39, 58, 133, 117, 173, 48, 53, 187,
+    35, 21, 12, 161, 212, 207, 20, 23, 145,
+    56, 29, 19, 117, 109, 181, 55, 68, 112,
+    47, 29, 17, 153, 64, 220, 59, 51, 114,
+    46, 16, 24, 136, 76, 147, 41, 64, 172,
+    34, 17, 11, 108, 152, 187, 13, 15, 209,
+    51, 24, 14, 115, 133, 209, 32, 26, 104,
+    55, 30, 18, 122, 79, 179, 44, 88, 116,
+    37, 49, 25, 129, 168, 164, 41, 54, 148,
+    82, 22, 32, 127, 143, 213, 39, 41, 70,
+    62, 44, 61, 123, 105, 189, 48, 57, 64,
+    47, 25, 17, 175, 222, 220, 24, 30, 86,
+    68, 36, 17, 106, 102, 206, 59, 74, 74,
+    57, 39, 23, 151, 68, 216, 55, 63, 58,
+    49, 30, 35, 141, 70, 168, 82, 40, 115,
+    51, 25, 15, 136, 129, 202, 38, 35, 139,
+    68, 26, 16, 111, 141, 215, 29, 28, 28,
+    59, 39, 19, 114, 75, 180, 77, 104, 42,
+    40, 61, 26, 126, 152, 206, 61, 59, 93,
+    78, 23, 39, 111, 117, 170, 74, 124, 94,
+    48, 34, 86, 101, 92, 146, 78, 179, 134,
+    47, 22, 24, 138, 187, 178, 68, 69, 59,
+    56, 25, 33, 105, 112, 187, 95, 177, 129,
+    48, 31, 27, 114, 63, 183, 82, 116, 56,
+    43, 28, 37, 121, 63, 123, 61, 192, 169,
+    42, 17, 24, 109, 97, 177, 56, 76, 122,
+    58, 18, 28, 105, 139, 182, 70, 92, 63,
+    46, 23, 32, 74, 86, 150, 67, 183, 88,
+    36, 38, 48, 92, 122, 165, 88, 137, 91,
+    65, 70, 60, 155, 159, 199, 61, 60, 81,
+    44, 78, 115, 132, 119, 173, 71, 112, 93,
+    39, 38, 21, 184, 227, 206, 42, 32, 64,
+    58, 47, 36, 124, 137, 193, 80, 82, 78,
+    49, 50, 35, 144, 95, 205, 63, 78, 59,
+    41, 53, 52, 148, 71, 142, 65, 128, 51,
+    40, 36, 28, 143, 143, 202, 40, 55, 137,
+    52, 34, 29, 129, 183, 227, 42, 35, 43,
+    42, 44, 44, 104, 105, 164, 64, 130, 80,
+    43, 81, 53, 140, 169, 204, 68, 84, 72,
+];
+
+pub const KF_UV_MODE_PROBS: [u8; 90] = [
+    144, 11, 54, 157, 195, 130, 46, 58, 108,
+    118, 15, 123, 148, 131, 101, 44, 93, 131,
+    113, 12, 23, 188, 226, 142, 26, 32, 125,
+    120, 11, 50, 123, 163, 135, 64, 77, 103,
+    113, 9, 36, 155, 111, 157, 32, 44, 161,
+    116, 9, 55, 176, 76, 96, 37, 61, 149,
+    115, 9, 28, 141, 161, 167, 21, 25, 193,
+    120, 12, 32, 145, 195, 142, 32, 38, 86,
+    116, 12, 64, 120, 140, 125, 49, 115, 121,
+    102, 19, 66, 162, 182, 122, 35, 59, 128,
+];
+
+pub const DEFAULT_PARTITION_PROBS: [u8; 48] = [
+    199, 122, 141,
+    147, 63, 159,
+    148, 133, 118,
+    121, 104, 114,
+    174, 73, 87,
+    92, 41, 83,
+    82, 99, 50,
+    53, 39, 39,
+    177, 58, 59,
+    68, 26, 63,
+    52, 79, 25,
+    17, 14, 12,
+    222, 34, 30,
+    72, 16, 44,
+    58, 32, 12,
+    10, 7, 6,
+];
+
+pub const DEFAULT_Y_MODE_PROBS: [u8; 36] = [
+    65, 32, 18, 144, 162, 194, 41, 51, 98,
+    132, 68, 18, 165, 217, 196, 45, 40, 78,
+    173, 80, 19, 176, 240, 193, 64, 35, 46,
+    221, 135, 38, 194, 248, 121, 96, 85, 29,
+];
+
+pub const DEFAULT_UV_MODE_PROBS: [u8; 90] = [
+    120, 7, 76, 176, 208, 126, 28, 54, 103,
+    48, 12, 154, 155, 139, 90, 34, 117, 119,
+    67, 6, 25, 204, 243, 158, 13, 21, 96,
+    97, 5, 44, 131, 176, 139, 48, 68, 97,
+    83, 5, 42, 156, 111, 152, 26, 49, 152,
+    80, 5, 58, 178, 74, 83, 33, 62, 145,
+    86, 5, 32, 154, 192, 168, 14, 22, 163,
+    85, 5, 32, 156, 216, 148, 19, 29, 73,
+    77, 7, 64, 116, 132, 122, 37, 126, 120,
+    101, 21, 107, 181, 192, 103, 19, 67, 125,
+];
+
+pub const DEFAULT_SKIP_PROB: [u8; 3] = [
+    192, 128, 64,
+];
+
+pub const DEFAULT_IS_INTER_PROB: [u8; 4] = [
+    9, 102, 187, 225,
+];
+
+pub const DEFAULT_COMP_MODE_PROB: [u8; 5] = [
+    239, 183, 119, 96, 41,
+];
+
+pub const DEFAULT_COMP_REF_PROB: [u8; 5] = [
+    50, 126, 123, 221, 226,
+];
+
+pub const DEFAULT_SINGLE_REF_PROB: [u8; 10] = [
+    33, 16,
+    77, 74,
+    142, 142,
+    172, 170,
+    238, 247,
+];
+
+pub const DEFAULT_MV_SIGN_PROB: [u8; 2] = [
+    128, 128,
+];
+
+pub const DEFAULT_MV_BITS_PROB: [u8; 20] = [
+    136, 140, 148, 160, 176, 192, 224, 234, 234, 240,
+    136, 140, 148, 160, 176, 192, 224, 234, 234, 240,
+];
+
+pub const DEFAULT_MV_CLASS0_BIT_PROB: [u8; 2] = [
+    216, 208,
+];
+
+pub const DEFAULT_TX_PROBS: [u8; 24] = [
+    0, 0, 0,
+    0, 0, 0,
+    100, 0, 0,
+    66, 0, 0,
+    20, 152, 0,
+    15, 101, 0,
+    3, 136, 37,
+    5, 52, 13,
+];
+
+pub const DEFAULT_INTER_MODE_PROBS: [u8; 21] = [
+    2, 173, 34,
+    7, 145, 85,
+    7, 166, 63,
+    7, 94, 66,
+    8, 64, 46,
+    17, 81, 31,
+    25, 29, 30,
+];
+
+pub const DEFAULT_INTERP_FILTER_PROBS: [u8; 8] = [
+    235, 162,
+    36, 255,
+    34, 3,
+    149, 144,
+];
+
+pub const DEFAULT_MV_JOINT_PROBS: [u8; 3] = [
+    32, 64, 96,
+];
+
+pub const DEFAULT_MV_CLASS_PROBS: [u8; 20] = [
+    224, 144, 192, 168, 192, 176, 192, 198, 198, 245,
+    216, 128, 176, 160, 176, 176, 192, 198, 198, 208,
+];
+
+pub const DEFAULT_MV_CLASS0_FR_PROBS: [u8; 12] = [
+    128, 128, 64,
+    96, 112, 64,
+    128, 128, 64,
+    96, 112, 64,
+];
+
+pub const DEFAULT_MV_CLASS0_HP_PROB: [u8; 2] = [
+    160, 160,
+];
+
+pub const DEFAULT_MV_FR_PROBS: [u8; 6] = [
+    64, 96, 64,
+    64, 96, 64,
+];
+
+pub const DEFAULT_MV_HP_PROB: [u8; 2] = [
+    128, 128,
+];
+
+pub const DEFAULT_COEF_PROBS: [u8; 1728] = [
+    195, 29, 183,
+    84, 49, 136,
+    8, 42, 71,
+    0, 0, 0,
+    0, 0, 0,
+    0, 0, 0,
+    31, 107, 169,
+    35, 99, 159,
+    17, 82, 140,
+    8, 66, 114,
+    2, 44, 76,
+    1, 19, 32,
+    40, 132, 201,
+    29, 114, 187,
+    13, 91, 157,
+    7, 75, 127,
+    3, 58, 95,
+    1, 28, 47,
+    69, 142, 221,
+    42, 122, 201,
+    15, 91, 159,
+    6, 67, 121,
+    1, 42, 77,
+    1, 17, 31,
+    102, 148, 228,
+    67, 117, 204,
+    17, 82, 154,
+    6, 59, 114,
+    2, 39, 75,
+    1, 15, 29,
+    156, 57, 233,
+    119, 57, 212,
+    58, 48, 163,
+    29, 40, 124,
+    12, 30, 81,
+    3, 12, 31,
+    191, 107, 226,
+    124, 117, 204,
+    25, 99, 155,
+    0, 0, 0,
+    0, 0, 0,
+    0, 0, 0,
+    29, 148, 210,
+    37, 126, 194,
+    8, 93, 157,
+    2, 68, 118,
+    1, 39, 69,
+    1, 17, 33,
+    41, 151, 213,
+    27, 123, 193,
+    3, 82, 144,
+    1, 58, 105,
+    1, 32, 60,
+    1, 13, 26,
+    59, 159, 220,
+    23, 126, 198,
+    4, 88, 151,
+    1, 66, 114,
+    1, 38, 71,
+    1, 18, 34,
+    114, 136, 232,
+    51, 114, 207,
+    11, 83, 155,
+    3, 56, 105,
+    1, 33, 65,
+    1, 17, 34,
+    149, 65, 234,
+    121, 57, 215,
+    61, 49, 166,
+    28, 36, 114,
+    12, 25, 76,
+    3, 16, 42,
+    214, 49, 220,
+    132, 63, 188,
+    42, 65, 137,
+    0, 0, 0,
+    0, 0, 0,
+    0, 0, 0,
+    85, 137, 221,
+    104, 131, 216,
+    49, 111, 192,
+    21, 87, 155,
+    2, 49, 87,
+    1, 16, 28,
+    89, 163, 230,
+    90, 137, 220,
+    29, 100, 183,
+    10, 70, 135,
+    2, 42, 81,
+    1, 17, 33,
+    108, 167, 237,
+    55, 133, 222,
+    15, 97, 179,
+    4, 72, 135,
+    1, 45, 85,
+    1, 19, 38,
+    124, 146, 240,
+    66, 124, 224,
+    17, 88, 175,
+    4, 58, 122,
+    1, 36, 75,
+    1, 18, 37,
+    141, 79, 241,
+    126, 70, 227,
+    66, 58, 182,
+    30, 44, 136,
+    12, 34, 96,
+    2, 20, 47,
+    229, 99, 249,
+    143, 111, 235,
+    46, 109, 192,
+    0, 0, 0,
+    0, 0, 0,
+    0, 0, 0,
+    82, 158, 236,
+    94, 146, 224,
+    25, 117, 191,
+    9, 87, 149,
+    3, 56, 99,
+    1, 33, 57,
+    83, 167, 237,
+    68, 145, 222,
+    10, 103, 177,
+    2, 72, 131,
+    1, 41, 79,
+    1, 20, 39,
+    99, 167, 239,
+    47, 141, 224,
+    10, 104, 178,
+    2, 73, 133,
+    1, 44, 85,
+    1, 22, 47,
+    127, 145, 243,
+    71, 129, 228,
+    17, 93, 177,
+    3, 61, 124,
+    1, 41, 84,
+    1, 21, 52,
+    157, 78, 244,
+    140, 72, 231,
+    69, 58, 184,
+    31, 44, 137,
+    14, 38, 105,
+    8, 23, 61,
+    125, 34, 187,
+    52, 41, 133,
+    6, 31, 56,
+    0, 0, 0,
+    0, 0, 0,
+    0, 0, 0,
+    37, 109, 153,
+    51, 102, 147,
+    23, 87, 128,
+    8, 67, 101,
+    1, 41, 63,
+    1, 19, 29,
+    31, 154, 185,
+    17, 127, 175,
+    6, 96, 145,
+    2, 73, 114,
+    1, 51, 82,
+    1, 28, 45,
+    23, 163, 200,
+    10, 131, 185,
+    2, 93, 148,
+    1, 67, 111,
+    1, 41, 69,
+    1, 14, 24,
+    29, 176, 217,
+    12, 145, 201,
+    3, 101, 156,
+    1, 69, 111,
+    1, 39, 63,
+    1, 14, 23,
+    57, 192, 233,
+    25, 154, 215,
+    6, 109, 167,
+    3, 78, 118,
+    1, 48, 69,
+    1, 21, 29,
+    202, 105, 245,
+    108, 106, 216,
+    18, 90, 144,
+    0, 0, 0,
+    0, 0, 0,
+    0, 0, 0,
+    33, 172, 219,
+    64, 149, 206,
+    14, 117, 177,
+    5, 90, 141,
+    2, 61, 95,
+    1, 37, 57,
+    33, 179, 220,
+    11, 140, 198,
+    1, 89, 148,
+    1, 60, 104,
+    1, 33, 57,
+    1, 12, 21,
+    30, 181, 221,
+    8, 141, 198,
+    1, 87, 145,
+    1, 58, 100,
+    1, 31, 55,
+    1, 12, 20,
+    32, 186, 224,
+    7, 142, 198,
+    1, 86, 143,
+    1, 58, 100,
+    1, 31, 55,
+    1, 12, 22,
+    57, 192, 227,
+    20, 143, 204,
+    3, 96, 154,
+    1, 68, 112,
+    1, 42, 69,
+    1, 19, 32,
+    212, 35, 215,
+    113, 47, 169,
+    29, 48, 105,
+    0, 0, 0,
+    0, 0, 0,
+    0, 0, 0,
+    74, 129, 203,
+    106, 120, 203,
+    49, 107, 178,
+    19, 84, 144,
+    4, 50, 84,
+    1, 15, 25,
+    71, 172, 217,
+    44, 141, 209,
+    15, 102, 173,
+    6, 76, 133,
+    2, 51, 89,
+    1, 24, 42,
+    64, 185, 231,
+    31, 148, 216,
+    8, 103, 175,
+    3, 74, 131,
+    1, 46, 81,
+    1, 18, 30,
+    65, 196, 235,
+    25, 157, 221,
+    5, 105, 174,
+    1, 67, 120,
+    1, 38, 69,
+    1, 15, 30,
+    65, 204, 238,
+    30, 156, 224,
+    7, 107, 177,
+    2, 70, 124,
+    1, 42, 73,
+    1, 18, 34,
+    225, 86, 251,
+    144, 104, 235,
+    42, 99, 181,
+    0, 0, 0,
+    0, 0, 0,
+    0, 0, 0,
+    85, 175, 239,
+    112, 165, 229,
+    29, 136, 200,
+    12, 103, 162,
+    6, 77, 123,
+    2, 53, 84,
+    75, 183, 239,
+    30, 155, 221,
+    3, 106, 171,
+    1, 74, 128,
+    1, 44, 76,
+    1, 17, 28,
+    73, 185, 240,
+    27, 159, 222,
+    2, 107, 172,
+    1, 75, 127,
+    1, 42, 73,
+    1, 17, 29,
+    62, 190, 238,
+    21, 159, 222,
+    2, 107, 172,
+    1, 72, 122,
+    1, 40, 71,
+    1, 18, 32,
+    61, 199, 240,
+    27, 161, 226,
+    4, 113, 180,
+    1, 76, 129,
+    1, 46, 80,
+    1, 23, 41,
+    7, 27, 153,
+    5, 30, 95,
+    1, 16, 30,
+    0, 0, 0,
+    0, 0, 0,
+    0, 0, 0,
+    50, 75, 127,
+    57, 75, 124,
+    27, 67, 108,
+    10, 54, 86,
+    1, 33, 52,
+    1, 12, 18,
+    43, 125, 151,
+    26, 108, 148,
+    7, 83, 122,
+    2, 59, 89,
+    1, 38, 60,
+    1, 17, 27,
+    23, 144, 163,
+    13, 112, 154,
+    2, 75, 117,
+    1, 50, 81,
+    1, 31, 51,
+    1, 14, 23,
+    18, 162, 185,
+    6, 123, 171,
+    1, 78, 125,
+    1, 51, 86,
+    1, 31, 54,
+    1, 14, 23,
+    15, 199, 227,
+    3, 150, 204,
+    1, 91, 146,
+    1, 55, 95,
+    1, 30, 53,
+    1, 11, 20,
+    19, 55, 240,
+    19, 59, 196,
+    3, 52, 105,
+    0, 0, 0,
+    0, 0, 0,
+    0, 0, 0,
+    41, 166, 207,
+    104, 153, 199,
+    31, 123, 181,
+    14, 101, 152,
+    5, 72, 106,
+    1, 36, 52,
+    35, 176, 211,
+    12, 131, 190,
+    2, 88, 144,
+    1, 60, 101,
+    1, 36, 60,
+    1, 16, 28,
+    28, 183, 213,
+    8, 134, 191,
+    1, 86, 142,
+    1, 56, 96,
+    1, 30, 53,
+    1, 12, 20,
+    20, 190, 215,
+    4, 135, 192,
+    1, 84, 139,
+    1, 53, 91,
+    1, 28, 49,
+    1, 11, 20,
+    13, 196, 216,
+    2, 137, 192,
+    1, 86, 143,
+    1, 57, 99,
+    1, 32, 56,
+    1, 13, 24,
+    211, 29, 217,
+    96, 47, 156,
+    22, 43, 87,
+    0, 0, 0,
+    0, 0, 0,
+    0, 0, 0,
+    78, 120, 193,
+    111, 116, 186,
+    46, 102, 164,
+    15, 80, 128,
+    2, 49, 76,
+    1, 18, 28,
+    71, 161, 203,
+    42, 132, 192,
+    10, 98, 150,
+    3, 69, 109,
+    1, 44, 70,
+    1, 18, 29,
+    57, 186, 211,
+    30, 140, 196,
+    4, 93, 146,
+    1, 62, 102,
+    1, 38, 65,
+    1, 16, 27,
+    47, 199, 217,
+    14, 145, 196,
+    1, 88, 142,
+    1, 57, 98,
+    1, 36, 62,
+    1, 15, 26,
+    26, 219, 229,
+    5, 155, 207,
+    1, 94, 151,
+    1, 60, 104,
+    1, 36, 62,
+    1, 16, 28,
+    233, 29, 248,
+    146, 47, 220,
+    43, 52, 140,
+    0, 0, 0,
+    0, 0, 0,
+    0, 0, 0,
+    100, 163, 232,
+    179, 161, 222,
+    63, 142, 204,
+    37, 113, 174,
+    26, 89, 137,
+    18, 68, 97,
+    85, 181, 230,
+    32, 146, 209,
+    7, 100, 164,
+    3, 71, 121,
+    1, 45, 77,
+    1, 18, 30,
+    65, 187, 230,
+    20, 148, 207,
+    2, 97, 159,
+    1, 68, 116,
+    1, 40, 70,
+    1, 14, 29,
+    40, 194, 227,
+    8, 147, 204,
+    1, 94, 155,
+    1, 65, 112,
+    1, 39, 66,
+    1, 14, 26,
+    16, 208, 228,
+    3, 151, 207,
+    1, 98, 160,
+    1, 67, 117,
+    1, 41, 74,
+    1, 17, 31,
+    17, 38, 140,
+    7, 34, 80,
+    1, 17, 29,
+    0, 0, 0,
+    0, 0, 0,
+    0, 0, 0,
+    37, 75, 128,
+    41, 76, 128,
+    26, 66, 116,
+    12, 52, 94,
+    2, 32, 55,
+    1, 10, 16,
+    50, 127, 154,
+    37, 109, 152,
+    16, 82, 121,
+    5, 59, 85,
+    1, 35, 54,
+    1, 13, 20,
+    40, 142, 167,
+    17, 110, 157,
+    2, 71, 112,
+    1, 44, 72,
+    1, 27, 45,
+    1, 11, 17,
+    30, 175, 188,
+    9, 124, 169,
+    1, 74, 116,
+    1, 48, 78,
+    1, 30, 49,
+    1, 11, 18,
+    10, 222, 223,
+    2, 150, 194,
+    1, 83, 128,
+    1, 48, 79,
+    1, 27, 45,
+    1, 11, 17,
+    36, 41, 235,
+    29, 36, 193,
+    10, 27, 111,
+    0, 0, 0,
+    0, 0, 0,
+    0, 0, 0,
+    85, 165, 222,
+    177, 162, 215,
+    110, 135, 195,
+    57, 113, 168,
+    23, 83, 120,
+    10, 49, 61,
+    85, 190, 223,
+    36, 139, 200,
+    5, 90, 146,
+    1, 60, 103,
+    1, 38, 65,
+    1, 18, 30,
+    72, 202, 223,
+    23, 141, 199,
+    2, 86, 140,
+    1, 56, 97,
+    1, 36, 61,
+    1, 16, 27,
+    55, 218, 225,
+    13, 145, 200,
+    1, 86, 141,
+    1, 57, 99,
+    1, 35, 61,
+    1, 13, 22,
+    15, 235, 212,
+    1, 132, 184,
+    1, 84, 139,
+    1, 57, 97,
+    1, 34, 56,
+    1, 14, 23,
+    181, 21, 201,
+    61, 37, 123,
+    10, 38, 71,
+    0, 0, 0,
+    0, 0, 0,
+    0, 0, 0,
+    47, 106, 172,
+    95, 104, 173,
+    42, 93, 159,
+    18, 77, 131,
+    4, 50, 81,
+    1, 17, 23,
+    62, 147, 199,
+    44, 130, 189,
+    28, 102, 154,
+    18, 75, 115,
+    2, 44, 65,
+    1, 12, 19,
+    55, 153, 210,
+    24, 130, 194,
+    3, 93, 146,
+    1, 61, 97,
+    1, 31, 50,
+    1, 10, 16,
+    49, 186, 223,
+    17, 148, 204,
+    1, 96, 142,
+    1, 53, 83,
+    1, 26, 44,
+    1, 11, 17,
+    13, 217, 212,
+    2, 136, 180,
+    1, 78, 124,
+    1, 50, 83,
+    1, 29, 49,
+    1, 14, 23,
+    197, 13, 247,
+    82, 17, 222,
+    25, 17, 162,
+    0, 0, 0,
+    0, 0, 0,
+    0, 0, 0,
+    126, 186, 247,
+    234, 191, 243,
+    176, 177, 234,
+    104, 158, 220,
+    66, 128, 186,
+    55, 90, 137,
+    111, 197, 242,
+    46, 158, 219,
+    9, 104, 171,
+    2, 65, 125,
+    1, 44, 80,
+    1, 17, 91,
+    104, 208, 245,
+    39, 168, 224,
+    3, 109, 162,
+    1, 79, 124,
+    1, 50, 102,
+    1, 43, 102,
+    84, 220, 246,
+    31, 177, 231,
+    2, 115, 180,
+    1, 79, 134,
+    1, 55, 77,
+    1, 60, 79,
+    43, 243, 240,
+    8, 180, 217,
+    1, 115, 166,
+    1, 84, 121,
+    1, 51, 67,
+    1, 16, 6,
+];
+
diff --git a/crates/vp9/src/tables.rs b/crates/vp9/src/tables.rs
new file mode 100644
index 000000000..d11e35cf5
--- /dev/null
+++ b/crates/vp9/src/tables.rs
@@ -0,0 +1,285 @@
+//! Constants, small lookup tables and decode trees of the VP9 specification (sections 3, 6, 9.3
+//! and 10.2). The large tables are extracted from the specification text into `spec_tables`.
+
+pub use crate::spec_tables::*;
+
+// Block sizes (7.4.3).
+pub const BLOCK_8X8: u8 = 3;
+pub const BLOCK_16X16: u8 = 6;
+pub const BLOCK_64X64: u8 = 12;
+pub const BLOCK_INVALID: u8 = 14;
+
+// Transform sizes / modes.
+pub const TX_4X4: u8 = 0;
+pub const TX_8X8: u8 = 1;
+pub const TX_16X16: u8 = 2;
+pub const TX_32X32: u8 = 3;
+pub const TX_MODE_SELECT: u8 = 4;
+
+// Prediction modes (7.4.5, 7.4.11).
+pub const DC_PRED: u8 = 0;
+pub const V_PRED: u8 = 1;
+pub const H_PRED: u8 = 2;
+pub const D45_PRED: u8 = 3;
+pub const D135_PRED: u8 = 4;
+pub const D117_PRED: u8 = 5;
+pub const D153_PRED: u8 = 6;
+pub const D207_PRED: u8 = 7;
+pub const D63_PRED: u8 = 8;
+pub const TM_PRED: u8 = 9;
+pub const NEARESTMV: u8 = 10;
+pub const NEARMV: u8 = 11;
+pub const ZEROMV: u8 = 12;
+pub const NEWMV: u8 = 13;
+
+// Reference frames.
+pub const NONE: i8 = -1;
+pub const INTRA_FRAME: i8 = 0;
+pub const LAST_FRAME: i8 = 1;
+pub const GOLDEN_FRAME: i8 = 2;
+pub const ALTREF_FRAME: i8 = 3;
+
+// Transform types.
+pub const DCT_DCT: u8 = 0;
+pub const ADST_DCT: u8 = 1;
+pub const DCT_ADST: u8 = 2;
+pub const ADST_ADST: u8 = 3;
+
+// Interpolation filters.
+pub const SWITCHABLE: u8 = 4;
+
+// Segmentation features.
+pub const SEG_LVL_ALT_Q: usize = 0;
+pub const SEG_LVL_ALT_L: usize = 1;
+pub const SEG_LVL_REF_FRAME: usize = 2;
+pub const SEG_LVL_SKIP: usize = 3;
+pub const MAX_SEGMENTS: usize = 8;
+
+pub const MAX_LOOP_FILTER: i32 = 63;
+pub const MIN_TILE_WIDTH_B64: u32 = 4;
+pub const MAX_TILE_WIDTH_B64: u32 = 64;
+pub const COMPANDED_MVREF_THRESH: i32 = 8;
+pub const MV_BORDER: i32 = 128;
+pub const INTERP_EXTEND: i32 = 4;
+pub const BORDERINPIXELS: i32 = 160;
+pub const COUNT_SAT: u32 = 20;
+pub const MAX_UPDATE_FACTOR: u32 = 128;
+
+pub const B_WIDTH_LOG2: [u8; 13] = [0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4];
+pub const B_HEIGHT_LOG2: [u8; 13] = [0, 1, 0, 1, 2, 1, 2, 3, 2, 3, 4, 3, 4];
+pub const NUM_4X4_WIDE: [u8; 13] = [1, 1, 2, 2, 2, 4, 4, 4, 8, 8, 8, 16, 16];
+pub const NUM_4X4_HIGH: [u8; 13] = [1, 2, 1, 2, 4, 2, 4, 8, 4, 8, 16, 8, 16];
+pub const MI_WIDTH_LOG2: [u8; 13] = [0, 0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3];
+pub const NUM_8X8_WIDE: [u8; 13] = [1, 1, 1, 1, 1, 2, 2, 2, 4, 4, 4, 8, 8];
+pub const NUM_8X8_HIGH: [u8; 13] = [1, 1, 1, 1, 2, 1, 2, 4, 2, 4, 8, 4, 8];
+pub const SIZE_GROUP: [u8; 13] = [0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 3];
+pub const MAX_TXSIZE: [u8; 13] = [0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 3];
+pub const TX_MODE_TO_BIGGEST_TX_SIZE: [u8; 5] = [0, 1, 2, 3, 3];
+
+/// subsize_lookup[partition][bsize] (10.2).
+pub const SUBSIZE_LOOKUP: [[u8; 13]; 4] = [
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
+    [14, 14, 14, 2, 14, 14, 5, 14, 14, 8, 14, 14, 11],
+    [14, 14, 14, 1, 14, 14, 4, 14, 14, 7, 14, 14, 10],
+    [14, 14, 14, 0, 14, 14, 3, 14, 14, 6, 14, 14, 9],
+];
+
+/// ss_size_lookup[bsize][subsampling_x][subsampling_y] (6.4.23).
+pub const SS_SIZE_LOOKUP: [[[u8; 2]; 2]; 13] = [
+    [[0, 14], [14, 14]],
+    [[1, 0], [14, 14]],
+    [[2, 14], [0, 14]],
+    [[3, 2], [1, 0]],
+    [[4, 3], [14, 1]],
+    [[5, 14], [3, 2]],
+    [[6, 5], [4, 3]],
+    [[7, 6], [14, 4]],
+    [[8, 14], [6, 5]],
+    [[9, 8], [7, 6]],
+    [[10, 9], [14, 7]],
+    [[11, 14], [9, 8]],
+    [[12, 11], [10, 9]],
+];
+
+/// mode2txfm_map (10.2).
+pub const MODE2TXFM: [u8; 14] =
+    [DCT_DCT, ADST_DCT, DCT_ADST, DCT_DCT, ADST_ADST, ADST_DCT, DCT_ADST, DCT_ADST, ADST_DCT, ADST_ADST, DCT_DCT, DCT_DCT, DCT_DCT, DCT_DCT];
+
+/// counter_to_context (6.5.1); INVALID_CASE entries are 9.
+pub const COUNTER_TO_CONTEXT: [u8; 19] = [2, 3, 4, 1, 3, 9, 0, 9, 9, 5, 5, 9, 5, 9, 9, 9, 9, 9, 6];
+
+/// idx_n_column_to_subblock (6.5.11).
+pub const IDX_N_COLUMN_TO_SUBBLOCK: [[u8; 2]; 4] = [[1, 2], [1, 3], [3, 2], [3, 3]];
+
+/// literal_to_type (6.2.7).
+pub const LITERAL_TO_TYPE: [u8; 4] = [1, 0, 2, 3];
+
+pub const SEGMENTATION_FEATURE_BITS: [u32; 4] = [8, 6, 2, 0];
+pub const SEGMENTATION_FEATURE_SIGNED: [bool; 4] = [true, true, false, false];
+
+/// extra_bits[token] = (cat, numExtra, base) (6.4.26).
+pub const EXTRA_BITS: [(u8, u8, u16); 11] =
+    [(0, 0, 0), (0, 0, 1), (0, 0, 2), (0, 0, 3), (0, 0, 4), (1, 1, 5), (2, 2, 7), (3, 3, 11), (4, 4, 19), (5, 5, 35), (6, 14, 67)];
+
+/// cat_probs (6.4.26).
+pub const CAT_PROBS: [&[u8]; 7] = [
+    &[],
+    &[159],
+    &[165, 145],
+    &[173, 148, 140],
+    &[176, 155, 140, 135],
+    &[180, 157, 141, 134, 130],
+    &[254, 254, 254, 252, 249, 243, 230, 196, 177, 153, 140, 133, 130, 129],
+];
+
+// Decode trees (9.3.1); leaves are stored negated.
+pub const PARTITION_TREE: [i8; 6] = [0, 2, -1, 4, -2, -3];
+pub const INTRA_MODE_TREE: [i8; 18] = [
+    -(DC_PRED as i8),
+    2,
+    -(TM_PRED as i8),
+    4,
+    -(V_PRED as i8),
+    6,
+    8,
+    12,
+    -(H_PRED as i8),
+    10,
+    -(D135_PRED as i8),
+    -(D117_PRED as i8),
+    -(D45_PRED as i8),
+    14,
+    -(D63_PRED as i8),
+    16,
+    -(D153_PRED as i8),
+    -(D207_PRED as i8),
+];
+pub const SEGMENT_TREE: [i8; 14] = [2, 4, 6, 8, 10, 12, 0, -1, -2, -3, -4, -5, -6, -7];
+pub const TX_SIZE_32_TREE: [i8; 6] = [0, 2, -1, 4, -2, -3];
+pub const TX_SIZE_16_TREE: [i8; 4] = [0, 2, -1, -2];
+pub const TX_SIZE_8_TREE: [i8; 2] = [0, -1];
+/// inter_mode_tree: values are inter_mode = y_mode - NEARESTMV.
+pub const INTER_MODE_TREE: [i8; 6] = [-2, 2, 0, 4, -1, -3];
+pub const INTERP_FILTER_TREE: [i8; 4] = [0, 2, -1, -2];
+pub const MV_JOINT_TREE: [i8; 6] = [0, 2, -1, 4, -2, -3];
+pub const MV_CLASS_TREE: [i8; 20] = [0, 2, -1, 4, 6, 8, -2, -3, 10, 12, -4, -5, -6, 14, 16, 18, -7, -8, -9, -10];
+pub const MV_FR_TREE: [i8; 6] = [0, 2, -1, 4, -2, -3];
+/// small_token_tree used by coefficient probability adaptation (8.4.3).
+pub const SMALL_TOKEN_TREE: [i8; 6] = [0, 0, 0, 4, -1, -2];
+pub const BINARY_TREE: [i8; 2] = [0, -1];
+
+/// Probabilities of the full token tree for each model probability (9.3.2 pareto): row
+/// `p - 1` holds the probabilities of token-tree nodes 2..9 when `coef_probs[..][2] == p`.
+pub fn pareto_full() -> &'static [[u8; 8]; 255] {
+    use std::sync::OnceLock;
+    static T: OnceLock<[[u8; 8]; 255]> = OnceLock::new();
+    T.get_or_init(|| {
+        let mut t = [[0u8; 8]; 255];
+        for p in 1..=255usize {
+            let x = (p - 1) / 2;
+            for n in 0..8 {
+                t[p - 1][n] =
+                    if p & 1 == 1 { PARETO_TABLE[x * 8 + n] } else { ((PARETO_TABLE[x * 8 + n] as u32 + PARETO_TABLE[(x + 1) * 8 + n] as u32) >> 1) as u8 };
+            }
+        }
+        t
+    })
+}
+
+/// Scan order for a transform size and type (6.4.25).
+pub fn scan(tx_size: u8, tx_type: u8) -> &'static [u16] {
+    match (tx_size, tx_type) {
+        (0, ADST_DCT) => &ROW_SCAN_4X4,
+        (0, DCT_ADST) => &COL_SCAN_4X4,
+        (0, _) => &DEFAULT_SCAN_4X4,
+        (1, ADST_DCT) => &ROW_SCAN_8X8,
+        (1, DCT_ADST) => &COL_SCAN_8X8,
+        (1, _) => &DEFAULT_SCAN_8X8,
+        (2, ADST_DCT) => &ROW_SCAN_16X16,
+        (2, DCT_ADST) => &COL_SCAN_16X16,
+        (2, _) => &DEFAULT_SCAN_16X16,
+        _ => &DEFAULT_SCAN_32X32,
+    }
+}
+
+/// Coefficient context neighbours (9.3.2, `nb`) for every scan position of a transform size and
+/// type: `[c] = (nb0, nb1)` positions in the block.
+pub fn neighbors(tx_size: u8, tx_type: u8) -> &'static [(u16, u16)] {
+    use std::sync::OnceLock;
+    static T: OnceLock<Vec<Vec<(u16, u16)>>> = OnceLock::new();
+    let all = T.get_or_init(|| {
+        let mut v = Vec::new();
+        for tx in 0..4u8 {
+            for ty in 0..4u8 {
+                let sc = scan(tx, ty);
+                let n = 4usize << tx;
+                let mut nb = vec![(0u16, 0u16); sc.len()];
+                for (c, &pos) in sc.iter().enumerate().skip(1) {
+                    let pos = pos as usize;
+                    let (i, j) = (pos / n, pos % n);
+                    nb[c] = if i > 0 && j > 0 {
+                        let a = ((i - 1) * n + j) as u16;
+                        let a2 = (i * n + j - 1) as u16;
+                        // Only the 4x4..16x16 scans depend on the type; 32x32 is always DCT_DCT.
+                        let ty = if tx == 3 { DCT_DCT } else { ty };
+                        match ty {
+                            DCT_ADST => (a, a),
+                            ADST_DCT => (a2, a2),
+                            _ => (a, a2),
+                        }
+                    } else if i > 0 {
+                        let a = ((i - 1) * n + j) as u16;
+                        (a, a)
+                    } else {
+                        let a = (i * n + j - 1) as u16;
+                        (a, a)
+                    };
+                }
+                v.push(nb);
+            }
+        }
+        v
+    });
+    &all[(tx_size * 4 + tx_type) as usize]
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn trees_are_consistent() {
+        // Every leaf value appears exactly once.
+        fn leaves(t: &[i8]) -> Vec<i8> {
+            let mut v: Vec<i8> =
+                t.iter().enumerate().filter(|(i, x)| **x <= 0 && !(*i == 0 && t.len() > 2 && t[0] == 0 && t[1] == 0)).map(|(_, x)| -x).collect();
+            v.sort();
+            v
+        }
+        assert_eq!(leaves(&INTRA_MODE_TREE), (0..10).collect::<Vec<i8>>());
+        assert_eq!(leaves(&MV_CLASS_TREE), (0..11).collect::<Vec<i8>>());
+        assert_eq!(leaves(&PARTITION_TREE), (0..4).collect::<Vec<i8>>());
+        assert_eq!(leaves(&INTER_MODE_TREE), (0..4).collect::<Vec<i8>>());
+    }
+
+    #[test]
+    fn pareto_rows() {
+        let p = pareto_full();
+        assert_eq!(p[0], [3, 86, 128, 6, 86, 23, 88, 29]);
+        assert_eq!(p[254][..], PARETO_TABLE[127 * 8..128 * 8]);
+    }
+
+    #[test]
+    fn default_coef_probs_unused_are_zero() {
+        for (k, chunk) in DEFAULT_COEF_PROBS.chunks(3 * 6).enumerate() {
+            let band = k % 6;
+            for (ctx, p) in chunk.chunks(3).enumerate() {
+                if band == 0 && ctx >= 3 {
+                    assert_eq!(p, [0, 0, 0]);
+                } else {
+                    assert!(p.iter().all(|&x| x > 0), "band {band} ctx {ctx}");
+                }
+            }
+        }
+    }
+}
diff --git a/crates/vp9/src/tile.rs b/crates/vp9/src/tile.rs
new file mode 100644
index 000000000..0c2ca02b5
--- /dev/null
+++ b/crates/vp9/src/tile.rs
@@ -0,0 +1,1082 @@
+//! Tile decoding: partition trees, mode info (6.4), and block reconstruction. One `TileDecoder`
+//! decodes all tiles of one tile column (tile columns are independent of each other; tile rows
+//! of a column are decoded in order).
+
+use crate::boolcoder::BoolDecoder;
+use crate::frame::{Frame, MiGrid, MiInfo, Mv};
+use crate::header::{FrameHeader, Segmentation};
+use crate::probs::{Counts, FrameContext};
+use crate::tables::*;
+
+mod recon;
+
+/// A reference frame as used by the current frame, with its scale factors (8.5.2.3).
+pub struct RefUse<'a> {
+    pub frame: &'a Frame,
+    pub x_scale: i32,
+    pub y_scale: i32,
+    pub x_step: i32,
+    pub y_step: i32,
+}
+
+/// Read-only data shared by all tile columns of a frame.
+pub struct FrameShared<'a> {
+    pub h: &'a FrameHeader,
+    pub fc: &'a FrameContext,
+    pub seg: &'a Segmentation,
+    /// PrevSegmentIds (MiRows x MiCols).
+    pub prev_seg_ids: &'a [u8],
+    /// Mode info of the previous frame when UsePrevFrameMvs is 1.
+    pub prev_mi: Option<&'a MiGrid>,
+    /// References for LAST, GOLDEN, ALTREF.
+    pub refs: [Option<RefUse<'a>>; 3],
+    /// Quantizers per segment: [segment][plane > 0][dc = 0 / ac = 1].
+    pub seg_q: [[[i32; 2]; 2]; 8],
+    /// Whether syntax elements need to be counted (backward adaptation enabled).
+    pub counting: bool,
+    pub pools: &'a crate::frame::Pools,
+}
+
+/// Output of one tile column: samples, mode info and segment ids of its columns.
+pub struct Strip {
+    pub mi_col_start: usize,
+    pub mi_col_end: usize,
+    /// Mode info, (mi_col_end - mi_col_start) x MiRows.
+    pub mi: Vec<MiInfo>,
+    pub seg_ids: Vec<u8>,
+    pub planes: [Vec<u16>; 3],
+    pub strides: [usize; 3],
+    /// Plane x coordinate of the first column of each plane buffer.
+    pub x_off: [usize; 3],
+    pub counts: Box<Counts>,
+    /// Statistics.
+    pub compound_blocks: u64,
+    pub scaled_blocks: u64,
+    pub intra_blocks: u64,
+    pub inter_blocks: u64,
+}
+
+/// Per-block state (the variables of 6.4.4 - 6.4.20).
+#[derive(Clone, Copy, Default)]
+struct Blk {
+    r: usize,
+    c: usize,
+    size: u8,
+    avail_u: bool,
+    avail_l: bool,
+    seg_id: u8,
+    skip: bool,
+    tx_size: u8,
+    is_inter: bool,
+    y_mode: u8,
+    sub_modes: [u8; 4],
+    uv_mode: u8,
+    ref_frame: [i8; 2],
+    interp_filter: u8,
+    block_mvs: [[Mv; 4]; 2],
+    left_ref: [i8; 2],
+    above_ref: [i8; 2],
+    left_intra: bool,
+    above_intra: bool,
+    left_single: bool,
+    above_single: bool,
+    eob_total: u32,
+}
+
+pub struct TileDecoder<'a> {
+    s: &'a FrameShared<'a>,
+    h: &'a FrameHeader,
+    fc: &'a FrameContext,
+    pub strip: Strip,
+    mi_cols: usize,
+    mi_rows: usize,
+    ss_x: usize,
+    ss_y: usize,
+    bit_depth: u8,
+    // Contexts (indexed by absolute position).
+    above_nonzero: [Vec<u8>; 3],
+    left_nonzero: [Vec<u8>; 3],
+    above_partition: Vec<u8>,
+    left_partition: Vec<u8>,
+    above_seg_pred: Vec<u8>,
+    left_seg_pred: Vec<u8>,
+    // MV prediction state.
+    ref_list_mv: [Mv; 2],
+    ref_mv_count: usize,
+    mode_context: [u8; 4],
+    nearest_mv: [Mv; 2],
+    near_mv: [Mv; 2],
+    best_mv: [Mv; 2],
+    // Scratch.
+    coefs: Vec<i32>,
+    token_cache: Vec<u8>,
+    pred: Vec<u16>,
+    pred2: Vec<u16>,
+    mc_tmp: Vec<u16>,
+    mc_win: Vec<u16>,
+    /// First error met while decoding (e.g. a block referencing an unusable reference frame).
+    pub error: Option<crate::error::Error>,
+}
+
+impl<'a> TileDecoder<'a> {
+    pub fn new(s: &'a FrameShared<'a>, mi_col_start: usize, mi_col_end: usize) -> Self {
+        let h = s.h;
+        let (mi_cols, mi_rows) = (h.mi_cols as usize, h.mi_rows as usize);
+        let (ss_x, ss_y) = (h.color.subsampling_x as usize, h.color.subsampling_y as usize);
+        let sb_rows = h.sb64_rows as usize;
+        let sb_cols = h.sb64_cols as usize;
+        let strip_w = (mi_col_end - mi_col_start).div_ceil(8) * 64;
+        let strip_h = sb_rows * 64;
+        let x0 = mi_col_start * 8;
+        let uv_len = (strip_w >> ss_x) * (strip_h >> ss_y);
+        let planes = [s.pools.samples.take(strip_w * strip_h, 0), s.pools.samples.take(uv_len, 0), s.pools.samples.take(uv_len, 0)];
+        let mi_w = mi_col_end - mi_col_start;
+        let strip = Strip {
+            mi_col_start,
+            mi_col_end,
+            mi: s.pools.mi.take(mi_w * mi_rows, MiInfo::default()),
+            seg_ids: vec![0; mi_w * mi_rows],
+            planes,
+            strides: [strip_w, strip_w >> ss_x, strip_w >> ss_x],
+            x_off: [x0, x0 >> ss_x, x0 >> ss_x],
+            counts: Box::default(),
+            compound_blocks: 0,
+            scaled_blocks: 0,
+            intra_blocks: 0,
+            inter_blocks: 0,
+        };
+        let an = sb_cols * 16 + 16;
+        let ln = sb_rows * 16 + 16;
+        TileDecoder {
+            s,
+            h,
+            fc: s.fc,
+            strip,
+            mi_cols,
+            mi_rows,
+            ss_x,
+            ss_y,
+            bit_depth: h.color.bit_depth,
+            above_nonzero: [vec![0; an], vec![0; an], vec![0; an]],
+            left_nonzero: [vec![0; ln], vec![0; ln], vec![0; ln]],
+            above_partition: vec![0; sb_cols * 8 + 8],
+            left_partition: vec![0; sb_rows * 8 + 8],
+            above_seg_pred: vec![0; sb_cols * 8 + 8],
+            left_seg_pred: vec![0; sb_rows * 8 + 8],
+            ref_list_mv: [Mv::ZERO; 2],
+            ref_mv_count: 0,
+            mode_context: [0; 4],
+            nearest_mv: [Mv::ZERO; 2],
+            near_mv: [Mv::ZERO; 2],
+            best_mv: [Mv::ZERO; 2],
+            coefs: vec![0; 1024],
+            token_cache: vec![0; 1024],
+            pred: vec![0; 64 * 64],
+            pred2: vec![0; 64 * 64],
+            // Scaled prediction reads up to 5x the block height (8.5.2.3), unscaled h + 7 rows.
+            mc_tmp: vec![0; if s.refs.iter().flatten().any(|r| r.x_scale != 1 << 14 || r.y_scale != 1 << 14) { 64 * (64 * 5 + 16) } else { 64 * 71 }],
+            mc_win: vec![0; 71 * 71],
+            error: None,
+        }
+    }
+
+    #[inline]
+    fn mi_at(&self, r: usize, c: usize) -> &MiInfo {
+        &self.strip.mi[r * (self.strip.mi_col_end - self.strip.mi_col_start) + c - self.strip.mi_col_start]
+    }
+
+    /// decode_tile (6.4.2) for one tile of this column. Returns false if the data ran out badly.
+    pub fn decode_tile(&mut self, data: &[u8], mi_row_start: usize, mi_row_end: usize) -> bool {
+        let mut bd = BoolDecoder::new(data);
+        let (cs, ce) = (self.strip.mi_col_start, self.strip.mi_col_end);
+        for r in (mi_row_start..mi_row_end).step_by(8) {
+            // clear_left_context
+            for p in 0..3 {
+                let sy = if p > 0 { self.ss_y } else { 0 };
+                let s = (r * 2) >> sy;
+                let e = (s + (16 >> sy)).min(self.left_nonzero[p].len());
+                self.left_nonzero[p][s..e].fill(0);
+            }
+            self.left_partition[r..r + 8].fill(0);
+            self.left_seg_pred[r..r + 8].fill(0);
+            for c in (cs..ce).step_by(8) {
+                self.decode_partition(&mut bd, r, c, BLOCK_64X64);
+            }
+        }
+        true
+    }
+
+    fn decode_partition(&mut self, bd: &mut BoolDecoder, r: usize, c: usize, bsize: u8) {
+        if r >= self.mi_rows || c >= self.mi_cols {
+            return;
+        }
+        let num8x8 = NUM_8X8_WIDE[bsize as usize] as usize;
+        let half = num8x8 >> 1;
+        let has_rows = (r + half) < self.mi_rows;
+        let has_cols = (c + half) < self.mi_cols;
+        let bsl = MI_WIDTH_LOG2[bsize as usize] as usize;
+        let boffset = 3 - bsl;
+        let mut above = 0u8;
+        let mut left = 0u8;
+        for i in 0..num8x8 {
+            above |= self.above_partition[c + i];
+            left |= self.left_partition[r + i];
+        }
+        let above = (above >> boffset) & 1;
+        let left = (left >> boffset) & 1;
+        let ctx = bsl * 4 + left as usize * 2 + above as usize;
+        let probs: &[u8] = if self.h.frame_is_intra { &KF_PARTITION_PROBS[ctx * 3..ctx * 3 + 3] } else { &self.fc.partition[ctx] };
+        let partition = if has_rows && has_cols {
+            bd.read_tree(&PARTITION_TREE, probs)
+        } else if has_cols {
+            if bd.read_bool(probs[1]) { 3 } else { 1 }
+        } else if has_rows {
+            if bd.read_bool(probs[2]) { 3 } else { 2 }
+        } else {
+            3
+        };
+        if self.s.counting {
+            self.strip.counts.partition[ctx][partition as usize] += 1;
+        }
+        let subsize = SUBSIZE_LOOKUP[partition as usize][bsize as usize];
+        if subsize < BLOCK_8X8 || partition == 0 {
+            self.decode_block(bd, r, c, subsize);
+        } else if partition == 1 {
+            self.decode_block(bd, r, c, subsize);
+            if has_rows {
+                self.decode_block(bd, r + half, c, subsize);
+            }
+        } else if partition == 2 {
+            self.decode_block(bd, r, c, subsize);
+            if has_cols {
+                self.decode_block(bd, r, c + half, subsize);
+            }
+        } else {
+            self.decode_partition(bd, r, c, subsize);
+            self.decode_partition(bd, r, c + half, subsize);
+            self.decode_partition(bd, r + half, c, subsize);
+            self.decode_partition(bd, r + half, c + half, subsize);
+        }
+        if bsize == BLOCK_8X8 || partition != 3 {
+            let a = 15 >> B_WIDTH_LOG2[subsize as usize];
+            let l = 15 >> B_HEIGHT_LOG2[subsize as usize];
+            self.above_partition[c..c + num8x8].fill(a);
+            self.left_partition[r..r + num8x8].fill(l);
+        }
+    }
+
+    fn decode_block(&mut self, bd: &mut BoolDecoder, r: usize, c: usize, size: u8) {
+        let mut b = Blk { r, c, size, avail_u: r > 0, avail_l: c > self.strip.mi_col_start, ..Default::default() };
+        // Chroma block size must be valid (7.4.3); treat violations as a damaged stream.
+        if size >= BLOCK_8X8 && SS_SIZE_LOOKUP[size as usize][self.ss_x][self.ss_y] == BLOCK_INVALID {
+            b.size = BLOCK_8X8;
+        }
+        if self.h.frame_is_intra {
+            self.intra_frame_mode_info(bd, &mut b);
+        } else {
+            self.inter_frame_mode_info(bd, &mut b);
+        }
+        if b.is_inter {
+            self.strip.inter_blocks += 1;
+        } else {
+            self.strip.intra_blocks += 1;
+        }
+        self.residual(bd, &mut b);
+        if b.is_inter && b.size >= BLOCK_8X8 && b.eob_total == 0 {
+            b.skip = true;
+        }
+        let info = MiInfo {
+            sb_size: b.size,
+            skip: b.skip,
+            tx_size: b.tx_size,
+            y_mode: b.y_mode,
+            sub_modes: b.sub_modes,
+            seg_id: b.seg_id,
+            ref_frame: b.ref_frame,
+            interp_filter: b.interp_filter,
+            mv: b.block_mvs,
+        };
+        let bh = NUM_8X8_HIGH[b.size as usize] as usize;
+        let bw = NUM_8X8_WIDE[b.size as usize] as usize;
+        let mi_w = self.strip.mi_col_end - self.strip.mi_col_start;
+        let (y1, x1) = ((r + bh).min(self.mi_rows), (c + bw).min(self.strip.mi_col_end));
+        for y in r..y1 {
+            let row = y * mi_w;
+            for x in c..x1 {
+                self.strip.mi[row + x - self.strip.mi_col_start] = info;
+                self.strip.seg_ids[row + x - self.strip.mi_col_start] = b.seg_id;
+            }
+        }
+    }
+
+    // ---------------------------------------------------------------- mode info (6.4.5 - 6.4.20)
+
+    fn intra_frame_mode_info(&mut self, bd: &mut BoolDecoder, b: &mut Blk) {
+        // intra_segment_id
+        b.seg_id = if self.s.seg.enabled && self.s.seg.update_map { bd.read_tree(&SEGMENT_TREE, &self.s.seg.tree_probs) } else { 0 };
+        self.read_skip(bd, b);
+        self.read_tx_size(bd, b, true);
+        b.ref_frame = [INTRA_FRAME, NONE];
+        b.is_inter = false;
+        let above_mi = if b.avail_u { Some(*self.mi_at(b.r - 1, b.c)) } else { None };
+        let left_mi = if b.avail_l { Some(*self.mi_at(b.r, b.c - 1)) } else { None };
+        if b.size >= BLOCK_8X8 {
+            let above = above_mi.map_or(DC_PRED, |m| m.sub_modes[2]);
+            let left = left_mi.map_or(DC_PRED, |m| m.sub_modes[1]);
+            let o = (above as usize * 10 + left as usize) * 9;
+            let mode = bd.read_tree(&INTRA_MODE_TREE, &KF_Y_MODE_PROBS[o..o + 9]);
+            b.y_mode = mode;
+            b.sub_modes = [mode; 4];
+        } else {
+            let n4w = NUM_4X4_WIDE[b.size as usize] as usize;
+            let n4h = NUM_4X4_HIGH[b.size as usize] as usize;
+            let mut mode = 0;
+            let mut idy = 0;
+            while idy < 2 {
+                let mut idx = 0;
+                while idx < 2 {
+                    let above = if idy > 0 { b.sub_modes[idx] } else { above_mi.map_or(DC_PRED, |m| m.sub_modes[2 + idx]) };
+                    let left = if idx > 0 { b.sub_modes[idy * 2] } else { left_mi.map_or(DC_PRED, |m| m.sub_modes[1 + idy * 2]) };
+                    let o = (above as usize * 10 + left as usize) * 9;
+                    mode = bd.read_tree(&INTRA_MODE_TREE, &KF_Y_MODE_PROBS[o..o + 9]);
+                    for y2 in 0..n4h {
+                        for x2 in 0..n4w {
+                            b.sub_modes[(idy + y2) * 2 + idx + x2] = mode;
+                        }
+                    }
+                    idx += n4w;
+                }
+                idy += n4h;
+            }
+            b.y_mode = mode;
+        }
+        let o = b.y_mode as usize * 9;
+        b.uv_mode = bd.read_tree(&INTRA_MODE_TREE, &KF_UV_MODE_PROBS[o..o + 9]);
+    }
+
+    fn read_skip(&mut self, bd: &mut BoolDecoder, b: &mut Blk) {
+        if self.s.seg.feature_active(b.seg_id, SEG_LVL_SKIP) {
+            b.skip = true;
+        } else {
+            let mut ctx = 0;
+            if b.avail_u {
+                ctx += self.mi_at(b.r - 1, b.c).skip as usize;
+            }
+            if b.avail_l {
+                ctx += self.mi_at(b.r, b.c - 1).skip as usize;
+            }
+            b.skip = bd.read_bool(self.fc.skip[ctx]);
+            if self.s.counting {
+                self.strip.counts.skip[ctx][b.skip as usize] += 1;
+            }
+        }
+    }
+
+    fn read_tx_size(&mut self, bd: &mut BoolDecoder, b: &mut Blk, allow_select: bool) {
+        let max_tx = MAX_TXSIZE[b.size as usize];
+        if allow_select && self.h.tx_mode == TX_MODE_SELECT && b.size >= BLOCK_8X8 {
+            let mut above = max_tx;
+            let mut left = max_tx;
+            if b.avail_u {
+                let m = self.mi_at(b.r - 1, b.c);
+                if !m.skip {
+                    above = m.tx_size;
+                }
+            }
+            if b.avail_l {
+                let m = self.mi_at(b.r, b.c - 1);
+                if !m.skip {
+                    left = m.tx_size;
+                }
+            }
+            if !b.avail_l {
+                left = above;
+            }
+            if !b.avail_u {
+                above = left;
+            }
+            let ctx = ((above + left) > max_tx) as usize;
+            let tree: &[i8] = match max_tx {
+                3 => &TX_SIZE_32_TREE,
+                2 => &TX_SIZE_16_TREE,
+                _ => &TX_SIZE_8_TREE,
+            };
+            b.tx_size = bd.read_tree(tree, &self.fc.tx[max_tx as usize][ctx]);
+            if self.s.counting {
+                self.strip.counts.tx[max_tx as usize][ctx][b.tx_size as usize] += 1;
+            }
+        } else {
+            b.tx_size = max_tx.min(TX_MODE_TO_BIGGEST_TX_SIZE[self.h.tx_mode as usize]);
+        }
+    }
+
+    fn inter_frame_mode_info(&mut self, bd: &mut BoolDecoder, b: &mut Blk) {
+        b.left_ref = if b.avail_l { self.mi_at(b.r, b.c - 1).ref_frame } else { [INTRA_FRAME, NONE] };
+        b.above_ref = if b.avail_u { self.mi_at(b.r - 1, b.c).ref_frame } else { [INTRA_FRAME, NONE] };
+        b.left_intra = b.left_ref[0] <= INTRA_FRAME;
+        b.above_intra = b.above_ref[0] <= INTRA_FRAME;
+        b.left_single = b.left_ref[1] <= NONE;
+        b.above_single = b.above_ref[1] <= NONE;
+        self.inter_segment_id(bd, b);
+        self.read_skip(bd, b);
+        self.read_is_inter(bd, b);
+        let allow = !b.skip || !b.is_inter;
+        self.read_tx_size(bd, b, allow);
+        if b.is_inter {
+            self.inter_block_mode_info(bd, b);
+        } else {
+            self.intra_block_mode_info(bd, b);
+        }
+    }
+
+    fn get_segment_id(&self, b: &Blk) -> u8 {
+        let bw = NUM_8X8_WIDE[b.size as usize] as usize;
+        let bh = NUM_8X8_HIGH[b.size as usize] as usize;
+        let xmis = (self.mi_cols - b.c).min(bw);
+        let ymis = (self.mi_rows - b.r).min(bh);
+        let mut seg = 7;
+        let prev = self.s.prev_seg_ids;
+        if prev.is_empty() {
+            return 0;
+        }
+        for y in 0..ymis {
+            for x in 0..xmis {
+                seg = seg.min(prev[(b.r + y) * self.mi_cols + b.c + x]);
+            }
+        }
+        seg
+    }
+
+    fn inter_segment_id(&mut self, bd: &mut BoolDecoder, b: &mut Blk) {
+        let seg = self.s.seg;
+        if !seg.enabled {
+            b.seg_id = 0;
+            return;
+        }
+        let predicted = self.get_segment_id(b);
+        if !seg.update_map {
+            b.seg_id = predicted;
+            return;
+        }
+        if seg.temporal_update {
+            let ctx = (self.left_seg_pred[b.r] + self.above_seg_pred[b.c]) as usize;
+            let pred_flag = bd.read_bool(seg.pred_probs[ctx]);
+            b.seg_id = if pred_flag { predicted } else { bd.read_tree(&SEGMENT_TREE, &seg.tree_probs) };
+            let bw = NUM_8X8_WIDE[b.size as usize] as usize;
+            let bh = NUM_8X8_HIGH[b.size as usize] as usize;
+            self.above_seg_pred[b.c..b.c + bw].fill(pred_flag as u8);
+            self.left_seg_pred[b.r..b.r + bh].fill(pred_flag as u8);
+        } else {
+            b.seg_id = bd.read_tree(&SEGMENT_TREE, &seg.tree_probs);
+        }
+    }
+
+    fn read_is_inter(&mut self, bd: &mut BoolDecoder, b: &mut Blk) {
+        if self.s.seg.feature_active(b.seg_id, SEG_LVL_REF_FRAME) {
+            b.is_inter = self.s.seg.feature_data[b.seg_id as usize][SEG_LVL_REF_FRAME] != INTRA_FRAME as i16;
+        } else {
+            let ctx = if b.avail_u && b.avail_l {
+                if b.left_intra && b.above_intra { 3 } else { (b.left_intra || b.above_intra) as usize }
+            } else if b.avail_u || b.avail_l {
+                2 * (if b.avail_u { b.above_intra } else { b.left_intra }) as usize
+            } else {
+                0
+            };
+            b.is_inter = bd.read_bool(self.fc.is_inter[ctx]);
+            if self.s.counting {
+                self.strip.counts.is_inter[ctx][b.is_inter as usize] += 1;
+            }
+        }
+    }
+
+    fn intra_block_mode_info(&mut self, bd: &mut BoolDecoder, b: &mut Blk) {
+        b.ref_frame = [INTRA_FRAME, NONE];
+        if b.size >= BLOCK_8X8 {
+            let ctx = SIZE_GROUP[b.size as usize] as usize;
+            let mode = bd.read_tree(&INTRA_MODE_TREE, &self.fc.y_mode[ctx]);
+            if self.s.counting {
+                self.strip.counts.intra_mode[ctx][mode as usize] += 1;
+            }
+            b.y_mode = mode;
+            b.sub_modes = [mode; 4];
+        } else {
+            let n4w = NUM_4X4_WIDE[b.size as usize] as usize;
+            let n4h = NUM_4X4_HIGH[b.size as usize] as usize;
+            let mut mode = 0;
+            let mut idy = 0;
+            while idy < 2 {
+                let mut idx = 0;
+                while idx < 2 {
+                    mode = bd.read_tree(&INTRA_MODE_TREE, &self.fc.y_mode[0]);
+                    if self.s.counting {
+                        self.strip.counts.intra_mode[0][mode as usize] += 1;
+                    }
+                    for y2 in 0..n4h {
+                        for x2 in 0..n4w {
+                            b.sub_modes[(idy + y2) * 2 + idx + x2] = mode;
+                        }
+                    }
+                    idx += n4w;
+                }
+                idy += n4h;
+            }
+            b.y_mode = mode;
+        }
+        b.uv_mode = bd.read_tree(&INTRA_MODE_TREE, &self.fc.uv_mode[b.y_mode as usize]);
+        if self.s.counting {
+            self.strip.counts.uv_mode[b.y_mode as usize][b.uv_mode as usize] += 1;
+        }
+    }
+
+    fn inter_block_mode_info(&mut self, bd: &mut BoolDecoder, b: &mut Blk) {
+        self.read_ref_frames(bd, b);
+        let is_compound = b.ref_frame[1] > INTRA_FRAME;
+        if is_compound {
+            self.strip.compound_blocks += 1;
+        }
+        for j in 0..1 + is_compound as usize {
+            let rf = b.ref_frame[j];
+            self.find_mv_refs(b, rf, -1);
+            self.find_best_ref_mvs(b, j);
+        }
+        b.sub_modes = [DC_PRED; 4];
+        if self.s.seg.feature_active(b.seg_id, SEG_LVL_SKIP) {
+            b.y_mode = ZEROMV;
+        } else if b.size >= BLOCK_8X8 {
+            let ctx = self.mode_context[b.ref_frame[0] as usize] as usize;
+            let inter_mode = bd.read_tree(&INTER_MODE_TREE, &self.fc.inter_mode[ctx.min(6)]);
+            if self.s.counting {
+                self.strip.counts.inter_mode[ctx.min(6)][inter_mode as usize] += 1;
+            }
+            b.y_mode = NEARESTMV + inter_mode;
+        }
+        b.interp_filter = if self.h.interp_filter == SWITCHABLE {
+            let left = if b.avail_l && b.left_ref[0] > INTRA_FRAME { self.mi_at(b.r, b.c - 1).interp_filter } else { 3 };
+            let above = if b.avail_u && b.above_ref[0] > INTRA_FRAME { self.mi_at(b.r - 1, b.c).interp_filter } else { 3 };
+            let ctx = if left == above {
+                left
+            } else if left == 3 && above != 3 {
+                above
+            } else if left != 3 && above == 3 {
+                left
+            } else {
+                3
+            } as usize;
+            let f = bd.read_tree(&INTERP_FILTER_TREE, &self.fc.interp_filter[ctx]);
+            if self.s.counting {
+                self.strip.counts.interp_filter[ctx][f as usize] += 1;
+            }
+            f
+        } else {
+            self.h.interp_filter
+        };
+        b.block_mvs = [[Mv::ZERO; 4]; 2];
+        if b.size < BLOCK_8X8 {
+            let n4w = NUM_4X4_WIDE[b.size as usize] as usize;
+            let n4h = NUM_4X4_HIGH[b.size as usize] as usize;
+            let mut idy = 0;
+            while idy < 2 {
+                let mut idx = 0;
+                while idx < 2 {
+                    let ctx = self.mode_context[b.ref_frame[0] as usize] as usize;
+                    let inter_mode = bd.read_tree(&INTER_MODE_TREE, &self.fc.inter_mode[ctx.min(6)]);
+                    if self.s.counting {
+                        self.strip.counts.inter_mode[ctx.min(6)][inter_mode as usize] += 1;
+                    }
+                    b.y_mode = NEARESTMV + inter_mode;
+                    if b.y_mode == NEARESTMV || b.y_mode == NEARMV {
+                        for j in 0..1 + is_compound as usize {
+                            self.append_sub8x8_mvs(b, (idy * 2 + idx) as i32, j);
+                        }
+                    }
+                    let mv = self.assign_mv(bd, b, is_compound);
+                    for y2 in 0..n4h {
+                        for x2 in 0..n4w {
+                            let blk = (idy + y2) * 2 + idx + x2;
+                            for l in 0..1 + is_compound as usize {
+                                b.block_mvs[l][blk] = mv[l];
+                            }
+                        }
+                    }
+                    idx += n4w;
+                }
+                idy += n4h;
+            }
+        } else {
+            let mv = self.assign_mv(bd, b, is_compound);
+            for l in 0..1 + is_compound as usize {
+                b.block_mvs[l] = [mv[l]; 4];
+            }
+        }
+    }
+
+    fn read_ref_frames(&mut self, bd: &mut BoolDecoder, b: &mut Blk) {
+        let seg = self.s.seg;
+        if seg.feature_active(b.seg_id, SEG_LVL_REF_FRAME) {
+            b.ref_frame = [(seg.feature_data[b.seg_id as usize][SEG_LVL_REF_FRAME] as i8).clamp(LAST_FRAME, ALTREF_FRAME), NONE];
+            return;
+        }
+        let h = self.h;
+        let comp_mode = if h.reference_mode == 2 {
+            let ctx = self.comp_mode_ctx(b);
+            let v = bd.read_bool(self.fc.comp_mode[ctx]);
+            if self.s.counting {
+                self.strip.counts.comp_mode[ctx][v as usize] += 1;
+            }
+            v as u8
+        } else {
+            h.reference_mode
+        };
+        if comp_mode == 1 {
+            let idx = h.ref_frame_sign_bias[h.comp_fixed_ref as usize] as usize;
+            let ctx = self.comp_ref_ctx(b);
+            let comp_ref = bd.read_bool(self.fc.comp_ref[ctx]);
+            if self.s.counting {
+                self.strip.counts.comp_ref[ctx][comp_ref as usize] += 1;
+            }
+            b.ref_frame[idx] = h.comp_fixed_ref;
+            b.ref_frame[1 - idx] = h.comp_var_ref[comp_ref as usize];
+        } else {
+            let ctx = self.single_ref_p1_ctx(b);
+            let p1 = bd.read_bool(self.fc.single_ref[ctx][0]);
+            if self.s.counting {
+                self.strip.counts.single_ref[ctx][0][p1 as usize] += 1;
+            }
+            b.ref_frame[0] = if p1 {
+                let ctx2 = self.single_ref_p2_ctx(b);
+                let p2 = bd.read_bool(self.fc.single_ref[ctx2][1]);
+                if self.s.counting {
+                    self.strip.counts.single_ref[ctx2][1][p2 as usize] += 1;
+                }
+                if p2 { ALTREF_FRAME } else { GOLDEN_FRAME }
+            } else {
+                LAST_FRAME
+            };
+            b.ref_frame[1] = NONE;
+        }
+    }
+
+    fn comp_mode_ctx(&self, b: &Blk) -> usize {
+        let fixed = self.h.comp_fixed_ref;
+        (if b.avail_u && b.avail_l {
+            if b.above_single && b.left_single {
+                ((b.above_ref[0] == fixed) ^ (b.left_ref[0] == fixed)) as u8
+            } else if b.above_single {
+                2 + (b.above_ref[0] == fixed || b.above_intra) as u8
+            } else if b.left_single {
+                2 + (b.left_ref[0] == fixed || b.left_intra) as u8
+            } else {
+                4
+            }
+        } else if b.avail_u {
+            if b.above_single { (b.above_ref[0] == fixed) as u8 } else { 3 }
+        } else if b.avail_l {
+            if b.left_single { (b.left_ref[0] == fixed) as u8 } else { 3 }
+        } else {
+            1
+        }) as usize
+    }
+
+    fn comp_ref_ctx(&self, b: &Blk) -> usize {
+        let h = self.h;
+        let fix_ref_idx = h.ref_frame_sign_bias[h.comp_fixed_ref as usize] as usize;
+        let var_ref_idx = 1 - fix_ref_idx;
+        let var0 = h.comp_var_ref[0];
+        let var1 = h.comp_var_ref[1];
+        let fixed = h.comp_fixed_ref;
+        (if b.avail_u && b.avail_l {
+            if b.above_intra && b.left_intra {
+                2
+            } else if b.left_intra {
+                if b.above_single { 1 + 2 * (b.above_ref[0] != var1) as u8 } else { 1 + 2 * (b.above_ref[var_ref_idx] != var1) as u8 }
+            } else if b.above_intra {
+                if b.left_single { 1 + 2 * (b.left_ref[0] != var1) as u8 } else { 1 + 2 * (b.left_ref[var_ref_idx] != var1) as u8 }
+            } else {
+                let vrfa = if b.above_single { b.above_ref[0] } else { b.above_ref[var_ref_idx] };
+                let vrfl = if b.left_single { b.left_ref[0] } else { b.left_ref[var_ref_idx] };
+                if vrfa == vrfl && var1 == vrfa {
+                    0
+                } else if b.left_single && b.above_single {
+                    if (vrfa == fixed && vrfl == var0) || (vrfl == fixed && vrfa == var0) {
+                        4
+                    } else if vrfa == vrfl {
+                        3
+                    } else {
+                        1
+                    }
+                } else if b.left_single || b.above_single {
+                    let vrfc = if b.left_single { vrfa } else { vrfl };
+                    let rfs = if b.above_single { vrfa } else { vrfl };
+                    if vrfc == var1 && rfs != var1 {
+                        1
+                    } else if rfs == var1 && vrfc != var1 {
+                        2
+                    } else {
+                        4
+                    }
+                } else if vrfa == vrfl {
+                    4
+                } else {
+                    2
+                }
+            }
+        } else if b.avail_u {
+            if b.above_intra {
+                2
+            } else if b.above_single {
+                3 * (b.above_ref[0] != var1) as u8
+            } else {
+                4 * (b.above_ref[var_ref_idx] != var1) as u8
+            }
+        } else if b.avail_l {
+            if b.left_intra {
+                2
+            } else if b.left_single {
+                3 * (b.left_ref[0] != var1) as u8
+            } else {
+                4 * (b.left_ref[var_ref_idx] != var1) as u8
+            }
+        } else {
+            2
+        }) as usize
+    }
+
+    fn single_ref_p1_ctx(&self, b: &Blk) -> usize {
+        let (a, l) = (b.above_ref, b.left_ref);
+        (if b.avail_u && b.avail_l {
+            if b.above_intra && b.left_intra {
+                2
+            } else if b.left_intra {
+                if b.above_single { 4 * (a[0] == LAST_FRAME) as u8 } else { 1 + (a[0] == LAST_FRAME || a[1] == LAST_FRAME) as u8 }
+            } else if b.above_intra {
+                if b.left_single { 4 * (l[0] == LAST_FRAME) as u8 } else { 1 + (l[0] == LAST_FRAME || l[1] == LAST_FRAME) as u8 }
+            } else if b.above_single && b.left_single {
+                2 * (a[0] == LAST_FRAME) as u8 + 2 * (l[0] == LAST_FRAME) as u8
+            } else if !b.above_single && !b.left_single {
+                1 + (a[0] == LAST_FRAME || a[1] == LAST_FRAME || l[0] == LAST_FRAME || l[1] == LAST_FRAME) as u8
+            } else {
+                let rfs = if b.above_single { a[0] } else { l[0] };
+                let crf1 = if b.above_single { l[0] } else { a[0] };
+                let crf2 = if b.above_single { l[1] } else { a[1] };
+                if rfs == LAST_FRAME { 3 + (crf1 == LAST_FRAME || crf2 == LAST_FRAME) as u8 } else { (crf1 == LAST_FRAME || crf2 == LAST_FRAME) as u8 }
+            }
+        } else if b.avail_u {
+            if b.above_intra {
+                2
+            } else if b.above_single {
+                4 * (a[0] == LAST_FRAME) as u8
+            } else {
+                1 + (a[0] == LAST_FRAME || a[1] == LAST_FRAME) as u8
+            }
+        } else if b.avail_l {
+            if b.left_intra {
+                2
+            } else if b.left_single {
+                4 * (l[0] == LAST_FRAME) as u8
+            } else {
+                1 + (l[0] == LAST_FRAME || l[1] == LAST_FRAME) as u8
+            }
+        } else {
+            2
+        }) as usize
+    }
+
+    fn single_ref_p2_ctx(&self, b: &Blk) -> usize {
+        let (a, l) = (b.above_ref, b.left_ref);
+        const G: i8 = GOLDEN_FRAME;
+        const L: i8 = LAST_FRAME;
+        (if b.avail_u && b.avail_l {
+            if b.above_intra && b.left_intra {
+                2
+            } else if b.left_intra {
+                if b.above_single { if a[0] == L { 3 } else { 4 * (a[0] == G) as u8 } } else { 1 + 2 * (a[0] == G || a[1] == G) as u8 }
+            } else if b.above_intra {
+                if b.left_single { if l[0] == L { 3 } else { 4 * (l[0] == G) as u8 } } else { 1 + 2 * (l[0] == G || l[1] == G) as u8 }
+            } else if b.above_single && b.left_single {
+                if a[0] == L && l[0] == L {
+                    3
+                } else if a[0] == L {
+                    4 * (l[0] == G) as u8
+                } else if l[0] == L {
+                    4 * (a[0] == G) as u8
+                } else {
+                    2 * (a[0] == G) as u8 + 2 * (l[0] == G) as u8
+                }
+            } else if !b.above_single && !b.left_single {
+                if a[0] == l[0] && a[1] == l[1] { 3 * (a[0] == G || a[1] == G) as u8 } else { 2 }
+            } else {
+                let rfs = if b.above_single { a[0] } else { l[0] };
+                let crf1 = if b.above_single { l[0] } else { a[0] };
+                let crf2 = if b.above_single { l[1] } else { a[1] };
+                if rfs == G {
+                    3 + (crf1 == G || crf2 == G) as u8
+                } else if rfs == ALTREF_FRAME {
+                    (crf1 == G || crf2 == G) as u8
+                } else {
+                    1 + 2 * (crf1 == G || crf2 == G) as u8
+                }
+            }
+        } else if b.avail_u {
+            if b.above_intra || (a[0] == L && b.above_single) {
+                2
+            } else if b.above_single {
+                4 * (a[0] == G) as u8
+            } else {
+                3 * (a[0] == G || a[1] == G) as u8
+            }
+        } else if b.avail_l {
+            if b.left_intra || (l[0] == L && b.left_single) {
+                2
+            } else if b.left_single {
+                4 * (l[0] == G) as u8
+            } else {
+                3 * (l[0] == G || l[1] == G) as u8
+            }
+        } else {
+            2
+        }) as usize
+    }
+
+    /// assign_mv (6.4.18): returns Mv[0..2].
+    fn assign_mv(&mut self, bd: &mut BoolDecoder, b: &Blk, is_compound: bool) -> [Mv; 2] {
+        let mut mv = [Mv::ZERO; 2];
+        for i in 0..1 + is_compound as usize {
+            mv[i] = match b.y_mode {
+                NEWMV => self.read_mv(bd, i),
+                NEARESTMV => self.nearest_mv[i],
+                NEARMV => self.near_mv[i],
+                _ => Mv::ZERO,
+            };
+        }
+        mv
+    }
+
+    fn read_mv(&mut self, bd: &mut BoolDecoder, r: usize) -> Mv {
+        let use_hp = self.h.allow_high_precision_mv && use_mv_hp(self.best_mv[r]);
+        let joint = bd.read_tree(&MV_JOINT_TREE, &self.fc.mv_joint);
+        if self.s.counting {
+            self.strip.counts.mv_joint[joint as usize] += 1;
+        }
+        let mut diff = [0i32; 2];
+        if joint == 2 || joint == 3 {
+            diff[0] = self.read_mv_component(bd, 0, use_hp);
+        }
+        if joint == 1 || joint == 3 {
+            diff[1] = self.read_mv_component(bd, 1, use_hp);
+        }
+        Mv::new(self.best_mv[r].row as i32 + diff[0], self.best_mv[r].col as i32 + diff[1])
+    }
+
+    fn read_mv_component(&mut self, bd: &mut BoolDecoder, comp: usize, use_hp: bool) -> i32 {
+        let fc = self.fc;
+        let counting = self.s.counting;
+        let counts = &mut self.strip.counts;
+        let sign = bd.read_bool(fc.mv_sign[comp]);
+        let class = bd.read_tree(&MV_CLASS_TREE, &fc.mv_class[comp]) as usize;
+        let mag = if class == 0 {
+            let c0 = bd.read_bool(fc.mv_class0_bit[comp]) as usize;
+            let fr = bd.read_tree(&MV_FR_TREE, &fc.mv_class0_fr[comp][c0]) as usize;
+            let hp = if use_hp { bd.read_bool(fc.mv_class0_hp[comp]) as usize } else { 1 };
+            if counting {
+                counts.mv_class0_bit[comp][c0] += 1;
+                counts.mv_class0_fr[comp][c0][fr] += 1;
+                counts.mv_class0_hp[comp][hp] += 1;
+            }
+            ((c0 << 3) | (fr << 1) | hp) + 1
+        } else {
+            let mut d = 0usize;
+            for i in 0..class {
+                let bit = bd.read_bool(fc.mv_bits[comp][i]) as usize;
+                if counting {
+                    counts.mv_bits[comp][i][bit] += 1;
+                }
+                d |= bit << i;
+            }
+            let base = 2usize << (class + 2);
+            let fr = bd.read_tree(&MV_FR_TREE, &fc.mv_fr[comp]) as usize;
+            let hp = if use_hp { bd.read_bool(fc.mv_hp[comp]) as usize } else { 1 };
+            if counting {
+                counts.mv_fr[comp][fr] += 1;
+                counts.mv_hp[comp][hp] += 1;
+            }
+            base + ((d << 3) | (fr << 1) | hp) + 1
+        };
+        if counting {
+            counts.mv_sign[comp][sign as usize] += 1;
+            counts.mv_class[comp][class] += 1;
+        }
+        if sign { -(mag as i32) } else { mag as i32 }
+    }
+
+    // ------------------------------------------------------------ motion vector prediction (6.5)
+
+    #[inline]
+    fn is_inside(&self, r: isize, c: isize) -> bool {
+        r >= 0 && (r as usize) < self.mi_rows && c >= self.strip.mi_col_start as isize && (c as usize) < self.strip.mi_col_end
+    }
+
+    #[inline]
+    fn add_mv_ref_list(&mut self, mv: Mv) {
+        if self.ref_mv_count >= 2 {
+            return;
+        }
+        if self.ref_mv_count > 0 && mv == self.ref_list_mv[0] {
+            return;
+        }
+        self.ref_list_mv[self.ref_mv_count] = mv;
+        self.ref_mv_count += 1;
+    }
+
+    fn if_same_ref_frame_add(&mut self, m: &MiInfo, ref_frame: i8) {
+        for j in 0..2 {
+            if m.ref_frame[j] == ref_frame {
+                self.add_mv_ref_list(m.mv[j][3]);
+                return;
+            }
+        }
+    }
+
+    fn if_diff_ref_frame_add(&mut self, m: &MiInfo, ref_frame: i8) {
+        let bias = &self.h.ref_frame_sign_bias;
+        let mvs = [m.mv[0][3], m.mv[1][3]];
+        let same = mvs[0] == mvs[1];
+        let scale = |f: i8, mv: Mv| -> Mv { if bias[f as usize] != bias[ref_frame as usize] { Mv::new(-(mv.row as i32), -(mv.col as i32)) } else { mv } };
+        if m.ref_frame[0] > INTRA_FRAME && m.ref_frame[0] != ref_frame {
+            let mv = scale(m.ref_frame[0], mvs[0]);
+            self.add_mv_ref_list(mv);
+        }
+        if m.ref_frame[1] > INTRA_FRAME && m.ref_frame[1] != ref_frame && !same {
+            let mv = scale(m.ref_frame[1], mvs[1]);
+            self.add_mv_ref_list(mv);
+        }
+    }
+
+    fn clamp_mv_row(&self, b: &Blk, v: i32, border: i32) -> i32 {
+        let bh = NUM_8X8_HIGH[b.size as usize] as i32;
+        let to_top = -((b.r as i32 * 8) * 8);
+        let to_bottom = ((self.mi_rows as i32 - bh - b.r as i32) * 8) * 8;
+        v.clamp(to_top - border, (to_bottom + border).max(to_top - border))
+    }
+
+    fn clamp_mv_col(&self, b: &Blk, v: i32, border: i32) -> i32 {
+        let bw = NUM_8X8_WIDE[b.size as usize] as i32;
+        let to_left = -((b.c as i32 * 8) * 8);
+        let to_right = ((self.mi_cols as i32 - bw - b.c as i32) * 8) * 8;
+        v.clamp(to_left - border, (to_right + border).max(to_left - border))
+    }
+
+    /// find_mv_refs (6.5.1) for `ref_frame`; `block` is -1 or the sub-8x8 block index.
+    fn find_mv_refs(&mut self, b: &Blk, ref_frame: i8, block: i32) {
+        self.ref_mv_count = 0;
+        self.ref_list_mv = [Mv::ZERO; 2];
+        let mut different_ref_found = false;
+        let mut context_counter = 0usize;
+        let search = &MV_REF_BLOCKS[b.size as usize * 16..b.size as usize * 16 + 16];
+        let (r, c) = (b.r as isize, b.c as isize);
+        for i in 0..2 {
+            let (cr, cc) = (r + search[i * 2] as isize, c + search[i * 2 + 1] as isize);
+            if self.is_inside(cr, cc) {
+                let m = *self.mi_at(cr as usize, cc as usize);
+                different_ref_found = true;
+                context_counter += MODE_2_COUNTER[m.y_mode as usize] as usize;
+                for j in 0..2 {
+                    if m.ref_frame[j] == ref_frame {
+                        let idx = if block >= 0 { IDX_N_COLUMN_TO_SUBBLOCK[block as usize][(search[i * 2 + 1] == 0) as usize] as usize } else { 3 };
+                        self.add_mv_ref_list(m.mv[j][idx]);
+                        break;
+                    }
+                }
+            }
+        }
+        for i in 2..8 {
+            let (cr, cc) = (r + search[i * 2] as isize, c + search[i * 2 + 1] as isize);
+            if self.is_inside(cr, cc) {
+                different_ref_found = true;
+                let m = *self.mi_at(cr as usize, cc as usize);
+                self.if_same_ref_frame_add(&m, ref_frame);
+            }
+        }
+        let prev = self.s.prev_mi.map(|g| *g.at(b.r, b.c));
+        if let Some(p) = &prev {
+            self.if_same_ref_frame_add(p, ref_frame);
+        }
+        if different_ref_found {
+            for i in 0..8 {
+                let (cr, cc) = (r + search[i * 2] as isize, c + search[i * 2 + 1] as isize);
+                if self.is_inside(cr, cc) {
+                    let m = *self.mi_at(cr as usize, cc as usize);
+                    self.if_diff_ref_frame_add(&m, ref_frame);
+                }
+            }
+        }
+        if let Some(p) = &prev {
+            self.if_diff_ref_frame_add(p, ref_frame);
+        }
+        self.mode_context[ref_frame as usize] = COUNTER_TO_CONTEXT[context_counter.min(18)];
+        for i in 0..2 {
+            let mv = self.ref_list_mv[i];
+            self.ref_list_mv[i] = Mv::new(self.clamp_mv_row(b, mv.row as i32, MV_BORDER), self.clamp_mv_col(b, mv.col as i32, MV_BORDER));
+        }
+    }
+
+    /// find_best_ref_mvs (6.5.12).
+    fn find_best_ref_mvs(&mut self, b: &Blk, ref_list: usize) {
+        for i in 0..2 {
+            let mv = self.ref_list_mv[i];
+            let (mut dr, mut dc) = (mv.row as i32, mv.col as i32);
+            if !self.h.allow_high_precision_mv || !use_mv_hp(mv) {
+                if dr & 1 != 0 {
+                    dr += if dr > 0 { -1 } else { 1 };
+                }
+                if dc & 1 != 0 {
+                    dc += if dc > 0 { -1 } else { 1 };
+                }
+            }
+            let border = (BORDERINPIXELS - INTERP_EXTEND) << 3;
+            self.ref_list_mv[i] = Mv::new(self.clamp_mv_row(b, dr, border), self.clamp_mv_col(b, dc, border));
+        }
+        self.nearest_mv[ref_list] = self.ref_list_mv[0];
+        self.near_mv[ref_list] = self.ref_list_mv[1];
+        self.best_mv[ref_list] = self.ref_list_mv[0];
+    }
+
+    /// append_sub8x8_mvs (6.5.14).
+    fn append_sub8x8_mvs(&mut self, b: &Blk, block: i32, ref_list: usize) {
+        self.find_mv_refs(b, b.ref_frame[ref_list], block);
+        let mut sub = [Mv::ZERO; 2];
+        let mut dst;
+        let bm = &b.block_mvs[ref_list];
+        if block == 0 {
+            sub = self.ref_list_mv;
+            dst = 2;
+        } else if block <= 2 {
+            sub[0] = bm[0];
+            dst = 1;
+        } else {
+            sub[0] = bm[2];
+            dst = 1;
+            for idx in [1usize, 0] {
+                if dst < 2 && bm[idx] != sub[0] {
+                    sub[dst] = bm[idx];
+                    dst += 1;
+                }
+            }
+        }
+        for n in 0..2 {
+            if dst < 2 && self.ref_list_mv[n] != sub[0] {
+                sub[dst] = self.ref_list_mv[n];
+                dst += 1;
+            }
+        }
+        if dst < 2 {
+            sub[dst] = Mv::ZERO;
+        }
+        self.nearest_mv[ref_list] = sub[0];
+        self.near_mv[ref_list] = sub[1];
+    }
+}
+
+#[inline]
+pub fn use_mv_hp(mv: Mv) -> bool {
+    ((mv.row as i32).abs() >> 3) < COMPANDED_MVREF_THRESH && ((mv.col as i32).abs() >> 3) < COMPANDED_MVREF_THRESH
+}
diff --git a/crates/vp9/src/tile/recon.rs b/crates/vp9/src/tile/recon.rs
new file mode 100644
index 000000000..4ab72118b
--- /dev/null
+++ b/crates/vp9/src/tile/recon.rs
@@ -0,0 +1,336 @@
+//! Residual syntax (6.4.21 - 6.4.26) with the prediction and reconstruction processes it
+//! triggers (8.5, 8.6).
+
+use super::{Blk, TileDecoder};
+use crate::boolcoder::BoolDecoder;
+use crate::error::Error;
+use crate::frame::Mv;
+use crate::inter::{self, RefPlane};
+use crate::intra::{self, IntraEdge};
+use crate::tables::*;
+use crate::transform;
+
+/// round_mv_comp_q2 / q4 (8.5.2.1).
+fn round_q2(v: i32) -> i32 {
+    (if v < 0 { v - 1 } else { v + 1 }) / 2
+}
+fn round_q4(v: i32) -> i32 {
+    (if v < 0 { v - 2 } else { v + 2 }) / 4
+}
+
+impl<'a> TileDecoder<'a> {
+    pub(super) fn residual(&mut self, bd: &mut BoolDecoder, b: &mut Blk) {
+        let bsize = b.size.max(BLOCK_8X8) as usize;
+        let (ssx, ssy) = (self.ss_x, self.ss_y);
+        let uv_tx = if b.size < BLOCK_8X8 { 0 } else { b.tx_size.min(MAX_TXSIZE[SS_SIZE_LOOKUP[b.size as usize][ssx][ssy] as usize]) };
+        for plane in 0..3 {
+            let tx_sz = if plane > 0 { uv_tx } else { b.tx_size };
+            let step = 1usize << tx_sz;
+            let (sx, sy) = if plane > 0 { (ssx, ssy) } else { (0, 0) };
+            let plane_sz = if plane > 0 { SS_SIZE_LOOKUP[bsize][ssx][ssy] as usize } else { bsize };
+            let n4w = NUM_4X4_WIDE[plane_sz] as usize;
+            let n4h = NUM_4X4_HIGH[plane_sz] as usize;
+            let base_x = (b.c * 8) >> sx;
+            let base_y = (b.r * 8) >> sy;
+            if b.is_inter {
+                if b.size < BLOCK_8X8 {
+                    for y in 0..n4h {
+                        for x in 0..n4w {
+                            self.predict_inter(b, plane, base_x + 4 * x, base_y + 4 * y, 4, 4, y * n4w + x);
+                        }
+                    }
+                } else {
+                    self.predict_inter(b, plane, base_x, base_y, n4w * 4, n4h * 4, 0);
+                }
+            }
+            let max_x = (self.mi_cols * 8) >> sx;
+            let max_y = (self.mi_rows * 8) >> sy;
+            let mut block_idx = 0;
+            for y in (0..n4h).step_by(step) {
+                for x in (0..n4w).step_by(step) {
+                    let start_x = base_x + 4 * x;
+                    let start_y = base_y + 4 * y;
+                    let mut nonzero = false;
+                    if start_x < max_x && start_y < max_y {
+                        let tx_type = self.tx_type(b, plane, tx_sz, block_idx);
+                        if !b.is_inter {
+                            let mode = if plane > 0 {
+                                b.uv_mode
+                            } else if b.size >= BLOCK_8X8 {
+                                b.y_mode
+                            } else {
+                                b.sub_modes[block_idx]
+                            };
+                            let edge = IntraEdge {
+                                have_left: b.avail_l || x > 0,
+                                have_above: b.avail_u || y > 0,
+                                not_on_right: x + step < n4w,
+                                tx_size: tx_sz,
+                                max_x: max_x - 1,
+                                max_y: max_y - 1,
+                                bit_depth: self.bit_depth,
+                            };
+                            let (stride, x_off) = (self.strip.strides[plane], self.strip.x_off[plane]);
+                            intra::predict(&mut self.strip.planes[plane], stride, x_off, start_x, start_y, mode, &edge);
+                        }
+                        if !b.skip {
+                            let (eob, rows) = self.tokens(bd, b, plane, start_x, start_y, tx_sz, tx_type);
+                            nonzero = eob > 0;
+                            b.eob_total += nonzero as u32;
+                            if eob > 0 {
+                                let (stride, x_off) = (self.strip.strides[plane], self.strip.x_off[plane]);
+                                let o = start_y * stride + start_x - x_off;
+                                transform::inverse_transform_add(
+                                    &self.coefs,
+                                    tx_sz,
+                                    tx_type,
+                                    self.h.lossless,
+                                    eob,
+                                    rows,
+                                    self.bit_depth,
+                                    &mut self.strip.planes[plane][o..],
+                                    stride,
+                                );
+                                let sc = scan(tx_sz, tx_type);
+                                for &p in &sc[..eob] {
+                                    self.coefs[p as usize] = 0;
+                                }
+                            }
+                        }
+                    }
+                    let ax = start_x >> 2;
+                    let ly = start_y >> 2;
+                    let an = &mut self.above_nonzero[plane];
+                    let e = (ax + step).min(an.len());
+                    an[ax.min(e)..e].fill(nonzero as u8);
+                    let ln = &mut self.left_nonzero[plane];
+                    let e = (ly + step).min(ln.len());
+                    ln[ly.min(e)..e].fill(nonzero as u8);
+                    block_idx += 1;
+                }
+            }
+        }
+    }
+
+    /// Transform type (6.4.25).
+    fn tx_type(&self, b: &Blk, plane: usize, tx_sz: u8, block_idx: usize) -> u8 {
+        if plane > 0 || tx_sz == TX_32X32 {
+            DCT_DCT
+        } else if tx_sz == TX_4X4 {
+            if self.h.lossless || b.is_inter { DCT_DCT } else { MODE2TXFM[if b.size < BLOCK_8X8 { b.sub_modes[block_idx] } else { b.y_mode } as usize] }
+        } else {
+            MODE2TXFM[b.y_mode as usize]
+        }
+    }
+
+    /// tokens (6.4.24): reads and dequantizes the coefficients into `self.coefs`. Returns the end
+    /// of block position and the number of leading coefficient rows that may be non-zero.
+    #[allow(clippy::too_many_arguments)]
+    fn tokens(&mut self, bd: &mut BoolDecoder, b: &Blk, plane: usize, start_x: usize, start_y: usize, tx_sz: u8, tx_type: u8) -> (usize, usize) {
+        let seg_eob = 16usize << (tx_sz << 1);
+        let sc = scan(tx_sz, tx_type);
+        let nb = neighbors(tx_sz, tx_type);
+        let bands: &[u8] = if tx_sz == 0 { &COEFBAND_4X4 } else { &COEFBAND_8X8PLUS };
+        let ptype = (plane > 0) as usize;
+        let rtype = b.is_inter as usize;
+        let probs = &self.fc.coef[tx_sz as usize][ptype][rtype];
+        let (sx, sy) = if plane > 0 { (self.ss_x, self.ss_y) } else { (0, 0) };
+        let max_x4 = (2 * self.mi_cols) >> sx;
+        let max_y4 = (2 * self.mi_rows) >> sy;
+        let n = 1usize << tx_sz;
+        let (x4, y4) = (start_x >> 2, start_y >> 2);
+        let mut above = 0u8;
+        let mut left = 0u8;
+        for i in 0..n {
+            if x4 + i < max_x4 {
+                above |= self.above_nonzero[plane][x4 + i];
+            }
+            if y4 + i < max_y4 {
+                left |= self.left_nonzero[plane][y4 + i];
+            }
+        }
+        let ctx0 = (above + left) as usize;
+        let q = self.s.seg_q[b.seg_id as usize][ptype];
+        let dq_shift = (tx_sz == TX_32X32) as u32;
+        let pareto = pareto_full();
+        let counting = self.s.counting;
+        let log2n = 2 + tx_sz as usize;
+        let bit_depth = self.bit_depth;
+        let mut max_row = 0usize;
+        let mut check_eob = true;
+        let mut c = 0usize;
+        let tc = &mut self.token_cache;
+        let coefs = &mut self.coefs;
+        let counts = &mut self.strip.counts;
+        while c < seg_eob {
+            let pos = sc[c] as usize;
+            let band = bands[c] as usize;
+            let ctx = if c == 0 {
+                ctx0
+            } else {
+                let (a, bb) = nb[c];
+                ((1 + tc[a as usize] + tc[bb as usize]) >> 1) as usize
+            };
+            let p = &probs[band][ctx];
+            if check_eob {
+                let more = bd.read_bool(p[0]);
+                if counting {
+                    counts.more_coefs[tx_sz as usize][ptype][rtype][band][ctx][more as usize] += 1;
+                }
+                if !more {
+                    break;
+                }
+            }
+            if !bd.read_bool(p[1]) {
+                tc[pos] = 0;
+                if counting {
+                    counts.token[tx_sz as usize][ptype][rtype][band][ctx][0] += 1;
+                }
+                check_eob = false;
+                c += 1;
+                continue;
+            }
+            check_eob = true;
+            let token: usize;
+            let coef: i64;
+            if !bd.read_bool(p[2]) {
+                if counting {
+                    counts.token[tx_sz as usize][ptype][rtype][band][ctx][1] += 1;
+                }
+                token = 1;
+                coef = 1;
+            } else {
+                if counting {
+                    counts.token[tx_sz as usize][ptype][rtype][band][ctx][2] += 1;
+                }
+                let pp = &pareto[p[2].max(1) as usize - 1];
+                token = if !bd.read_bool(pp[0]) {
+                    if !bd.read_bool(pp[1]) {
+                        2
+                    } else if !bd.read_bool(pp[2]) {
+                        3
+                    } else {
+                        4
+                    }
+                } else if !bd.read_bool(pp[3]) {
+                    if !bd.read_bool(pp[4]) { 5 } else { 6 }
+                } else if !bd.read_bool(pp[5]) {
+                    if !bd.read_bool(pp[6]) { 7 } else { 8 }
+                } else if !bd.read_bool(pp[7]) {
+                    9
+                } else {
+                    10
+                };
+                // read_coef (6.4.26)
+                let (cat, num_extra, base) = EXTRA_BITS[token];
+                let mut v = base as i64;
+                if token == 10 {
+                    for e in 0..(bit_depth as u32 - 8) {
+                        if bd.read_bool(255) {
+                            v += 1 << (5 + bit_depth as u32 - e);
+                        }
+                    }
+                }
+                let cp = CAT_PROBS[cat as usize];
+                for e in 0..num_extra as usize {
+                    if bd.read_bool(cp[e]) {
+                        v += 1 << (num_extra as usize - 1 - e);
+                    }
+                }
+                coef = v;
+            }
+            tc[pos] = ENERGY_CLASS[token];
+            let sign = bd.read_bool(128);
+            let qv = if pos == 0 { q[0] } else { q[1] } as i64;
+            let d = ((coef * qv) >> dq_shift) as i32;
+            coefs[pos] = if sign { d.wrapping_neg() } else { d };
+            max_row = max_row.max(pos >> log2n);
+            c += 1;
+        }
+        (c, max_row + 1)
+    }
+
+    /// Inter prediction process (8.5.2) for one block region.
+    #[allow(clippy::too_many_arguments)]
+    fn predict_inter(&mut self, b: &Blk, plane: usize, x: usize, y: usize, w: usize, h: usize, block_idx: usize) {
+        let is_compound = b.ref_frame[1] > INTRA_FRAME;
+        let (sx, sy) = if plane > 0 { (self.ss_x, self.ss_y) } else { (0, 0) };
+        for rl in 0..1 + is_compound as usize {
+            // Motion vector selection (8.5.2.1).
+            let bm = &b.block_mvs[rl];
+            let mv = if plane == 0 || b.size >= BLOCK_8X8 || (sx == 0 && sy == 0) {
+                bm[block_idx]
+            } else if sx == 0 && sy == 1 {
+                Mv::new(round_q2(bm[block_idx].row as i32 + bm[block_idx + 2].row as i32), round_q2(bm[block_idx].col as i32 + bm[block_idx + 2].col as i32))
+            } else if sx == 1 && sy == 0 {
+                Mv::new(round_q2(bm[block_idx].row as i32 + bm[block_idx + 1].row as i32), round_q2(bm[block_idx].col as i32 + bm[block_idx + 1].col as i32))
+            } else {
+                let sr: i32 = bm.iter().map(|m| m.row as i32).sum();
+                let sc: i32 = bm.iter().map(|m| m.col as i32).sum();
+                Mv::new(round_q4(sr), round_q4(sc))
+            };
+            // Motion vector clamping (8.5.2.2).
+            let bh = NUM_8X8_HIGH[b.size as usize] as i32;
+            let bw = NUM_8X8_WIDE[b.size as usize] as i32;
+            let (r, c) = (b.r as i32, b.c as i32);
+            let to_top = (-(r * 8 * 16)) >> sy;
+            let to_bottom = (((self.mi_rows as i32 - bh - r) * 8) * 16) >> sy;
+            let to_left = (-(c * 8 * 16)) >> sx;
+            let to_right = (((self.mi_cols as i32 - bw - c) * 8) * 16) >> sx;
+            let spel_left = (INTERP_EXTEND + ((bw * 8) >> sx)) << 4;
+            let spel_right = spel_left - 16;
+            let spel_top = (INTERP_EXTEND + ((bh * 8) >> sy)) << 4;
+            let spel_bottom = spel_top - 16;
+            let cmv_row = ((2 * mv.row as i32) >> sy).clamp(to_top - spel_top, (to_bottom + spel_bottom).max(to_top - spel_top));
+            let cmv_col = ((2 * mv.col as i32) >> sx).clamp(to_left - spel_left, (to_right + spel_right).max(to_left - spel_left));
+            let ri = (b.ref_frame[rl] - 1).clamp(0, 2) as usize;
+            let Some(rf) = &self.s.refs[ri] else {
+                if self.error.is_none() {
+                    self.error = Some(Error::MissingReference(format!("block uses unusable reference {}", b.ref_frame[rl])));
+                }
+                let out = if rl == 0 { &mut self.pred } else { &mut self.pred2 };
+                out[..w * h].fill(1 << (self.bit_depth - 1));
+                continue;
+            };
+            // Motion vector scaling (8.5.2.3).
+            let (x_scale, y_scale) = (rf.x_scale as i64, rf.y_scale as i64);
+            let (start_x, start_y, step_x, step_y) = if rf.x_step == 16 && rf.y_step == 16 && x_scale == 1 << 14 && y_scale == 1 << 14 {
+                (((x as i32) << 4) + cmv_col, ((y as i32) << 4) + cmv_row, 16, 16)
+            } else {
+                self.strip.scaled_blocks += 1;
+                let base_x = (x as i64 * x_scale) >> 14;
+                let base_y = (y as i64 * y_scale) >> 14;
+                let luma_x = (x << sx) as i64;
+                let luma_y = (y << sy) as i64;
+                let frac_x = ((16 * luma_x * x_scale) >> 14) & 15;
+                let frac_y = ((16 * luma_y * y_scale) >> 14) & 15;
+                let dx = ((cmv_col as i64 * x_scale) >> 14) + frac_x;
+                let dy = ((cmv_row as i64 * y_scale) >> 14) + frac_y;
+                (((base_x << 4) + dx) as i32, ((base_y << 4) + dy) as i32, rf.x_step, rf.y_step)
+            };
+            let f = rf.frame;
+            let p = &f.planes[plane];
+            let rp = RefPlane {
+                data: &p.data,
+                stride: p.stride,
+                last_x: ((f.width as i32 + sx as i32) >> sx) - 1,
+                last_y: ((f.height as i32 + sy as i32) >> sy) - 1,
+            };
+            let out = if rl == 0 { &mut self.pred } else { &mut self.pred2 };
+            inter::predict(&rp, start_x, start_y, step_x, step_y, w, h, b.interp_filter, self.bit_depth, out, &mut self.mc_tmp, &mut self.mc_win);
+        }
+        let (stride, x_off) = (self.strip.strides[plane], self.strip.x_off[plane]);
+        let dst = &mut self.strip.planes[plane];
+        for i in 0..h {
+            let o = (y + i) * stride + x - x_off;
+            let row = &mut dst[o..o + w];
+            if is_compound {
+                for ((d, &a), &bb) in row.iter_mut().zip(&self.pred[i * w..i * w + w]).zip(&self.pred2[i * w..i * w + w]) {
+                    *d = ((a as u32 + bb as u32 + 1) >> 1) as u16;
+                }
+            } else {
+                row.copy_from_slice(&self.pred[i * w..i * w + w]);
+            }
+        }
+    }
+}
diff --git a/crates/vp9/src/transform.rs b/crates/vp9/src/transform.rs
new file mode 100644
index 000000000..f0daf1fd5
--- /dev/null
+++ b/crates/vp9/src/transform.rs
@@ -0,0 +1,341 @@
+//! 2D inverse transforms and reconstruction (8.6.2, 8.7.2). The 1D DCT / ADST butterflies are
+//! generated from the specification's step lists (`transform_gen.rs`); ADST4 (8.7.1.6) and the
+//! Walsh-Hadamard transform (8.7.1.10) are written out here.
+
+use crate::tables::{ADST_ADST, ADST_DCT, DCT_ADST, DCT_DCT};
+use crate::transform_gen::{narrow, wide};
+
+const SINPI_1_9: i64 = 5283;
+const SINPI_2_9: i64 = 9929;
+const SINPI_3_9: i64 = 13377;
+const SINPI_4_9: i64 = 15212;
+
+macro_rules! adst4 {
+    ($name:ident, $t:ty) => {
+        #[inline(always)]
+        fn $name(x: [$t; 4]) -> [$t; 4] {
+            let (s1_9, s2_9, s3_9, s4_9) = (SINPI_1_9 as $t, SINPI_2_9 as $t, SINPI_3_9 as $t, SINPI_4_9 as $t);
+            let s0 = s1_9.wrapping_mul(x[0]);
+            let s1 = s2_9.wrapping_mul(x[0]);
+            let s2 = s3_9.wrapping_mul(x[1]);
+            let s3 = s4_9.wrapping_mul(x[2]);
+            let s4 = s1_9.wrapping_mul(x[2]);
+            let s5 = s2_9.wrapping_mul(x[3]);
+            let s6 = s4_9.wrapping_mul(x[3]);
+            let v = x[0].wrapping_sub(x[2]).wrapping_add(x[3]);
+            let s7 = s3_9.wrapping_mul(v);
+            let x0 = s0.wrapping_add(s3).wrapping_add(s5);
+            let x1 = s1.wrapping_sub(s4).wrapping_sub(s6);
+            let x2 = s7;
+            let x3 = s2;
+            let r = |v: $t| v.wrapping_add(1 << 13) >> 14;
+            [r(x0.wrapping_add(x3)), r(x1.wrapping_add(x3)), r(x2), r(x0.wrapping_add(x1).wrapping_sub(x3))]
+        }
+    };
+}
+adst4!(iadst4_narrow, i32);
+adst4!(iadst4_wide, i64);
+
+/// Inverse Walsh-Hadamard transform (8.7.1.10).
+fn iwht4(x: [i32; 4], shift: u32) -> [i32; 4] {
+    let mut a = x[0] >> shift;
+    let mut c = x[1] >> shift;
+    let mut d = x[2] >> shift;
+    let mut b = x[3] >> shift;
+    a = a.wrapping_add(c);
+    d = d.wrapping_sub(b);
+    let e = a.wrapping_sub(d) >> 1;
+    b = e.wrapping_sub(b);
+    c = e.wrapping_sub(c);
+    a = a.wrapping_sub(b);
+    d = d.wrapping_add(c);
+    [a, b, c, d]
+}
+
+/// Apply a 1D transform of length `n` (4, 8, 16, 32) in place.
+#[inline(always)]
+fn tx1d_narrow(buf: &mut [i32], n: usize, adst: bool) {
+    match (n, adst) {
+        (4, false) => {
+            let r = narrow::idct4(buf[..4].try_into().unwrap());
+            buf[..4].copy_from_slice(&r);
+        }
+        (4, true) => {
+            let r = iadst4_narrow(buf[..4].try_into().unwrap());
+            buf[..4].copy_from_slice(&r);
+        }
+        (8, false) => {
+            let r = narrow::idct8(buf[..8].try_into().unwrap());
+            buf[..8].copy_from_slice(&r);
+        }
+        (8, true) => {
+            let r = narrow::iadst8(buf[..8].try_into().unwrap());
+            buf[..8].copy_from_slice(&r);
+        }
+        (16, false) => {
+            let r = narrow::idct16(buf[..16].try_into().unwrap());
+            buf[..16].copy_from_slice(&r);
+        }
+        (16, true) => {
+            let r = narrow::iadst16(buf[..16].try_into().unwrap());
+            buf[..16].copy_from_slice(&r);
+        }
+        _ => {
+            let r = narrow::idct32(buf[..32].try_into().unwrap());
+            buf[..32].copy_from_slice(&r);
+        }
+    }
+}
+
+#[inline(always)]
+fn tx1d_wide(buf: &mut [i64], n: usize, adst: bool) {
+    match (n, adst) {
+        (4, false) => {
+            let r = wide::idct4(buf[..4].try_into().unwrap());
+            buf[..4].copy_from_slice(&r);
+        }
+        (4, true) => {
+            let r = iadst4_wide(buf[..4].try_into().unwrap());
+            buf[..4].copy_from_slice(&r);
+        }
+        (8, false) => {
+            let r = wide::idct8(buf[..8].try_into().unwrap());
+            buf[..8].copy_from_slice(&r);
+        }
+        (8, true) => {
+            let r = wide::iadst8(buf[..8].try_into().unwrap());
+            buf[..8].copy_from_slice(&r);
+        }
+        (16, false) => {
+            let r = wide::idct16(buf[..16].try_into().unwrap());
+            buf[..16].copy_from_slice(&r);
+        }
+        (16, true) => {
+            let r = wide::iadst16(buf[..16].try_into().unwrap());
+            buf[..16].copy_from_slice(&r);
+        }
+        _ => {
+            let r = wide::idct32(buf[..32].try_into().unwrap());
+            buf[..32].copy_from_slice(&r);
+        }
+    }
+}
+
+/// Clamp coefficients so that garbage streams cannot overflow the 32-bit arithmetic (conformant
+/// streams keep far smaller values, 8 + BitDepth bits).
+#[inline]
+fn sat(v: i32, lim: i32) -> i32 {
+    v.clamp(-lim, lim)
+}
+
+/// Inverse transform `coefs` (row-major n x n dequantized coefficients, `rows` = number of leading
+/// rows that can hold non-zero values) and add the residual to `dst` (8.6.2 step 4).
+#[allow(clippy::too_many_arguments)]
+pub fn inverse_transform_add(coefs: &[i32], tx_size: u8, tx_type: u8, lossless: bool, eob: usize, rows: usize, bit_depth: u8, dst: &mut [u16], stride: usize) {
+    let n = 4usize << tx_size;
+    let max = (1i32 << bit_depth) - 1;
+    if lossless {
+        let mut t = [0i32; 16];
+        for i in 0..4 {
+            let r = iwht4(coefs[i * 4..i * 4 + 4].try_into().unwrap(), 2);
+            t[i * 4..i * 4 + 4].copy_from_slice(&r);
+        }
+        for j in 0..4 {
+            let r = iwht4([t[j], t[4 + j], t[8 + j], t[12 + j]], 0);
+            for i in 0..4 {
+                let p = &mut dst[i * stride + j];
+                *p = (*p as i32).saturating_add(r[i]).clamp(0, max) as u16;
+            }
+        }
+        return;
+    }
+    let shift = (tx_size as u32 + 4).min(6);
+    let round = 1i32 << (shift - 1);
+    if eob == 1 && tx_type == DCT_DCT {
+        // Only the DC coefficient is present: every output of both passes is equal (8.7.2 with a
+        // single non-zero input).
+        let dc = coefs[0] as i64;
+        let a = (dc * 11585 + (1 << 13)) >> 14;
+        let b = (a * 11585 + (1 << 13)) >> 14;
+        let v = ((b + round as i64) >> shift).clamp(-(1 << 20), 1 << 20) as i32;
+        for i in 0..n {
+            for p in dst[i * stride..i * stride + n].iter_mut() {
+                *p = (*p as i32 + v).clamp(0, max) as u16;
+            }
+        }
+        return;
+    }
+    let row_adst = matches!(tx_type, DCT_ADST | ADST_ADST);
+    let col_adst = matches!(tx_type, ADST_DCT | ADST_ADST);
+    let p = TxParams { row_adst, col_adst, rows, shift, round, max };
+    match (tx_size, bit_depth == 8) {
+        (0, true) => itx_narrow::<4>(coefs, &p, dst, stride),
+        (1, true) => itx_narrow::<8>(coefs, &p, dst, stride),
+        (2, true) => itx_narrow::<16>(coefs, &p, dst, stride),
+        (_, true) => itx_narrow::<32>(coefs, &p, dst, stride),
+        (0, false) => itx_wide::<4>(coefs, &p, dst, stride),
+        (1, false) => itx_wide::<8>(coefs, &p, dst, stride),
+        (2, false) => itx_wide::<16>(coefs, &p, dst, stride),
+        (_, false) => itx_wide::<32>(coefs, &p, dst, stride),
+    }
+}
+
+struct TxParams {
+    row_adst: bool,
+    col_adst: bool,
+    rows: usize,
+    shift: u32,
+    round: i32,
+    max: i32,
+}
+
+/// 2D inverse transform of size N with 32-bit intermediates (8-bit streams).
+fn itx_narrow<const N: usize>(coefs: &[i32], p: &TxParams, dst: &mut [u16], stride: usize) {
+    let lim = 1 << 24;
+    let mut t = [[0i32; N]; N];
+    for (i, row) in t.iter_mut().enumerate().take(p.rows.min(N)) {
+        for (d, s) in row.iter_mut().zip(&coefs[i * N..i * N + N]) {
+            *d = sat(*s, lim);
+        }
+        tx1d_narrow(row, N, p.row_adst);
+        for v in row.iter_mut() {
+            *v = sat(*v, lim);
+        }
+    }
+    let mut col = [0i32; N];
+    for j in 0..N {
+        for i in 0..N {
+            col[i] = t[i][j];
+        }
+        tx1d_narrow(&mut col, N, p.col_adst);
+        for i in 0..N {
+            let d = &mut dst[i * stride + j];
+            *d = (*d as i32 + (col[i].wrapping_add(p.round) >> p.shift).clamp(-(1 << 20), 1 << 20)).clamp(0, p.max) as u16;
+        }
+    }
+}
+
+/// 2D inverse transform of size N with 64-bit intermediates (high bit depth).
+fn itx_wide<const N: usize>(coefs: &[i32], p: &TxParams, dst: &mut [u16], stride: usize) {
+    let lim = 1i64 << 40;
+    let mut t = [[0i64; N]; N];
+    for (i, row) in t.iter_mut().enumerate().take(p.rows.min(N)) {
+        for (d, s) in row.iter_mut().zip(&coefs[i * N..i * N + N]) {
+            *d = *s as i64;
+        }
+        tx1d_wide(row, N, p.row_adst);
+        for v in row.iter_mut() {
+            *v = (*v).clamp(-lim, lim);
+        }
+    }
+    let mut col = [0i64; N];
+    for j in 0..N {
+        for i in 0..N {
+            col[i] = t[i][j];
+        }
+        tx1d_wide(&mut col, N, p.col_adst);
+        for i in 0..N {
+            let d = &mut dst[i * stride + j];
+            let r = ((col[i].clamp(-lim, lim) + p.round as i64) >> p.shift).clamp(-(1 << 30), 1 << 30) as i32;
+            *d = (*d as i32 + r).clamp(0, p.max) as u16;
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Reference inverse DCT (orthonormal, scaled like VP9: DC gain 1/sqrt(2) per pass times
+    /// sqrt(2) ... ) — compare basis functions up to rounding.
+    fn float_idct(input: &[f64]) -> Vec<f64> {
+        let n = input.len();
+        (0..n)
+            .map(|x| {
+                let mut s = input[0] / 2f64.sqrt();
+                for (k, &v) in input.iter().enumerate().skip(1) {
+                    s += v * ((2 * x + 1) as f64 * k as f64 * std::f64::consts::PI / (2 * n) as f64).cos();
+                }
+                s
+            })
+            .collect()
+    }
+
+    #[test]
+    fn idct_matches_float_reference() {
+        for n in [4usize, 8, 16, 32] {
+            for k in 0..n {
+                let mut buf = vec![0i32; n];
+                buf[k] = 1000;
+                tx1d_narrow(&mut buf, n, false);
+                let mut inp = vec![0f64; n];
+                inp[k] = 1000.0;
+                let r = float_idct(&inp);
+                for (a, b) in buf.iter().zip(&r) {
+                    assert!((*a as f64 - b).abs() <= 3.0, "n {n} k {k}: {buf:?} vs {r:?}");
+                }
+                let mut w: Vec<i64> = vec![0; n];
+                w[k] = 1000;
+                tx1d_wide(&mut w, n, false);
+                assert_eq!(w.iter().map(|&v| v as i32).collect::<Vec<_>>(), buf);
+            }
+        }
+    }
+
+    #[test]
+    fn adst_is_sine_basis() {
+        // VP9's ADST (for n = 8, 16) is a DST-IV variant: out[x] ~ sum in[k] sin(pi (2x+1)(2k+1) / 4n).
+        for n in [8usize, 16] {
+            for k in 0..n {
+                let mut buf = vec![0i32; n];
+                buf[k] = 1000;
+                tx1d_narrow(&mut buf, n, true);
+                let r: Vec<f64> = (0..n)
+                    .map(|x| 1000.0 * ((2 * x + 1) as f64 * (2 * k + 1) as f64 * std::f64::consts::PI / (4 * n) as f64).sin() * 2f64.sqrt() / 2f64.sqrt())
+                    .collect();
+                for (a, b) in buf.iter().zip(&r) {
+                    assert!((*a as f64 - b).abs() <= 4.0, "n {n} k {k}: {buf:?} vs {r:?}");
+                }
+            }
+        }
+        // ADST4 is the sine transform sin(pi (x+1)(2k+1) / 9) scaled.
+        for k in 0..4 {
+            let mut buf = vec![0i32; 4];
+            buf[k] = 1000;
+            tx1d_narrow(&mut buf, 4, true);
+            let r: Vec<f64> =
+                (0..4).map(|x| 1000.0 * (std::f64::consts::PI * (x + 1) as f64 * (2 * k + 1) as f64 / 9.0).sin() * 2.0 * 2f64.sqrt() / 3.0).collect();
+            for (a, b) in buf.iter().zip(&r) {
+                assert!((*a as f64 - b).abs() <= 3.0, "k {k}: {buf:?} vs {r:?}");
+            }
+        }
+    }
+
+    #[test]
+    fn dc_only_shortcut_matches_full_transform() {
+        for tx in 0..4u8 {
+            let n = 4usize << tx;
+            for dc in [-5000, -37, -1, 1, 2, 57, 1234, 9999] {
+                let mut coefs = vec![0i32; n * n];
+                coefs[0] = dc;
+                let mut a = vec![128u16; n * n];
+                let mut b = vec![128u16; n * n];
+                inverse_transform_add(&coefs, tx, DCT_DCT, false, 1, 1, 8, &mut a, n);
+                inverse_transform_add(&coefs, tx, DCT_DCT, false, 2, n, 8, &mut b, n);
+                assert_eq!(a, b, "tx {tx} dc {dc}");
+            }
+        }
+    }
+
+    #[test]
+    fn wht_round_trip_identity() {
+        // A single DC coefficient of 4 * v spreads v / 4 ... check invertibility on a simple case:
+        // input [4, 0, ..] (after the >> 2 pre-scaling a unit impulse).
+        let mut coefs = [0i32; 16];
+        coefs[0] = 4 * 4;
+        let mut dst = [100u16; 16];
+        inverse_transform_add(&coefs, 0, DCT_DCT, true, 1, 4, 8, &mut dst, 4);
+        let sum: i32 = dst.iter().map(|&v| v as i32 - 100).sum();
+        assert_eq!(sum, 16);
+    }
+}
diff --git a/crates/vp9/src/transform_gen.rs b/crates/vp9/src/transform_gen.rs
new file mode 100644
index 000000000..6d2136b48
--- /dev/null
+++ b/crates/vp9/src/transform_gen.rs
@@ -0,0 +1,480 @@
+// Generated by tools/gen_transforms.py from the butterfly descriptions of the VP9 specification
+// v0.6 section 8.7.1. Do not edit by hand.
+
+macro_rules! transforms_1d {
+    ($t:ty) => {
+    #[inline(always)]
+    fn r14(x: $t) -> $t {
+        x.wrapping_add(1 << 13) >> 14
+    }
+
+    #[inline(always)]
+    pub fn idct4(x: [$t; 4]) -> [$t; 4] {
+        let v0 = r14(x[0].wrapping_mul(11585).wrapping_add(x[2].wrapping_mul(-11585)));
+        let v1 = r14(x[0].wrapping_mul(11585).wrapping_add(x[2].wrapping_mul(11585)));
+        let v2 = r14(x[1].wrapping_mul(6270).wrapping_add(x[3].wrapping_mul(-15137)));
+        let v3 = r14(x[1].wrapping_mul(15137).wrapping_add(x[3].wrapping_mul(6270)));
+        let v4 = v1.wrapping_add(v3);
+        let v5 = v1.wrapping_sub(v3);
+        let v6 = v0.wrapping_add(v2);
+        let v7 = v0.wrapping_sub(v2);
+        [v4, v6, v7, v5]
+    }
+
+    #[inline(always)]
+    pub fn idct8(x: [$t; 8]) -> [$t; 8] {
+        let v0 = r14(x[0].wrapping_mul(11585).wrapping_add(x[4].wrapping_mul(-11585)));
+        let v1 = r14(x[0].wrapping_mul(11585).wrapping_add(x[4].wrapping_mul(11585)));
+        let v2 = r14(x[2].wrapping_mul(6270).wrapping_add(x[6].wrapping_mul(-15137)));
+        let v3 = r14(x[2].wrapping_mul(15137).wrapping_add(x[6].wrapping_mul(6270)));
+        let v4 = v1.wrapping_add(v3);
+        let v5 = v1.wrapping_sub(v3);
+        let v6 = v0.wrapping_add(v2);
+        let v7 = v0.wrapping_sub(v2);
+        let v8 = r14(x[1].wrapping_mul(3196).wrapping_add(x[7].wrapping_mul(-16069)));
+        let v9 = r14(x[1].wrapping_mul(16069).wrapping_add(x[7].wrapping_mul(3196)));
+        let v10 = r14(x[5].wrapping_mul(13623).wrapping_add(x[3].wrapping_mul(-9102)));
+        let v11 = r14(x[5].wrapping_mul(9102).wrapping_add(x[3].wrapping_mul(13623)));
+        let v12 = v8.wrapping_add(v10);
+        let v13 = v8.wrapping_sub(v10);
+        let v14 = v9.wrapping_add(v11);
+        let v15 = v9.wrapping_sub(v11);
+        let v16 = r14(v15.wrapping_mul(11585).wrapping_add(v13.wrapping_mul(-11585)));
+        let v17 = r14(v15.wrapping_mul(11585).wrapping_add(v13.wrapping_mul(11585)));
+        let v18 = v4.wrapping_add(v14);
+        let v19 = v4.wrapping_sub(v14);
+        let v20 = v6.wrapping_add(v17);
+        let v21 = v6.wrapping_sub(v17);
+        let v22 = v7.wrapping_add(v16);
+        let v23 = v7.wrapping_sub(v16);
+        let v24 = v5.wrapping_add(v12);
+        let v25 = v5.wrapping_sub(v12);
+        [v18, v20, v22, v24, v25, v23, v21, v19]
+    }
+
+    #[inline(always)]
+    pub fn idct16(x: [$t; 16]) -> [$t; 16] {
+        let v0 = r14(x[0].wrapping_mul(11585).wrapping_add(x[8].wrapping_mul(-11585)));
+        let v1 = r14(x[0].wrapping_mul(11585).wrapping_add(x[8].wrapping_mul(11585)));
+        let v2 = r14(x[4].wrapping_mul(6270).wrapping_add(x[12].wrapping_mul(-15137)));
+        let v3 = r14(x[4].wrapping_mul(15137).wrapping_add(x[12].wrapping_mul(6270)));
+        let v4 = v1.wrapping_add(v3);
+        let v5 = v1.wrapping_sub(v3);
+        let v6 = v0.wrapping_add(v2);
+        let v7 = v0.wrapping_sub(v2);
+        let v8 = r14(x[2].wrapping_mul(3196).wrapping_add(x[14].wrapping_mul(-16069)));
+        let v9 = r14(x[2].wrapping_mul(16069).wrapping_add(x[14].wrapping_mul(3196)));
+        let v10 = r14(x[10].wrapping_mul(13623).wrapping_add(x[6].wrapping_mul(-9102)));
+        let v11 = r14(x[10].wrapping_mul(9102).wrapping_add(x[6].wrapping_mul(13623)));
+        let v12 = v8.wrapping_add(v10);
+        let v13 = v8.wrapping_sub(v10);
+        let v14 = v9.wrapping_add(v11);
+        let v15 = v9.wrapping_sub(v11);
+        let v16 = r14(v15.wrapping_mul(11585).wrapping_add(v13.wrapping_mul(-11585)));
+        let v17 = r14(v15.wrapping_mul(11585).wrapping_add(v13.wrapping_mul(11585)));
+        let v18 = v4.wrapping_add(v14);
+        let v19 = v4.wrapping_sub(v14);
+        let v20 = v6.wrapping_add(v17);
+        let v21 = v6.wrapping_sub(v17);
+        let v22 = v7.wrapping_add(v16);
+        let v23 = v7.wrapping_sub(v16);
+        let v24 = v5.wrapping_add(v12);
+        let v25 = v5.wrapping_sub(v12);
+        let v26 = r14(x[1].wrapping_mul(1606).wrapping_add(x[15].wrapping_mul(-16305)));
+        let v27 = r14(x[1].wrapping_mul(16305).wrapping_add(x[15].wrapping_mul(1606)));
+        let v28 = r14(x[9].wrapping_mul(12665).wrapping_add(x[7].wrapping_mul(-10394)));
+        let v29 = r14(x[9].wrapping_mul(10394).wrapping_add(x[7].wrapping_mul(12665)));
+        let v30 = r14(x[5].wrapping_mul(7723).wrapping_add(x[11].wrapping_mul(-14449)));
+        let v31 = r14(x[5].wrapping_mul(14449).wrapping_add(x[11].wrapping_mul(7723)));
+        let v32 = r14(x[13].wrapping_mul(15679).wrapping_add(x[3].wrapping_mul(-4756)));
+        let v33 = r14(x[13].wrapping_mul(4756).wrapping_add(x[3].wrapping_mul(15679)));
+        let v34 = v26.wrapping_add(v28);
+        let v35 = v26.wrapping_sub(v28);
+        let v36 = v32.wrapping_add(v30);
+        let v37 = v32.wrapping_sub(v30);
+        let v38 = v33.wrapping_add(v31);
+        let v39 = v33.wrapping_sub(v31);
+        let v40 = v27.wrapping_add(v29);
+        let v41 = v27.wrapping_sub(v29);
+        let v42 = r14(v41.wrapping_mul(6270).wrapping_add(v35.wrapping_mul(-15137)));
+        let v43 = r14(v41.wrapping_mul(15137).wrapping_add(v35.wrapping_mul(6270)));
+        let v44 = r14(v37.wrapping_mul(-15137).wrapping_add(v39.wrapping_mul(6270)));
+        let v45 = r14(v37.wrapping_mul(-6270).wrapping_add(v39.wrapping_mul(-15137)));
+        let v46 = v34.wrapping_add(v36);
+        let v47 = v34.wrapping_sub(v36);
+        let v48 = v40.wrapping_add(v38);
+        let v49 = v40.wrapping_sub(v38);
+        let v50 = v42.wrapping_add(v45);
+        let v51 = v42.wrapping_sub(v45);
+        let v52 = v43.wrapping_add(v44);
+        let v53 = v43.wrapping_sub(v44);
+        let v54 = r14(v53.wrapping_mul(11585).wrapping_add(v51.wrapping_mul(-11585)));
+        let v55 = r14(v53.wrapping_mul(11585).wrapping_add(v51.wrapping_mul(11585)));
+        let v56 = r14(v49.wrapping_mul(11585).wrapping_add(v47.wrapping_mul(-11585)));
+        let v57 = r14(v49.wrapping_mul(11585).wrapping_add(v47.wrapping_mul(11585)));
+        let v58 = v18.wrapping_add(v48);
+        let v59 = v18.wrapping_sub(v48);
+        let v60 = v20.wrapping_add(v52);
+        let v61 = v20.wrapping_sub(v52);
+        let v62 = v22.wrapping_add(v55);
+        let v63 = v22.wrapping_sub(v55);
+        let v64 = v24.wrapping_add(v57);
+        let v65 = v24.wrapping_sub(v57);
+        let v66 = v25.wrapping_add(v56);
+        let v67 = v25.wrapping_sub(v56);
+        let v68 = v23.wrapping_add(v54);
+        let v69 = v23.wrapping_sub(v54);
+        let v70 = v21.wrapping_add(v50);
+        let v71 = v21.wrapping_sub(v50);
+        let v72 = v19.wrapping_add(v46);
+        let v73 = v19.wrapping_sub(v46);
+        [v58, v60, v62, v64, v66, v68, v70, v72, v73, v71, v69, v67, v65, v63, v61, v59]
+    }
+
+    #[inline(always)]
+    pub fn idct32(x: [$t; 32]) -> [$t; 32] {
+        let v0 = r14(x[0].wrapping_mul(11585).wrapping_add(x[16].wrapping_mul(-11585)));
+        let v1 = r14(x[0].wrapping_mul(11585).wrapping_add(x[16].wrapping_mul(11585)));
+        let v2 = r14(x[8].wrapping_mul(6270).wrapping_add(x[24].wrapping_mul(-15137)));
+        let v3 = r14(x[8].wrapping_mul(15137).wrapping_add(x[24].wrapping_mul(6270)));
+        let v4 = v1.wrapping_add(v3);
+        let v5 = v1.wrapping_sub(v3);
+        let v6 = v0.wrapping_add(v2);
+        let v7 = v0.wrapping_sub(v2);
+        let v8 = r14(x[4].wrapping_mul(3196).wrapping_add(x[28].wrapping_mul(-16069)));
+        let v9 = r14(x[4].wrapping_mul(16069).wrapping_add(x[28].wrapping_mul(3196)));
+        let v10 = r14(x[20].wrapping_mul(13623).wrapping_add(x[12].wrapping_mul(-9102)));
+        let v11 = r14(x[20].wrapping_mul(9102).wrapping_add(x[12].wrapping_mul(13623)));
+        let v12 = v8.wrapping_add(v10);
+        let v13 = v8.wrapping_sub(v10);
+        let v14 = v9.wrapping_add(v11);
+        let v15 = v9.wrapping_sub(v11);
+        let v16 = r14(v15.wrapping_mul(11585).wrapping_add(v13.wrapping_mul(-11585)));
+        let v17 = r14(v15.wrapping_mul(11585).wrapping_add(v13.wrapping_mul(11585)));
+        let v18 = v4.wrapping_add(v14);
+        let v19 = v4.wrapping_sub(v14);
+        let v20 = v6.wrapping_add(v17);
+        let v21 = v6.wrapping_sub(v17);
+        let v22 = v7.wrapping_add(v16);
+        let v23 = v7.wrapping_sub(v16);
+        let v24 = v5.wrapping_add(v12);
+        let v25 = v5.wrapping_sub(v12);
+        let v26 = r14(x[2].wrapping_mul(1606).wrapping_add(x[30].wrapping_mul(-16305)));
+        let v27 = r14(x[2].wrapping_mul(16305).wrapping_add(x[30].wrapping_mul(1606)));
+        let v28 = r14(x[18].wrapping_mul(12665).wrapping_add(x[14].wrapping_mul(-10394)));
+        let v29 = r14(x[18].wrapping_mul(10394).wrapping_add(x[14].wrapping_mul(12665)));
+        let v30 = r14(x[10].wrapping_mul(7723).wrapping_add(x[22].wrapping_mul(-14449)));
+        let v31 = r14(x[10].wrapping_mul(14449).wrapping_add(x[22].wrapping_mul(7723)));
+        let v32 = r14(x[26].wrapping_mul(15679).wrapping_add(x[6].wrapping_mul(-4756)));
+        let v33 = r14(x[26].wrapping_mul(4756).wrapping_add(x[6].wrapping_mul(15679)));
+        let v34 = v26.wrapping_add(v28);
+        let v35 = v26.wrapping_sub(v28);
+        let v36 = v32.wrapping_add(v30);
+        let v37 = v32.wrapping_sub(v30);
+        let v38 = v33.wrapping_add(v31);
+        let v39 = v33.wrapping_sub(v31);
+        let v40 = v27.wrapping_add(v29);
+        let v41 = v27.wrapping_sub(v29);
+        let v42 = r14(v41.wrapping_mul(6270).wrapping_add(v35.wrapping_mul(-15137)));
+        let v43 = r14(v41.wrapping_mul(15137).wrapping_add(v35.wrapping_mul(6270)));
+        let v44 = r14(v37.wrapping_mul(-15137).wrapping_add(v39.wrapping_mul(6270)));
+        let v45 = r14(v37.wrapping_mul(-6270).wrapping_add(v39.wrapping_mul(-15137)));
+        let v46 = v34.wrapping_add(v36);
+        let v47 = v34.wrapping_sub(v36);
+        let v48 = v40.wrapping_add(v38);
+        let v49 = v40.wrapping_sub(v38);
+        let v50 = v42.wrapping_add(v45);
+        let v51 = v42.wrapping_sub(v45);
+        let v52 = v43.wrapping_add(v44);
+        let v53 = v43.wrapping_sub(v44);
+        let v54 = r14(v53.wrapping_mul(11585).wrapping_add(v51.wrapping_mul(-11585)));
+        let v55 = r14(v53.wrapping_mul(11585).wrapping_add(v51.wrapping_mul(11585)));
+        let v56 = r14(v49.wrapping_mul(11585).wrapping_add(v47.wrapping_mul(-11585)));
+        let v57 = r14(v49.wrapping_mul(11585).wrapping_add(v47.wrapping_mul(11585)));
+        let v58 = v18.wrapping_add(v48);
+        let v59 = v18.wrapping_sub(v48);
+        let v60 = v20.wrapping_add(v52);
+        let v61 = v20.wrapping_sub(v52);
+        let v62 = v22.wrapping_add(v55);
+        let v63 = v22.wrapping_sub(v55);
+        let v64 = v24.wrapping_add(v57);
+        let v65 = v24.wrapping_sub(v57);
+        let v66 = v25.wrapping_add(v56);
+        let v67 = v25.wrapping_sub(v56);
+        let v68 = v23.wrapping_add(v54);
+        let v69 = v23.wrapping_sub(v54);
+        let v70 = v21.wrapping_add(v50);
+        let v71 = v21.wrapping_sub(v50);
+        let v72 = v19.wrapping_add(v46);
+        let v73 = v19.wrapping_sub(v46);
+        let v74 = r14(x[1].wrapping_mul(804).wrapping_add(x[31].wrapping_mul(-16364)));
+        let v75 = r14(x[1].wrapping_mul(16364).wrapping_add(x[31].wrapping_mul(804)));
+        let v76 = r14(x[17].wrapping_mul(12140).wrapping_add(x[15].wrapping_mul(-11003)));
+        let v77 = r14(x[17].wrapping_mul(11003).wrapping_add(x[15].wrapping_mul(12140)));
+        let v78 = r14(x[9].wrapping_mul(7005).wrapping_add(x[23].wrapping_mul(-14811)));
+        let v79 = r14(x[9].wrapping_mul(14811).wrapping_add(x[23].wrapping_mul(7005)));
+        let v80 = r14(x[25].wrapping_mul(15426).wrapping_add(x[7].wrapping_mul(-5520)));
+        let v81 = r14(x[25].wrapping_mul(5520).wrapping_add(x[7].wrapping_mul(15426)));
+        let v82 = r14(x[5].wrapping_mul(3981).wrapping_add(x[27].wrapping_mul(-15893)));
+        let v83 = r14(x[5].wrapping_mul(15893).wrapping_add(x[27].wrapping_mul(3981)));
+        let v84 = r14(x[21].wrapping_mul(14053).wrapping_add(x[11].wrapping_mul(-8423)));
+        let v85 = r14(x[21].wrapping_mul(8423).wrapping_add(x[11].wrapping_mul(14053)));
+        let v86 = r14(x[13].wrapping_mul(9760).wrapping_add(x[19].wrapping_mul(-13160)));
+        let v87 = r14(x[13].wrapping_mul(13160).wrapping_add(x[19].wrapping_mul(9760)));
+        let v88 = r14(x[29].wrapping_mul(16207).wrapping_add(x[3].wrapping_mul(-2404)));
+        let v89 = r14(x[29].wrapping_mul(2404).wrapping_add(x[3].wrapping_mul(16207)));
+        let v90 = v74.wrapping_add(v76);
+        let v91 = v74.wrapping_sub(v76);
+        let v92 = v80.wrapping_add(v78);
+        let v93 = v80.wrapping_sub(v78);
+        let v94 = v82.wrapping_add(v84);
+        let v95 = v82.wrapping_sub(v84);
+        let v96 = v88.wrapping_add(v86);
+        let v97 = v88.wrapping_sub(v86);
+        let v98 = v89.wrapping_add(v87);
+        let v99 = v89.wrapping_sub(v87);
+        let v100 = v83.wrapping_add(v85);
+        let v101 = v83.wrapping_sub(v85);
+        let v102 = v81.wrapping_add(v79);
+        let v103 = v81.wrapping_sub(v79);
+        let v104 = v75.wrapping_add(v77);
+        let v105 = v75.wrapping_sub(v77);
+        let v106 = r14(v105.wrapping_mul(3196).wrapping_add(v91.wrapping_mul(-16069)));
+        let v107 = r14(v105.wrapping_mul(16069).wrapping_add(v91.wrapping_mul(3196)));
+        let v108 = r14(v97.wrapping_mul(-9102).wrapping_add(v99.wrapping_mul(13623)));
+        let v109 = r14(v97.wrapping_mul(-13623).wrapping_add(v99.wrapping_mul(-9102)));
+        let v110 = r14(v101.wrapping_mul(13623).wrapping_add(v95.wrapping_mul(-9102)));
+        let v111 = r14(v101.wrapping_mul(9102).wrapping_add(v95.wrapping_mul(13623)));
+        let v112 = r14(v93.wrapping_mul(-16069).wrapping_add(v103.wrapping_mul(3196)));
+        let v113 = r14(v93.wrapping_mul(-3196).wrapping_add(v103.wrapping_mul(-16069)));
+        let v114 = v90.wrapping_add(v92);
+        let v115 = v90.wrapping_sub(v92);
+        let v116 = v96.wrapping_add(v94);
+        let v117 = v96.wrapping_sub(v94);
+        let v118 = v98.wrapping_add(v100);
+        let v119 = v98.wrapping_sub(v100);
+        let v120 = v104.wrapping_add(v102);
+        let v121 = v104.wrapping_sub(v102);
+        let v122 = v106.wrapping_add(v113);
+        let v123 = v106.wrapping_sub(v113);
+        let v124 = v109.wrapping_add(v110);
+        let v125 = v109.wrapping_sub(v110);
+        let v126 = v108.wrapping_add(v111);
+        let v127 = v108.wrapping_sub(v111);
+        let v128 = v107.wrapping_add(v112);
+        let v129 = v107.wrapping_sub(v112);
+        let v130 = r14(v129.wrapping_mul(6270).wrapping_add(v123.wrapping_mul(-15137)));
+        let v131 = r14(v129.wrapping_mul(15137).wrapping_add(v123.wrapping_mul(6270)));
+        let v132 = r14(v125.wrapping_mul(-15137).wrapping_add(v127.wrapping_mul(6270)));
+        let v133 = r14(v125.wrapping_mul(-6270).wrapping_add(v127.wrapping_mul(-15137)));
+        let v134 = r14(v121.wrapping_mul(6270).wrapping_add(v115.wrapping_mul(-15137)));
+        let v135 = r14(v121.wrapping_mul(15137).wrapping_add(v115.wrapping_mul(6270)));
+        let v136 = r14(v117.wrapping_mul(-15137).wrapping_add(v119.wrapping_mul(6270)));
+        let v137 = r14(v117.wrapping_mul(-6270).wrapping_add(v119.wrapping_mul(-15137)));
+        let v138 = v114.wrapping_add(v116);
+        let v139 = v114.wrapping_sub(v116);
+        let v140 = v120.wrapping_add(v118);
+        let v141 = v120.wrapping_sub(v118);
+        let v142 = v122.wrapping_add(v124);
+        let v143 = v122.wrapping_sub(v124);
+        let v144 = v128.wrapping_add(v126);
+        let v145 = v128.wrapping_sub(v126);
+        let v146 = v130.wrapping_add(v133);
+        let v147 = v130.wrapping_sub(v133);
+        let v148 = v131.wrapping_add(v132);
+        let v149 = v131.wrapping_sub(v132);
+        let v150 = v134.wrapping_add(v137);
+        let v151 = v134.wrapping_sub(v137);
+        let v152 = v135.wrapping_add(v136);
+        let v153 = v135.wrapping_sub(v136);
+        let v154 = r14(v153.wrapping_mul(11585).wrapping_add(v151.wrapping_mul(-11585)));
+        let v155 = r14(v153.wrapping_mul(11585).wrapping_add(v151.wrapping_mul(11585)));
+        let v156 = r14(v149.wrapping_mul(11585).wrapping_add(v147.wrapping_mul(-11585)));
+        let v157 = r14(v149.wrapping_mul(11585).wrapping_add(v147.wrapping_mul(11585)));
+        let v158 = r14(v145.wrapping_mul(11585).wrapping_add(v143.wrapping_mul(-11585)));
+        let v159 = r14(v145.wrapping_mul(11585).wrapping_add(v143.wrapping_mul(11585)));
+        let v160 = r14(v141.wrapping_mul(11585).wrapping_add(v139.wrapping_mul(-11585)));
+        let v161 = r14(v141.wrapping_mul(11585).wrapping_add(v139.wrapping_mul(11585)));
+        let v162 = v58.wrapping_add(v140);
+        let v163 = v58.wrapping_sub(v140);
+        let v164 = v60.wrapping_add(v144);
+        let v165 = v60.wrapping_sub(v144);
+        let v166 = v62.wrapping_add(v148);
+        let v167 = v62.wrapping_sub(v148);
+        let v168 = v64.wrapping_add(v152);
+        let v169 = v64.wrapping_sub(v152);
+        let v170 = v66.wrapping_add(v155);
+        let v171 = v66.wrapping_sub(v155);
+        let v172 = v68.wrapping_add(v157);
+        let v173 = v68.wrapping_sub(v157);
+        let v174 = v70.wrapping_add(v159);
+        let v175 = v70.wrapping_sub(v159);
+        let v176 = v72.wrapping_add(v161);
+        let v177 = v72.wrapping_sub(v161);
+        let v178 = v73.wrapping_add(v160);
+        let v179 = v73.wrapping_sub(v160);
+        let v180 = v71.wrapping_add(v158);
+        let v181 = v71.wrapping_sub(v158);
+        let v182 = v69.wrapping_add(v156);
+        let v183 = v69.wrapping_sub(v156);
+        let v184 = v67.wrapping_add(v154);
+        let v185 = v67.wrapping_sub(v154);
+        let v186 = v65.wrapping_add(v150);
+        let v187 = v65.wrapping_sub(v150);
+        let v188 = v63.wrapping_add(v146);
+        let v189 = v63.wrapping_sub(v146);
+        let v190 = v61.wrapping_add(v142);
+        let v191 = v61.wrapping_sub(v142);
+        let v192 = v59.wrapping_add(v138);
+        let v193 = v59.wrapping_sub(v138);
+        [v162, v164, v166, v168, v170, v172, v174, v176, v178, v180, v182, v184, v186, v188, v190, v192, v193, v191, v189, v187, v185, v183, v181, v179, v177, v175, v173, v171, v169, v167, v165, v163]
+    }
+
+    #[inline(always)]
+    pub fn iadst8(x: [$t; 8]) -> [$t; 8] {
+        let v0 = x[7].wrapping_mul(1606).wrapping_add(x[0].wrapping_mul(-16305));
+        let v1 = x[7].wrapping_mul(16305).wrapping_add(x[0].wrapping_mul(1606));
+        let v2 = x[5].wrapping_mul(7723).wrapping_add(x[2].wrapping_mul(-14449));
+        let v3 = x[5].wrapping_mul(14449).wrapping_add(x[2].wrapping_mul(7723));
+        let v4 = x[3].wrapping_mul(12665).wrapping_add(x[4].wrapping_mul(-10394));
+        let v5 = x[3].wrapping_mul(10394).wrapping_add(x[4].wrapping_mul(12665));
+        let v6 = x[1].wrapping_mul(15679).wrapping_add(x[6].wrapping_mul(-4756));
+        let v7 = x[1].wrapping_mul(4756).wrapping_add(x[6].wrapping_mul(15679));
+        let v8 = r14(v1.wrapping_add(v5));
+        let v9 = r14(v1.wrapping_sub(v5));
+        let v10 = r14(v0.wrapping_add(v4));
+        let v11 = r14(v0.wrapping_sub(v4));
+        let v12 = r14(v3.wrapping_add(v7));
+        let v13 = r14(v3.wrapping_sub(v7));
+        let v14 = r14(v2.wrapping_add(v6));
+        let v15 = r14(v2.wrapping_sub(v6));
+        let v16 = v9.wrapping_mul(6270).wrapping_add(v11.wrapping_mul(-15137));
+        let v17 = v9.wrapping_mul(15137).wrapping_add(v11.wrapping_mul(6270));
+        let v18 = v15.wrapping_mul(15137).wrapping_add(v13.wrapping_mul(-6270));
+        let v19 = v15.wrapping_mul(6270).wrapping_add(v13.wrapping_mul(15137));
+        let v20 = r14(v17.wrapping_add(v18));
+        let v21 = r14(v17.wrapping_sub(v18));
+        let v22 = r14(v16.wrapping_add(v19));
+        let v23 = r14(v16.wrapping_sub(v19));
+        let v24 = v8.wrapping_add(v12);
+        let v25 = v8.wrapping_sub(v12);
+        let v26 = v10.wrapping_add(v14);
+        let v27 = v10.wrapping_sub(v14);
+        let v28 = r14(v25.wrapping_mul(11585).wrapping_add(v27.wrapping_mul(-11585)));
+        let v29 = r14(v25.wrapping_mul(11585).wrapping_add(v27.wrapping_mul(11585)));
+        let v30 = r14(v21.wrapping_mul(11585).wrapping_add(v23.wrapping_mul(-11585)));
+        let v31 = r14(v21.wrapping_mul(11585).wrapping_add(v23.wrapping_mul(11585)));
+        let v32 = v20.wrapping_neg();
+        let v33 = v29.wrapping_neg();
+        let v34 = v30.wrapping_neg();
+        let v35 = v26.wrapping_neg();
+        [v24, v32, v31, v33, v28, v34, v22, v35]
+    }
+
+    #[inline(always)]
+    pub fn iadst16(x: [$t; 16]) -> [$t; 16] {
+        let v0 = x[15].wrapping_mul(804).wrapping_add(x[0].wrapping_mul(-16364));
+        let v1 = x[15].wrapping_mul(16364).wrapping_add(x[0].wrapping_mul(804));
+        let v2 = x[13].wrapping_mul(3981).wrapping_add(x[2].wrapping_mul(-15893));
+        let v3 = x[13].wrapping_mul(15893).wrapping_add(x[2].wrapping_mul(3981));
+        let v4 = x[11].wrapping_mul(7005).wrapping_add(x[4].wrapping_mul(-14811));
+        let v5 = x[11].wrapping_mul(14811).wrapping_add(x[4].wrapping_mul(7005));
+        let v6 = x[9].wrapping_mul(9760).wrapping_add(x[6].wrapping_mul(-13160));
+        let v7 = x[9].wrapping_mul(13160).wrapping_add(x[6].wrapping_mul(9760));
+        let v8 = x[7].wrapping_mul(12140).wrapping_add(x[8].wrapping_mul(-11003));
+        let v9 = x[7].wrapping_mul(11003).wrapping_add(x[8].wrapping_mul(12140));
+        let v10 = x[5].wrapping_mul(14053).wrapping_add(x[10].wrapping_mul(-8423));
+        let v11 = x[5].wrapping_mul(8423).wrapping_add(x[10].wrapping_mul(14053));
+        let v12 = x[3].wrapping_mul(15426).wrapping_add(x[12].wrapping_mul(-5520));
+        let v13 = x[3].wrapping_mul(5520).wrapping_add(x[12].wrapping_mul(15426));
+        let v14 = x[1].wrapping_mul(16207).wrapping_add(x[14].wrapping_mul(-2404));
+        let v15 = x[1].wrapping_mul(2404).wrapping_add(x[14].wrapping_mul(16207));
+        let v16 = r14(v1.wrapping_add(v9));
+        let v17 = r14(v1.wrapping_sub(v9));
+        let v18 = r14(v0.wrapping_add(v8));
+        let v19 = r14(v0.wrapping_sub(v8));
+        let v20 = r14(v3.wrapping_add(v11));
+        let v21 = r14(v3.wrapping_sub(v11));
+        let v22 = r14(v2.wrapping_add(v10));
+        let v23 = r14(v2.wrapping_sub(v10));
+        let v24 = r14(v5.wrapping_add(v13));
+        let v25 = r14(v5.wrapping_sub(v13));
+        let v26 = r14(v4.wrapping_add(v12));
+        let v27 = r14(v4.wrapping_sub(v12));
+        let v28 = r14(v7.wrapping_add(v15));
+        let v29 = r14(v7.wrapping_sub(v15));
+        let v30 = r14(v6.wrapping_add(v14));
+        let v31 = r14(v6.wrapping_sub(v14));
+        let v32 = v17.wrapping_mul(3196).wrapping_add(v19.wrapping_mul(-16069));
+        let v33 = v17.wrapping_mul(16069).wrapping_add(v19.wrapping_mul(3196));
+        let v34 = v21.wrapping_mul(13623).wrapping_add(v23.wrapping_mul(-9102));
+        let v35 = v21.wrapping_mul(9102).wrapping_add(v23.wrapping_mul(13623));
+        let v36 = v25.wrapping_mul(16069).wrapping_add(v27.wrapping_mul(3196));
+        let v37 = v25.wrapping_mul(-3196).wrapping_add(v27.wrapping_mul(16069));
+        let v38 = v29.wrapping_mul(9102).wrapping_add(v31.wrapping_mul(13623));
+        let v39 = v29.wrapping_mul(-13623).wrapping_add(v31.wrapping_mul(9102));
+        let v40 = r14(v33.wrapping_add(v37));
+        let v41 = r14(v33.wrapping_sub(v37));
+        let v42 = r14(v32.wrapping_add(v36));
+        let v43 = r14(v32.wrapping_sub(v36));
+        let v44 = r14(v35.wrapping_add(v39));
+        let v45 = r14(v35.wrapping_sub(v39));
+        let v46 = r14(v34.wrapping_add(v38));
+        let v47 = r14(v34.wrapping_sub(v38));
+        let v48 = v16.wrapping_add(v24);
+        let v49 = v16.wrapping_sub(v24);
+        let v50 = v18.wrapping_add(v26);
+        let v51 = v18.wrapping_sub(v26);
+        let v52 = v20.wrapping_add(v28);
+        let v53 = v20.wrapping_sub(v28);
+        let v54 = v22.wrapping_add(v30);
+        let v55 = v22.wrapping_sub(v30);
+        let v56 = v49.wrapping_mul(6270).wrapping_add(v51.wrapping_mul(-15137));
+        let v57 = v49.wrapping_mul(15137).wrapping_add(v51.wrapping_mul(6270));
+        let v58 = v55.wrapping_mul(15137).wrapping_add(v53.wrapping_mul(-6270));
+        let v59 = v55.wrapping_mul(6270).wrapping_add(v53.wrapping_mul(15137));
+        let v60 = v41.wrapping_mul(6270).wrapping_add(v43.wrapping_mul(-15137));
+        let v61 = v41.wrapping_mul(15137).wrapping_add(v43.wrapping_mul(6270));
+        let v62 = v47.wrapping_mul(15137).wrapping_add(v45.wrapping_mul(-6270));
+        let v63 = v47.wrapping_mul(6270).wrapping_add(v45.wrapping_mul(15137));
+        let v64 = r14(v57.wrapping_add(v58));
+        let v65 = r14(v57.wrapping_sub(v58));
+        let v66 = r14(v61.wrapping_add(v62));
+        let v67 = r14(v61.wrapping_sub(v62));
+        let v68 = r14(v56.wrapping_add(v59));
+        let v69 = r14(v56.wrapping_sub(v59));
+        let v70 = r14(v60.wrapping_add(v63));
+        let v71 = r14(v60.wrapping_sub(v63));
+        let v72 = v48.wrapping_add(v52);
+        let v73 = v48.wrapping_sub(v52);
+        let v74 = v40.wrapping_add(v44);
+        let v75 = v40.wrapping_sub(v44);
+        let v76 = v50.wrapping_add(v54);
+        let v77 = v50.wrapping_sub(v54);
+        let v78 = v42.wrapping_add(v46);
+        let v79 = v42.wrapping_sub(v46);
+        let v80 = r14(v73.wrapping_mul(-11585).wrapping_add(v77.wrapping_mul(-11585)));
+        let v81 = r14(v73.wrapping_mul(11585).wrapping_add(v77.wrapping_mul(-11585)));
+        let v82 = r14(v65.wrapping_mul(11585).wrapping_add(v69.wrapping_mul(11585)));
+        let v83 = r14(v65.wrapping_mul(-11585).wrapping_add(v69.wrapping_mul(11585)));
+        let v84 = r14(v75.wrapping_mul(11585).wrapping_add(v79.wrapping_mul(11585)));
+        let v85 = r14(v75.wrapping_mul(-11585).wrapping_add(v79.wrapping_mul(11585)));
+        let v86 = r14(v67.wrapping_mul(-11585).wrapping_add(v71.wrapping_mul(-11585)));
+        let v87 = r14(v67.wrapping_mul(11585).wrapping_add(v71.wrapping_mul(-11585)));
+        let v88 = v74.wrapping_neg();
+        let v89 = v70.wrapping_neg();
+        let v90 = v64.wrapping_neg();
+        let v91 = v76.wrapping_neg();
+        [v72, v88, v66, v90, v82, v86, v84, v80, v81, v85, v87, v83, v68, v89, v78, v91]
+    }
+
+    };
+}
+
+pub(crate) mod narrow {
+    transforms_1d!(i32);
+}
+
+pub(crate) mod wide {
+    transforms_1d!(i64);
+}
diff --git a/crates/vp9/tests/common/mod.rs b/crates/vp9/tests/common/mod.rs
new file mode 100644
index 000000000..fad515e9d
--- /dev/null
+++ b/crates/vp9/tests/common/mod.rs
@@ -0,0 +1,397 @@
+//! Test fixture generation (ffmpeg + libvpx-vp9 as external encoder and oracle), a tiny IVF
+//! reader, and comparison helpers.
+#![allow(dead_code)]
+
+use filmcraft_vp9::{Decoder, Picture};
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+/// One encoder configuration of the fixture matrix.
+pub struct Fixture {
+    pub name: &'static str,
+    /// lavfi source (without size / rate).
+    pub source: &'static str,
+    pub width: u32,
+    pub height: u32,
+    pub frames: u32,
+    /// Extra video filter appended after the source.
+    pub filter: &'static str,
+    /// Pixel format of the encode (and of the reference decode).
+    pub pix_fmt: &'static str,
+    /// libvpx-vp9 arguments.
+    pub args: &'static [&'static str],
+}
+
+const NOISE: &str = "noise=alls=10:allf=t+u";
+
+macro_rules! fx {
+    ($name:expr, $src:expr, $w:expr, $h:expr, $n:expr, $filter:expr, $pf:expr, [$($a:expr),* $(,)?]) => {
+        Fixture { name: $name, source: $src, width: $w, height: $h, frames: $n, filter: $filter, pix_fmt: $pf, args: &[$($a),*] }
+    };
+}
+
+const P420: &str = "yuv420p";
+const P420_10: &str = "yuv420p10le";
+
+pub const FIXTURES: &[Fixture] = &[
+    fx!("intra_only_keyframes", "testsrc2", 352, 288, 3, NOISE, P420, ["-g", "1", "-b:v", "1M"]),
+    fx!("default_good", "testsrc2", 352, 288, 20, NOISE, P420, ["-b:v", "800k", "-frame-parallel", "0"]),
+    fx!("profile2_10bit", "testsrc2", 352, 288, 12, NOISE, P420_10, ["-b:v", "800k", "-profile:v", "2", "-frame-parallel", "0"]),
+    fx!("profile2_12bit", "mandelbrot", 176, 144, 8, NOISE, "yuv420p12le", ["-b:v", "500k", "-profile:v", "2", "-frame-parallel", "0"]),
+    fx!("profile1_444", "testsrc2", 176, 144, 8, NOISE, "yuv444p", ["-b:v", "500k", "-profile:v", "1", "-frame-parallel", "0"]),
+    fx!("profile1_422", "testsrc2", 176, 144, 8, NOISE, "yuv422p", ["-b:v", "500k", "-profile:v", "1", "-frame-parallel", "0"]),
+    fx!("profile1_440", "testsrc2", 176, 144, 8, NOISE, "yuv440p", ["-b:v", "500k", "-profile:v", "1", "-frame-parallel", "0"]),
+    fx!("profile3_444_10bit", "testsrc2", 176, 144, 6, NOISE, "yuv444p10le", ["-b:v", "500k", "-profile:v", "3", "-frame-parallel", "0"]),
+    fx!("profile3_422_12bit", "mandelbrot", 176, 144, 6, NOISE, "yuv422p12le", ["-b:v", "500k", "-profile:v", "3", "-frame-parallel", "0"]),
+    fx!("lossless", "testsrc2", 176, 144, 5, NOISE, P420, ["-lossless", "1", "-frame-parallel", "0"]),
+    fx!("lossless_10bit", "mandelbrot", 176, 144, 4, NOISE, P420_10, ["-lossless", "1", "-profile:v", "2", "-frame-parallel", "0"]),
+    fx!("tiles_cols4", "testsrc2", 1280, 720, 6, NOISE, P420, ["-b:v", "2M", "-tile-columns", "2", "-speed", "4", "-frame-parallel", "0"]),
+    fx!(
+        "tiles_rows_cols",
+        "testsrc2",
+        1280,
+        720,
+        6,
+        NOISE,
+        P420,
+        ["-b:v", "2M", "-tile-columns", "1", "-tile-rows", "2", "-speed", "4", "-frame-parallel", "0"]
+    ),
+    fx!("tiles_rows4", "testsrc2", 640, 480, 5, NOISE, P420, ["-b:v", "1M", "-tile-columns", "0", "-tile-rows", "2", "-frame-parallel", "0"]),
+    fx!(
+        "altref_hidden",
+        "testsrc2",
+        352,
+        288,
+        30,
+        NOISE,
+        P420,
+        ["2pass", "-b:v", "600k", "-auto-alt-ref", "1", "-lag-in-frames", "25", "-frame-parallel", "0"]
+    ),
+    fx!(
+        "altref_10bit",
+        "mandelbrot",
+        352,
+        288,
+        24,
+        NOISE,
+        P420_10,
+        ["2pass", "-b:v", "600k", "-profile:v", "2", "-auto-alt-ref", "1", "-lag-in-frames", "16", "-frame-parallel", "0"]
+    ),
+    fx!(
+        "altref_tiles",
+        "testsrc2",
+        1280,
+        720,
+        12,
+        NOISE,
+        P420,
+        ["2pass", "-b:v", "2M", "-auto-alt-ref", "1", "-lag-in-frames", "10", "-tile-columns", "2", "-speed", "2", "-frame-parallel", "0"]
+    ),
+    fx!("frame_parallel", "testsrc2", 352, 288, 16, NOISE, P420, ["-b:v", "600k", "-frame-parallel", "1"]),
+    fx!("error_resilient", "testsrc2", 352, 288, 16, NOISE, P420, ["-b:v", "600k", "-error-resilient", "1"]),
+    fx!("odd_size", "testsrc2", 347, 251, 10, NOISE, P420, ["-b:v", "600k", "-frame-parallel", "0"]),
+    fx!("tiny_odd", "testsrc2", 33, 17, 8, NOISE, P420, ["-b:v", "200k", "-frame-parallel", "0"]),
+    fx!("row_mt", "testsrc2", 640, 360, 10, NOISE, P420, ["-b:v", "1M", "-row-mt", "1", "-tile-columns", "1", "-frame-parallel", "0"]),
+    fx!("speed0", "mandelbrot", 176, 144, 8, NOISE, P420, ["2pass", "-b:v", "300k", "-speed", "0", "-frame-parallel", "0"]),
+    fx!("speed1", "testsrc2", 352, 288, 10, NOISE, P420, ["-b:v", "600k", "-speed", "1", "-frame-parallel", "0"]),
+    fx!("speed2", "testsrc2", 352, 288, 10, NOISE, P420, ["-b:v", "600k", "-speed", "2", "-frame-parallel", "0"]),
+    fx!("speed3", "testsrc2", 352, 288, 10, NOISE, P420, ["-b:v", "600k", "-speed", "3", "-frame-parallel", "0"]),
+    fx!("speed4", "testsrc2", 352, 288, 10, NOISE, P420, ["-b:v", "600k", "-speed", "4", "-frame-parallel", "0"]),
+    fx!("speed5", "testsrc2", 352, 288, 10, NOISE, P420, ["-b:v", "600k", "-speed", "5", "-deadline", "realtime", "-frame-parallel", "0"]),
+    fx!("speed6", "testsrc2", 352, 288, 10, NOISE, P420, ["-b:v", "600k", "-speed", "6", "-deadline", "realtime", "-frame-parallel", "0"]),
+    fx!("speed7", "testsrc2", 352, 288, 10, NOISE, P420, ["-b:v", "600k", "-speed", "7", "-deadline", "realtime", "-frame-parallel", "0"]),
+    fx!("speed8", "testsrc2", 352, 288, 10, NOISE, P420, ["-b:v", "600k", "-speed", "8", "-deadline", "realtime", "-frame-parallel", "0"]),
+    fx!("cq_low", "testsrc2", 352, 288, 8, NOISE, P420, ["-crf", "0", "-b:v", "0", "-frame-parallel", "0"]),
+    fx!("cq_q4", "testsrc2", 352, 288, 8, NOISE, P420, ["-crf", "4", "-b:v", "0", "-frame-parallel", "0"]),
+    fx!("cq_high", "testsrc2", 352, 288, 12, NOISE, P420, ["-crf", "63", "-b:v", "0", "-frame-parallel", "0"]),
+    fx!("cq_10bit_low", "testsrc2", 176, 144, 6, NOISE, P420_10, ["-crf", "2", "-b:v", "0", "-profile:v", "2", "-frame-parallel", "0"]),
+    fx!("cq_12bit_high", "testsrc2", 176, 144, 6, NOISE, "yuv420p12le", ["-crf", "60", "-b:v", "0", "-profile:v", "2", "-frame-parallel", "0"]),
+    fx!("aq_segmentation", "testsrc2", 352, 288, 12, NOISE, P420, ["-b:v", "600k", "-aq-mode", "3", "-frame-parallel", "0"]),
+    fx!("aq_variance", "mandelbrot", 352, 288, 12, NOISE, P420, ["-b:v", "600k", "-aq-mode", "1", "-frame-parallel", "0"]),
+    fx!("aq_complexity", "testsrc2", 352, 288, 12, NOISE, P420, ["2pass", "-b:v", "600k", "-aq-mode", "2", "-frame-parallel", "0"]),
+    fx!("sharpness", "testsrc2", 352, 288, 8, NOISE, P420, ["-b:v", "400k", "-sharpness", "5", "-frame-parallel", "0"]),
+    fx!("fade_intra_heavy", "testsrc2", 352, 288, 20, "fade=in:0:15", P420, ["-b:v", "400k", "-g", "8", "-frame-parallel", "0"]),
+    fx!("hd_1080p", "testsrc2", 1920, 1080, 3, NOISE, P420, ["-b:v", "4M", "-speed", "5", "-deadline", "realtime"]),
+    fx!(
+        "bench_1080p",
+        "testsrc2",
+        1920,
+        1080,
+        60,
+        "noise=alls=3:allf=t",
+        P420,
+        ["-b:v", "4M", "-speed", "4", "-tile-columns", "2", "-row-mt", "1", "-frame-parallel", "0"]
+    ),
+    fx!(
+        "bench_4k",
+        "testsrc2",
+        3840,
+        2160,
+        20,
+        "noise=alls=3:allf=t",
+        P420,
+        ["-b:v", "12M", "-speed", "6", "-tile-columns", "3", "-row-mt", "1", "-frame-parallel", "0"]
+    ),
+];
+
+pub fn fixture(name: &str) -> &'static Fixture {
+    FIXTURES.iter().find(|f| f.name == name).unwrap_or_else(|| panic!("unknown fixture {name}"))
+}
+
+pub fn ffmpeg() -> Option<PathBuf> {
+    for p in ["/opt/homebrew/bin/ffmpeg", "/usr/local/bin/ffmpeg", "/usr/bin/ffmpeg"] {
+        if Path::new(p).exists() {
+            return Some(PathBuf::from(p));
+        }
+    }
+    None
+}
+
+pub fn fixtures_dir() -> PathBuf {
+    let d = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../target/fixtures/vp9");
+    std::fs::create_dir_all(&d).expect("create fixtures dir");
+    d
+}
+
+/// Unique suffix for temporary files: tests run on several threads of one process and may
+/// generate the same fixture concurrently.
+pub fn unique() -> String {
+    static N: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(0);
+    let n = N.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+    format!("{}-{n}", std::process::id())
+}
+
+pub fn run(cmd: &mut Command) -> bool {
+    match cmd.output() {
+        Ok(o) if o.status.success() => true,
+        Ok(o) => {
+            eprintln!("command failed: {:?}\n{}", cmd, String::from_utf8_lossy(&o.stderr));
+            false
+        }
+        Err(e) => {
+            eprintln!("failed to run {:?}: {e}", cmd);
+            false
+        }
+    }
+}
+
+/// Bytes per sample and chroma subsampling of a pixel format.
+pub fn format_info(pix_fmt: &str) -> (usize, u32, u32) {
+    let bps = if pix_fmt.contains("p10") || pix_fmt.contains("p12") { 2 } else { 1 };
+    let (sx, sy) = if pix_fmt.starts_with("yuv420") {
+        (1, 1)
+    } else if pix_fmt.starts_with("yuv422") {
+        (1, 0)
+    } else if pix_fmt.starts_with("yuv440") {
+        (0, 1)
+    } else {
+        (0, 0)
+    };
+    (bps, sx, sy)
+}
+
+/// Reference decode of `ivf` with ffmpeg (native vp9 decoder, every frame, no fps conversion).
+pub fn reference_decode(ivf: &Path, yuv: &Path, pix_fmt: &str) -> bool {
+    let Some(ff) = ffmpeg() else { return false };
+    let tmp = yuv.with_extension(format!("tmp.{}.yuv", unique()));
+    let mut c = Command::new(&ff);
+    c.args(["-hide_banner", "-loglevel", "error", "-y", "-c:v", "vp9", "-i"]).arg(ivf);
+    c.args(["-fps_mode", "passthrough", "-noautoscale", "-f", "rawvideo", "-pix_fmt", pix_fmt]).arg(&tmp);
+    if !run(&mut c) {
+        return false;
+    }
+    std::fs::rename(&tmp, yuv).is_ok() || yuv.exists()
+}
+
+/// Generate (if needed) the fixture stream and its ffmpeg reference decode.
+pub fn ensure(f: &Fixture) -> Option<(PathBuf, PathBuf)> {
+    let Some(ff) = ffmpeg() else {
+        eprintln!("SKIP {}: ffmpeg not found", f.name);
+        return None;
+    };
+    let dir = fixtures_dir();
+    let ivf = dir.join(format!("{}.ivf", f.name));
+    let yuv = dir.join(format!("{}.yuv", f.name));
+    if !ivf.exists() {
+        let tmp = dir.join(format!("{}.tmp.{}.ivf", f.name, unique()));
+        let mut vf = format!("{}=size={}x{}:rate=25,format={}", f.source, f.width, f.height, f.pix_fmt);
+        if !f.filter.is_empty() {
+            vf.push(',');
+            vf.push_str(f.filter);
+        }
+        let two_pass = f.args.first() == Some(&"2pass");
+        let args: Vec<&str> = f.args.iter().copied().filter(|a| *a != "2pass").collect();
+        let log = dir.join(format!("{}.{}.passlog", f.name, unique()));
+        let enc = |pass: Option<u32>, out: &Path| {
+            let mut c = Command::new(&ff);
+            c.args(["-hide_banner", "-loglevel", "error", "-y", "-f", "lavfi", "-i", &vf]);
+            c.args(["-frames:v", &f.frames.to_string(), "-c:v", "libvpx-vp9", "-pix_fmt", f.pix_fmt]);
+            c.args(&args);
+            if let Some(p) = pass {
+                c.args(["-pass", &p.to_string(), "-passlogfile"]).arg(&log);
+            }
+            if pass == Some(1) {
+                c.args(["-f", "null", "-"]);
+            } else {
+                c.args(["-f", "ivf"]).arg(out);
+            }
+            c
+        };
+        if two_pass && !run(&mut enc(Some(1), &tmp)) {
+            eprintln!("SKIP {}: first pass failed", f.name);
+            return None;
+        }
+        let mut c = enc(if two_pass { Some(2) } else { None }, &tmp);
+        if !run(&mut c) {
+            let _ = std::fs::remove_file(&tmp);
+            eprintln!("SKIP {}: libvpx-vp9 encode failed", f.name);
+            return None;
+        }
+        let _ = std::fs::remove_file(format!("{}-0.log", log.display()));
+        if std::fs::rename(&tmp, &ivf).is_err() && !ivf.exists() {
+            panic!("could not store fixture {}", ivf.display());
+        }
+    }
+    if !yuv.exists() {
+        assert!(reference_decode(&ivf, &yuv, f.pix_fmt), "reference decode failed for {}", f.name);
+    }
+    Some((ivf, yuv))
+}
+
+/// Frames of an IVF file (32-byte file header, then 12-byte frame headers).
+pub fn ivf_frames(data: &[u8]) -> Vec<&[u8]> {
+    let mut out = Vec::new();
+    if data.len() < 32 || &data[..4] != b"DKIF" {
+        return out;
+    }
+    let hl = u16::from_le_bytes([data[6], data[7]]) as usize;
+    let mut p = hl.max(32);
+    while p + 12 <= data.len() {
+        let sz = u32::from_le_bytes(data[p..p + 4].try_into().unwrap()) as usize;
+        p += 12;
+        if p + sz > data.len() {
+            break;
+        }
+        out.push(&data[p..p + sz]);
+        p += sz;
+    }
+    out
+}
+
+/// Write an IVF file.
+pub fn write_ivf(path: &Path, w: u16, h: u16, frames: &[Vec<u8>]) {
+    let mut d = Vec::new();
+    d.extend(b"DKIF");
+    d.extend(0u16.to_le_bytes());
+    d.extend(32u16.to_le_bytes());
+    d.extend(b"VP90");
+    d.extend(w.to_le_bytes());
+    d.extend(h.to_le_bytes());
+    d.extend(25u32.to_le_bytes());
+    d.extend(1u32.to_le_bytes());
+    d.extend((frames.len() as u32).to_le_bytes());
+    d.extend(0u32.to_le_bytes());
+    for (i, f) in frames.iter().enumerate() {
+        d.extend((f.len() as u32).to_le_bytes());
+        d.extend((i as u64).to_le_bytes());
+        d.extend(f);
+    }
+    std::fs::write(path, d).unwrap();
+}
+
+pub type DecodeFailure = (usize, filmcraft_vp9::Error, Vec<Picture>);
+
+/// Decode an IVF file with `threads` workers (0 = default), pts = frame index.
+pub fn decode_file_threads(path: &Path, threads: usize) -> Result<Vec<Picture>, DecodeFailure> {
+    let data = std::fs::read(path).unwrap();
+    let mut dec = if threads == 0 { Decoder::new() } else { Decoder::with_threads(threads) };
+    let mut out = Vec::new();
+    for (i, f) in ivf_frames(&data).into_iter().enumerate() {
+        match dec.decode(f, i as i64) {
+            Ok(p) => out.extend(p),
+            Err(e) => return Err((i, e, out)),
+        }
+    }
+    out.extend(dec.flush());
+    Ok(out)
+}
+
+/// Frame size in bytes of a raw picture.
+pub fn raw_size(w: usize, h: usize, pix_fmt: &str) -> usize {
+    let (bps, sx, sy) = format_info(pix_fmt);
+    let (cw, ch) = ((w + sx as usize) >> sx, (h + sy as usize) >> sy);
+    (w * h + 2 * cw * ch) * bps
+}
+
+/// Compare decoded pictures with a raw reference with frames of possibly varying sizes (sizes
+/// are taken from the decoded pictures). Reports the first mismatch.
+pub fn compare(pics: &[Picture], reference: &[u8], pix_fmt: &str) -> Result<(), String> {
+    let (bps, _, _) = format_info(pix_fmt);
+    let mut off = 0usize;
+    for (i, p) in pics.iter().enumerate() {
+        let (w, h) = (p.width as usize, p.height as usize);
+        let (cw, ch) = (p.chroma_width as usize, p.chroma_height as usize);
+        let fsize = raw_size(w, h, pix_fmt);
+        if off + fsize > reference.len() {
+            return Err(format!("decoder produced {} frames, reference has fewer (at frame {i})", pics.len()));
+        }
+        let f = &reference[off..off + fsize];
+        off += fsize;
+        let sample = |buf: &[u8], k: usize| if bps == 2 { u16::from_le_bytes([buf[2 * k], buf[2 * k + 1]]) } else { buf[k] as u16 };
+        let (ys, cs) = (w * h * bps, cw * ch * bps);
+        let planes = [("Y", &p.y, &f[..ys], w, h), ("U", &p.u, &f[ys..ys + cs], cw, ch), ("V", &p.v, &f[ys + cs..], cw, ch)];
+        for (name, got, exp, pw, ph) in planes {
+            let mut first = None;
+            let mut count = 0usize;
+            let mut maxd = 0i32;
+            for y in 0..ph {
+                for x in 0..pw {
+                    let (a, b) = (got.get(y * pw + x), sample(exp, y * pw + x));
+                    if a != b {
+                        count += 1;
+                        maxd = maxd.max((a as i32 - b as i32).abs());
+                        if first.is_none() {
+                            first = Some((x, y, a, b));
+                        }
+                    }
+                }
+            }
+            if let Some((x, y, a, b)) = first {
+                return Err(format!(
+                    "frame {i} (pts {}, {w}x{h}) plane {name}: first mismatch at ({x},{y}) [SB64 of luma ~({},{})]: got {a} want {b}; {count} samples differ, max diff {maxd}",
+                    p.pts,
+                    x / 64,
+                    y / 64
+                ));
+            }
+        }
+    }
+    if off != reference.len() {
+        return Err(format!("decoder produced {} frames, reference has more data", pics.len()));
+    }
+    Ok(())
+}
+
+/// Per-frame MD5-like digest is not needed: comparison is sample exact. Full check of one
+/// fixture: generate, decode (single- and multi-threaded), compare. Ok(false) when skipped.
+pub fn check_fixture(name: &str) -> Result<bool, String> {
+    let f = fixture(name);
+    let Some((ivf, yuv)) = ensure(f) else { return Ok(false) };
+    let reference = std::fs::read(&yuv).unwrap();
+    check_files(name, &ivf, &reference, f.pix_fmt)?;
+    Ok(true)
+}
+
+pub fn check_files(name: &str, ivf: &Path, reference: &[u8], pix_fmt: &str) -> Result<(), String> {
+    for threads in [1, 0] {
+        let pics = match decode_file_threads(ivf, threads) {
+            Ok(p) => p,
+            Err((fr, e, partial)) => {
+                let cmp = compare(&partial, reference, pix_fmt).err().unwrap_or_default();
+                return Err(format!("{name} (threads {threads}): decode error at chunk {fr}: {e} (after {} pictures) {cmp}", partial.len()));
+            }
+        };
+        compare(&pics, reference, pix_fmt).map_err(|e| format!("{name} (threads {threads}): {e}"))?;
+    }
+    Ok(())
+}
diff --git a/crates/vp9/tests/conformance.rs b/crates/vp9/tests/conformance.rs
new file mode 100644
index 000000000..dd90b10d2
--- /dev/null
+++ b/crates/vp9/tests/conformance.rs
@@ -0,0 +1,141 @@
+//! Bit-exactness against ffmpeg's VP9 decoder on libvpx-vp9 fixtures (skipped when ffmpeg or
+//! libvpx is absent).
+
+mod common;
+
+macro_rules! fixture_tests {
+    ($($name:ident),* $(,)?) => {
+        $(
+            #[test]
+            fn $name() {
+                match common::check_fixture(stringify!($name)) {
+                    Ok(true) => {}
+                    Ok(false) => eprintln!("skipped {}", stringify!($name)),
+                    Err(e) => panic!("{e}"),
+                }
+            }
+        )*
+    };
+}
+
+fixture_tests!(
+    intra_only_keyframes,
+    default_good,
+    profile2_10bit,
+    profile2_12bit,
+    profile1_444,
+    profile1_422,
+    profile1_440,
+    profile3_444_10bit,
+    profile3_422_12bit,
+    lossless,
+    lossless_10bit,
+    tiles_cols4,
+    tiles_rows_cols,
+    tiles_rows4,
+    altref_hidden,
+    altref_10bit,
+    altref_tiles,
+    frame_parallel,
+    error_resilient,
+    odd_size,
+    tiny_odd,
+    row_mt,
+    speed0,
+    speed1,
+    speed2,
+    speed3,
+    speed4,
+    speed5,
+    speed6,
+    speed7,
+    speed8,
+    cq_low,
+    cq_q4,
+    cq_high,
+    cq_10bit_low,
+    cq_12bit_high,
+    aq_segmentation,
+    aq_variance,
+    aq_complexity,
+    sharpness,
+    fade_intra_heavy,
+    hd_1080p,
+);
+
+/// Two streams of different sizes concatenated into one IVF (key frame at the size change).
+#[test]
+fn resize_concatenated() {
+    let a = common::fixture("default_good");
+    let b = common::fixture("odd_size");
+    let (Some((ia, ya)), Some((ib, yb))) = (common::ensure(a), common::ensure(b)) else { return };
+    let da = std::fs::read(ia).unwrap();
+    let db = std::fs::read(ib).unwrap();
+    let mut frames: Vec<Vec<u8>> = common::ivf_frames(&da).into_iter().map(|f| f.to_vec()).collect();
+    frames.extend(common::ivf_frames(&db).into_iter().map(|f| f.to_vec()));
+    let path = common::fixtures_dir().join("resize_concat.ivf");
+    common::write_ivf(&path, 352, 288, &frames);
+    let mut reference = std::fs::read(ya).unwrap();
+    reference.extend(std::fs::read(yb).unwrap());
+    common::check_files("resize_concat", &path, &reference, "yuv420p").unwrap();
+}
+
+/// Print which coding tools each fixture exercises (run with `-- --ignored --nocapture`).
+#[test]
+#[ignore]
+fn coverage_report() {
+    for f in common::FIXTURES {
+        let Some((ivf, _)) = common::ensure(f) else { continue };
+        let data = std::fs::read(ivf).unwrap();
+        let mut dec = filmcraft_vp9::Decoder::new();
+        for fr in common::ivf_frames(&data) {
+            let _ = dec.decode(fr, 0);
+        }
+        println!("{:<22} {:?}", f.name, dec.stats());
+    }
+}
+
+/// The comparison must report a single flipped sample (guards against a vacuous harness).
+#[test]
+fn compare_detects_mismatch() {
+    let f = common::fixture("intra_only_keyframes");
+    let Some((ivf, yuv)) = common::ensure(f) else { return };
+    let pics = common::decode_file_threads(&ivf, 1).map_err(|e| e.1).unwrap();
+    let mut reference = std::fs::read(yuv).unwrap();
+    common::compare(&pics, &reference, f.pix_fmt).unwrap();
+    let pos = reference.len() - 7;
+    reference[pos] ^= 1;
+    let err = common::compare(&pics, &reference, f.pix_fmt).unwrap_err();
+    assert!(err.contains("plane V"), "{err}");
+}
+
+/// Key frame detection (random access points) and decoder reset: decoding again from the
+/// second key frame after `reset` gives the same pictures as the uninterrupted decode.
+#[test]
+fn keyframes_and_reset() {
+    let f = common::fixture("fade_intra_heavy");
+    let Some((ivf, _)) = common::ensure(f) else { return };
+    let data = std::fs::read(ivf).unwrap();
+    let chunks = common::ivf_frames(&data);
+    let keys: Vec<usize> = (0..chunks.len()).filter(|&i| filmcraft_vp9::is_keyframe(chunks[i])).collect();
+    assert_eq!(keys.first(), Some(&0));
+    assert!(keys.len() >= 2, "key frames {keys:?}");
+    let info = filmcraft_vp9::keyframe_info(chunks[0]).unwrap();
+    assert_eq!((info.width, info.height, info.bit_depth), (f.width, f.height, 8));
+    assert!(info.subsampling_x && info.subsampling_y);
+    let mut dec = filmcraft_vp9::Decoder::with_threads(1);
+    let mut all = Vec::new();
+    for (i, c) in chunks.iter().enumerate() {
+        all.extend(dec.decode(c, i as i64).unwrap());
+    }
+    // Garbage in between, then a reset and a restart at the second key frame.
+    let _ = dec.decode(&[0x82, 0x49, 0x83, 0x42, 0x00], 0);
+    dec.reset();
+    let k = keys[1];
+    for (i, c) in chunks.iter().enumerate().skip(k) {
+        for p in dec.decode(c, i as i64).unwrap() {
+            let want = all.iter().find(|q| q.pts == p.pts).unwrap();
+            assert!(p.y == want.y && p.u == want.u && p.v == want.v, "picture {} differs after reset", p.pts);
+        }
+    }
+}
diff --git a/crates/vp9/tests/perf.rs b/crates/vp9/tests/perf.rs
new file mode 100644
index 000000000..a705ad465
--- /dev/null
+++ b/crates/vp9/tests/perf.rs
@@ -0,0 +1,47 @@
+//! Decode speed (ignored by default; run with
+//! `cargo test --release -p filmcraft-vp9 --test perf -- --ignored --nocapture`).
+
+mod common;
+
+use filmcraft_vp9::Decoder;
+use std::time::Instant;
+
+fn bench(frames: &[&[u8]], threads: usize, iters: usize) -> (usize, f64) {
+    let mut best = f64::MAX;
+    let mut n = 0;
+    for _ in 0..iters {
+        let mut dec = Decoder::with_threads(threads);
+        let t0 = Instant::now();
+        n = 0;
+        for f in frames {
+            n += dec.decode(f, 0).expect("decode").len();
+        }
+        best = best.min(t0.elapsed().as_secs_f64());
+    }
+    (n, best)
+}
+
+fn run(name: &str, label: &str) {
+    let f = common::fixture(name);
+    let Some((ivf, _)) = common::ensure(f) else { return };
+    common::check_fixture(name).unwrap();
+    let data = std::fs::read(ivf).unwrap();
+    let frames = common::ivf_frames(&data);
+    let cores = std::thread::available_parallelism().map(|n| n.get()).unwrap_or(1);
+    for threads in [1, cores.min(16)] {
+        let (n, secs) = bench(&frames, threads, 3);
+        println!("{label} ({} KB): {threads} thread(s): {n} frames in {secs:.3}s = {:.1} fps", data.len() / 1024, n as f64 / secs);
+    }
+}
+
+#[test]
+#[ignore]
+fn perf_1080p() {
+    run("bench_1080p", "1080p 8-bit, 4 tile columns");
+}
+
+#[test]
+#[ignore]
+fn perf_4k() {
+    run("bench_4k", "2160p 8-bit, 8 tile columns");
+}
diff --git a/crates/vp9/tests/robustness.rs b/crates/vp9/tests/robustness.rs
new file mode 100644
index 000000000..be63331d9
--- /dev/null
+++ b/crates/vp9/tests/robustness.rs
@@ -0,0 +1,106 @@
+//! Damaged, truncated and random input must never panic or hang (errors are fine).
+
+mod common;
+
+use filmcraft_vp9::Decoder;
+use std::time::{Duration, Instant};
+
+fn xorshift(seed: &mut u64) -> u64 {
+    *seed ^= *seed << 13;
+    *seed ^= *seed >> 7;
+    *seed ^= *seed << 17;
+    *seed
+}
+
+fn decode_all(frames: &[Vec<u8>], threads: usize) {
+    let mut dec = Decoder::with_threads(threads);
+    for (i, f) in frames.iter().enumerate() {
+        let _ = dec.decode(f, i as i64);
+    }
+    let _ = dec.flush();
+}
+
+#[test]
+fn corrupted_streams_do_not_panic() {
+    for name in ["default_good", "altref_hidden", "profile2_10bit", "tiles_cols4", "aq_segmentation", "lossless", "profile1_444", "tiles_rows4"] {
+        let f = common::fixture(name);
+        let Some((ivf, _)) = common::ensure(f) else { return };
+        let data = std::fs::read(ivf).unwrap();
+        let frames: Vec<Vec<u8>> = common::ivf_frames(&data).into_iter().map(|f| f.to_vec()).collect();
+        let mut seed = 0x1234_5678_9abc_def0u64 ^ name.len() as u64;
+        for round in 0..10 {
+            let t0 = Instant::now();
+            let mut d = frames.clone();
+            for _ in 0..(1 + round * 4) {
+                let fi = (xorshift(&mut seed) as usize) % d.len();
+                let fr = &mut d[fi];
+                if fr.is_empty() {
+                    continue;
+                }
+                let pos = (xorshift(&mut seed) as usize) % fr.len();
+                match round % 3 {
+                    0 => fr[pos] ^= 1 << (xorshift(&mut seed) % 8),
+                    1 => fr[pos] = xorshift(&mut seed) as u8,
+                    _ => fr.truncate(pos),
+                }
+            }
+            for threads in [1, 4] {
+                decode_all(&d, threads);
+            }
+            assert!(t0.elapsed() < Duration::from_secs(60), "{name} round {round} too slow");
+        }
+    }
+}
+
+#[test]
+fn truncated_frames_do_not_panic() {
+    let f = common::fixture("default_good");
+    let Some((ivf, _)) = common::ensure(f) else { return };
+    let data = std::fs::read(ivf).unwrap();
+    let frames: Vec<Vec<u8>> = common::ivf_frames(&data).into_iter().map(|f| f.to_vec()).collect();
+    for cut in [1usize, 2, 3, 5, 8, 13, 21, 40, 100, 400] {
+        let d: Vec<Vec<u8>> = frames.iter().map(|f| f[..cut.min(f.len())].to_vec()).collect();
+        decode_all(&d, 1);
+        decode_all(&d, 3);
+    }
+}
+
+#[test]
+fn garbage_input_is_rejected_gracefully() {
+    let mut seed = 42u64;
+    for len in [0usize, 1, 2, 5, 30, 100, 5000] {
+        for k in 0..40 {
+            let mut g: Vec<u8> = (0..len).map(|_| xorshift(&mut seed) as u8).collect();
+            if len > 10 && k % 2 == 0 {
+                // A plausible key frame start: frame marker, profile 0, key frame, sync code.
+                g[0] = 0x82;
+                g[1] = 0x49;
+                g[2] = 0x83;
+                g[3] = 0x42;
+            }
+            let mut dec = Decoder::with_threads(1 + k % 3);
+            let _ = dec.decode(&g, 0);
+            let _ = dec.decode(&g, 1);
+        }
+    }
+    // Inter frame / show_existing without references.
+    let mut dec = Decoder::new();
+    assert!(dec.decode(&[0x88], 0).is_err());
+    assert!(dec.decode(&[0x86, 0, 0, 0, 0], 0).is_err());
+}
+
+/// Huge declared frame sizes must not allocate absurd amounts or panic.
+#[test]
+fn oversized_frame_is_rejected() {
+    // Key frame header: marker 2, profile 0, show_existing 0, key, show, no error res,
+    // sync, color (4 bits), width-1 = 0xffff, height-1 = 0xffff.
+    let bits = "10".to_string() + "00" + "0" + "0" + "1" + "0" + "010010011000001101000010" + "0000" + &"1".repeat(32);
+    let mut v = vec![0u8; bits.len().div_ceil(8) + 8];
+    for (i, c) in bits.chars().enumerate() {
+        if c == '1' {
+            v[i / 8] |= 0x80 >> (i % 8);
+        }
+    }
+    let mut dec = Decoder::new();
+    assert!(dec.decode(&v, 0).is_err());
+}
diff --git a/crates/vp9/tests/synthetic.rs b/crates/vp9/tests/synthetic.rs
new file mode 100644
index 000000000..a01c7a1b8
--- /dev/null
+++ b/crates/vp9/tests/synthetic.rs
@@ -0,0 +1,357 @@
+//! Streams libvpx (as driven by ffmpeg) does not produce, built by rewriting the uncompressed
+//! headers of libvpx-vp9 output, all checked against ffmpeg's decoder:
+//! - reference scaling: inter frames of a stream encoded at another size are spliced after a key
+//!   frame, with their frame size coded explicitly, so they predict from differently sized
+//!   references (down- and up-scaling);
+//! - intra-only frames (a key frame rewritten as a hidden intra-only frame) shown with
+//!   show_existing_frame;
+//! - show_existing_frame of hidden alt-ref frames and of arbitrary slots.
+
+mod common;
+
+use std::path::Path;
+
+struct Bits<'a> {
+    d: &'a [u8],
+    pos: usize,
+}
+
+impl Bits<'_> {
+    fn f(&mut self, n: usize) -> u32 {
+        let mut v = 0;
+        for _ in 0..n {
+            v = (v << 1) | ((self.d[self.pos / 8] >> (7 - self.pos % 8)) & 1) as u32;
+            self.pos += 1;
+        }
+        v
+    }
+}
+
+#[derive(Default)]
+struct W {
+    bits: Vec<bool>,
+}
+
+impl W {
+    fn put(&mut self, v: u32, n: usize) {
+        for i in (0..n).rev() {
+            self.bits.push((v >> i) & 1 == 1);
+        }
+    }
+    fn copy(&mut self, d: &[u8], from: usize, to: usize) {
+        let mut b = Bits { d, pos: from };
+        for _ in from..to {
+            self.bits.push(b.f(1) == 1);
+        }
+    }
+    fn bytes(&self) -> Vec<u8> {
+        let mut out = vec![0u8; self.bits.len().div_ceil(8)];
+        for (i, &b) in self.bits.iter().enumerate() {
+            if b {
+                out[i / 8] |= 0x80 >> (i % 8);
+            }
+        }
+        out
+    }
+}
+
+/// Parse the header fields from refresh_frame_context to header_size_in_bytes (profile 0
+/// layouts); returns the bit position after header_size_in_bytes.
+fn parse_tail(b: &mut Bits, error_res: bool, width: u32) -> usize {
+    if !error_res {
+        b.f(2);
+    }
+    b.f(2); // frame_context_idx
+    b.f(6);
+    b.f(3);
+    if b.f(1) == 1 && b.f(1) == 1 {
+        for _ in 0..6 {
+            if b.f(1) == 1 {
+                b.f(7);
+            }
+        }
+    }
+    b.f(8);
+    for _ in 0..3 {
+        if b.f(1) == 1 {
+            b.f(5);
+        }
+    }
+    if b.f(1) == 1 {
+        if b.f(1) == 1 {
+            for _ in 0..7 {
+                if b.f(1) == 1 {
+                    b.f(8);
+                }
+            }
+            if b.f(1) == 1 {
+                for _ in 0..3 {
+                    if b.f(1) == 1 {
+                        b.f(8);
+                    }
+                }
+            }
+        }
+        if b.f(1) == 1 {
+            b.f(1);
+            for _ in 0..8 {
+                for (bits, signed) in [(8, true), (6, true), (2, false), (0, false)] {
+                    if b.f(1) == 1 {
+                        b.f(bits);
+                        if signed {
+                            b.f(1);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    let sb_cols = (width.div_ceil(8)).div_ceil(8);
+    let mut min_log2 = 0;
+    while (64 << min_log2) < sb_cols {
+        min_log2 += 1;
+    }
+    let mut max_log2 = 1;
+    while (sb_cols >> max_log2) >= 4 {
+        max_log2 += 1;
+    }
+    max_log2 -= 1;
+    let mut l = min_log2;
+    while l < max_log2 {
+        if b.f(1) == 1 {
+            l += 1;
+        } else {
+            break;
+        }
+    }
+    if b.f(1) == 1 {
+        b.f(1);
+    }
+    b.f(16);
+    b.pos
+}
+
+/// Rewrite a profile 0 inter frame so that its frame size (`w` x `h`) is coded explicitly.
+fn explicit_size(frame: &[u8], w: u32, h: u32) -> Vec<u8> {
+    let mut b = Bits { d: frame, pos: 0 };
+    assert_eq!(b.f(2), 2);
+    assert_eq!(b.f(2), 0, "profile 0 only");
+    assert_eq!(b.f(1), 0, "show_existing");
+    assert_eq!(b.f(1), 1, "inter frame expected");
+    let show = b.f(1) == 1;
+    let err = b.f(1) == 1;
+    if !show {
+        assert_eq!(b.f(1), 0, "intra-only");
+    }
+    if !err {
+        b.f(2);
+    }
+    b.f(8 + 12);
+    let found_at = b.pos;
+    let mut found = false;
+    for _ in 0..3 {
+        if b.f(1) == 1 {
+            found = true;
+            break;
+        }
+    }
+    if !found {
+        b.f(32);
+    }
+    let after_size = b.pos;
+    // render_size, allow_high_precision_mv, interpolation filter
+    if b.f(1) == 1 {
+        b.f(32);
+    }
+    b.f(1);
+    if b.f(1) == 0 {
+        b.f(2);
+    }
+    let end = parse_tail(&mut b, err, w);
+    let mut o = W::default();
+    o.copy(frame, 0, found_at);
+    o.put(0, 3);
+    o.put(w - 1, 16);
+    o.put(h - 1, 16);
+    o.copy(frame, after_size, end);
+    let mut out = o.bytes();
+    out.extend_from_slice(&frame[end.div_ceil(8)..]);
+    out
+}
+
+/// Rewrite a profile 0 key frame as a hidden intra-only frame refreshing `refresh` slots.
+fn key_to_intra_only(frame: &[u8], refresh: u8, reset: u32) -> Vec<u8> {
+    let mut b = Bits { d: frame, pos: 0 };
+    assert_eq!(b.f(2), 2);
+    assert_eq!(b.f(2), 0);
+    assert_eq!(b.f(1), 0);
+    assert_eq!(b.f(1), 0, "key frame expected");
+    b.f(1); // show_frame
+    let err = b.f(1) == 1;
+    assert_eq!(b.f(24), 0x498342);
+    b.f(4); // color_space, color_range
+    let size_at = b.pos;
+    let w = b.f(16) + 1;
+    b.f(16);
+    if b.f(1) == 1 {
+        b.f(32);
+    }
+    let after_render = b.pos;
+    let end = parse_tail(&mut b, err, w);
+    let mut o = W::default();
+    o.put(2, 2);
+    o.put(0, 2);
+    o.put(0, 1);
+    o.put(1, 1); // non-key
+    o.put(0, 1); // hidden
+    o.put(err as u32, 1);
+    o.put(1, 1); // intra_only
+    if !err {
+        o.put(reset, 2);
+    }
+    o.put(0x498342, 24);
+    o.put(refresh as u32, 8);
+    o.copy(frame, size_at, after_render);
+    o.copy(frame, after_render, end);
+    let mut out = o.bytes();
+    out.extend_from_slice(&frame[end.div_ceil(8)..]);
+    out
+}
+
+fn reference(ivf: &Path, pix_fmt: &str) -> Vec<u8> {
+    let yuv = ivf.with_extension("yuv");
+    let _ = std::fs::remove_file(&yuv);
+    assert!(common::reference_decode(ivf, &yuv, pix_fmt), "ffmpeg failed on {}", ivf.display());
+    let r = std::fs::read(&yuv).unwrap();
+    let _ = std::fs::remove_file(&yuv);
+    r
+}
+
+fn encode(name: &str, w: u32, h: u32, frames: u32, extra: &[&str]) -> Option<Vec<Vec<u8>>> {
+    let ff = common::ffmpeg()?;
+    let path = common::fixtures_dir().join(format!("{name}.ivf"));
+    if !path.exists() {
+        let mut c = std::process::Command::new(ff);
+        c.args(["-hide_banner", "-loglevel", "error", "-y", "-f", "lavfi", "-i"]);
+        c.arg(format!("testsrc2=size={w}x{h}:rate=25,noise=alls=8:allf=t+u"));
+        c.args(["-frames:v", &frames.to_string(), "-c:v", "libvpx-vp9", "-b:v", "500k", "-frame-parallel", "0"]);
+        c.args(extra);
+        c.args(["-f", "ivf"]).arg(&path);
+        if !common::run(&mut c) {
+            return None;
+        }
+    }
+    let d = std::fs::read(&path).unwrap();
+    Some(common::ivf_frames(&d).into_iter().map(|f| f.to_vec()).collect())
+}
+
+fn check(name: &str, frames: &[Vec<u8>]) {
+    let path = common::fixtures_dir().join(format!("{name}.ivf"));
+    common::write_ivf(&path, 0, 0, frames);
+    let r = reference(&path, "yuv420p");
+    common::check_files(name, &path, &r, "yuv420p").unwrap();
+    let _ = std::fs::remove_file(path);
+}
+
+/// Splice the inter frames of a `w2` x `h2` stream after frames of a 352x288 stream.
+fn scaled_splice(name: &str, w2: u32, h2: u32, interp: &[&str]) -> Option<Vec<Vec<u8>>> {
+    let a = encode("syn_base_352", 352, 288, 6, &[])?;
+    let mut args = vec!["-error-resilient", "1"];
+    args.extend_from_slice(interp);
+    let b = encode(&format!("syn_er_{w2}x{h2}{}", interp.join("")), w2, h2, 10, &args)?;
+    let mut frames: Vec<Vec<u8>> = a[..4].to_vec();
+    for f in &b[1..] {
+        frames.push(explicit_size(f, w2, h2));
+    }
+    let _ = name;
+    Some(frames)
+}
+
+#[test]
+fn scaled_reference_downscale() {
+    let Some(f) = scaled_splice("down", 256, 208, &[]) else { return };
+    let mut dec = filmcraft_vp9::Decoder::with_threads(1);
+    for c in &f {
+        let _ = dec.decode(c, 0);
+    }
+    assert!(dec.stats().scaled_ref_blocks > 0, "{:?}", dec.stats());
+    check("syn_scaled_down", &f);
+}
+
+#[test]
+fn splice_same_size_control() {
+    let Some(f) = scaled_splice("same", 352, 288, &[]) else { return };
+    check("syn_same", &f);
+}
+
+#[test]
+fn scaled_reference_upscale() {
+    let Some(f) = scaled_splice("up", 480, 400, &[]) else { return };
+    check("syn_scaled_up", &f);
+}
+
+#[test]
+fn scaled_reference_odd_sizes() {
+    let Some(f) = scaled_splice("odd", 301, 199, &[]) else { return };
+    check("syn_scaled_odd", &f);
+}
+
+fn build_superframe(frames: &[Vec<u8>]) -> Vec<u8> {
+    if frames.len() == 1 {
+        return frames[0].clone();
+    }
+    let mut out = Vec::new();
+    for f in frames {
+        out.extend_from_slice(f);
+    }
+    let marker = 0xc0 | (3 << 3) | (frames.len() as u8 - 1);
+    out.push(marker);
+    for f in frames {
+        out.extend((f.len() as u32).to_le_bytes());
+    }
+    out.push(marker);
+    out
+}
+
+#[test]
+fn intra_only_frames() {
+    // Error resilient source: the frame after the intra-only frame does not use the previous
+    // frame's motion vectors either way, so its symbols parse as the encoder intended.
+    let Some(src) = encode("syn_er_g8", 352, 288, 20, &["-g", "8", "-error-resilient", "1"]) else { return };
+    let keys: Vec<usize> = src.iter().enumerate().filter(|(_, f)| f[0] & 0x04 == 0 && f[0] & 0x08 == 0).map(|(i, _)| i).collect();
+    assert!(keys.len() >= 2, "need a second key frame: {keys:?}");
+    for (reset, refresh, show_slot) in [(3u32, 0xffu8, 0u8), (2, 0x05, 2), (0, 0x10, 4)] {
+        let mut frames = Vec::new();
+        for (i, f) in src.iter().enumerate() {
+            if i == keys[1] {
+                frames.push(key_to_intra_only(f, refresh, reset));
+                frames.push(vec![0x88 | show_slot]);
+            } else {
+                frames.push(f.clone());
+            }
+        }
+        let mut dec = filmcraft_vp9::Decoder::with_threads(1);
+        for c in &frames {
+            dec.decode(c, 0).unwrap();
+        }
+        let s = dec.stats();
+        assert!(s.intra_only == 1 && s.show_existing == 1, "{s:?}");
+        check(&format!("syn_intra_only_{reset}"), &frames);
+    }
+}
+
+#[test]
+fn show_existing_frames() {
+    let Some(src) = encode("syn_er_352", 352, 288, 6, &["-error-resilient", "1"]) else { return };
+    let mut frames = Vec::new();
+    for (i, f) in src.iter().enumerate() {
+        frames.push(f.clone());
+        if i >= 1 {
+            frames.push(vec![0x88 | (i as u8 % 8)]);
+        }
+    }
+    // A superframe holding a frame and a show_existing_frame.
+    let sf = build_superframe(&[src[2].clone(), vec![0x88]]);
+    frames.push(sf);
+    check("syn_show_existing", &frames);
+}
diff --git a/crates/vp9/tools/extract_tables.py b/crates/vp9/tools/extract_tables.py
new file mode 100644
index 000000000..bdd59bb7b
--- /dev/null
+++ b/crates/vp9/tools/extract_tables.py
@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+"""Extract the VP9 constant tables from the text of the public VP9 Bitstream & Decoding Process
+Specification (v0.6, WebM project / Google).
+
+Usage:
+    curl -L -o vp9.pdf 'https://storage.googleapis.com/downloads.webmproject.org/docs/vp9/vp9-bitstream-specification-v0.6-20160331-draft.pdf'
+    pdftotext -layout vp9.pdf vp9.txt
+    python3 extract_tables.py vp9.txt > ../src/spec_tables.rs
+
+Only the specification text is read. Every table is emitted flat (row-major, as printed) with its
+element count checked against the declared dimensions.
+"""
+import re
+import sys
+
+text = open(sys.argv[1], encoding="utf-8").read().replace("−", "-").replace("–", "-")
+lines = [l for l in text.split("\n") if "Copyright" not in l and "VP9 Bitstream & Decoding Process Specification" not in l]
+text = "\n".join(lines)
+
+
+def table(name, count):
+    """Integers of the table `name[...] = { ... }` (the last definition in the text)."""
+    starts = [m.start() for m in re.finditer(r"\b%s\s*\[" % re.escape(name), text)]
+    for s in reversed(starts):
+        eq = text.find("=", s)
+        brace = text.find("{", s)
+        if eq < 0 or brace < 0 or eq > brace or text[s:eq].count("\n") > 2:
+            continue
+        depth = 0
+        i = brace
+        while True:
+            ch = text[i]
+            if ch == "{":
+                depth += 1
+            elif ch == "}":
+                depth -= 1
+                if depth == 0:
+                    break
+            i += 1
+        body = text[brace:i]
+        body = re.sub(r"//[^\n]*", "", body)
+        body = re.sub(r"/\*.*?\*/", "", body, flags=re.S)
+        vals = [int(v) for v in re.findall(r"-?\d+", body)]
+        assert len(vals) == count, (name, len(vals), count)
+        return vals
+    raise AssertionError("table not found: " + name)
+
+
+def emit(rust_name, ty, vals, per_line=16):
+    print("pub const %s: [%s; %d] = [" % (rust_name, ty, len(vals)))
+    for k in range(0, len(vals), per_line):
+        print("    " + ", ".join(str(v) for v in vals[k:k + per_line]) + ",")
+    print("];")
+    print()
+
+
+print("// Generated by tools/extract_tables.py from the VP9 Bitstream & Decoding Process Specification")
+print("// v0.6 (section numbers refer to that document). Do not edit by hand.")
+print()
+
+emit("INV_MAP_TABLE", "u8", table("inv_map_table", 255))
+emit("SUBPEL_FILTERS", "i16", table("subpel_filters", 4 * 16 * 8), 8)
+emit("DC_QLOOKUP", "i32", table("dc_qlookup", 3 * 256))
+emit("AC_QLOOKUP", "i32", table("ac_qlookup", 3 * 256))
+emit("COS64_LOOKUP", "i32", table("cos64_lookup", 33))
+for n, c in [("4x4", 16), ("8x8", 64), ("16x16", 256)]:
+    for kind in ["default", "col", "row"]:
+        emit("%s_SCAN_%s" % (kind.upper(), n.upper()), "u16", table("%s_scan_%s" % (kind, n), c))
+emit("DEFAULT_SCAN_32X32", "u16", table("default_scan_32x32", 1024))
+emit("COEFBAND_4X4", "u8", table("coefband_4x4", 16))
+emit("COEFBAND_8X8PLUS", "u8", table("coefband_8x8plus", 1024))
+emit("ENERGY_CLASS", "u8", table("energy_class", 12))
+emit("PARETO_TABLE", "u8", table("pareto_table", 128 * 8), 8)
+emit("MV_REF_BLOCKS", "i8", table("mv_ref_blocks", 13 * 8 * 2))
+emit("MODE_2_COUNTER", "u8", table("mode_2_counter", 14))
+emit("KF_PARTITION_PROBS", "u8", table("kf_partition_probs", 16 * 3), 3)
+emit("KF_Y_MODE_PROBS", "u8", table("kf_y_mode_probs", 10 * 10 * 9), 9)
+emit("KF_UV_MODE_PROBS", "u8", table("kf_uv_mode_probs", 10 * 9), 9)
+emit("DEFAULT_PARTITION_PROBS", "u8", table("default_partition_probs", 16 * 3), 3)
+emit("DEFAULT_Y_MODE_PROBS", "u8", table("default_y_mode_probs", 4 * 9), 9)
+emit("DEFAULT_UV_MODE_PROBS", "u8", table("default_uv_mode_probs", 10 * 9), 9)
+emit("DEFAULT_SKIP_PROB", "u8", table("default_skip_prob", 3))
+emit("DEFAULT_IS_INTER_PROB", "u8", table("default_is_inter_prob", 4))
+emit("DEFAULT_COMP_MODE_PROB", "u8", table("default_comp_mode_prob", 5))
+emit("DEFAULT_COMP_REF_PROB", "u8", table("default_comp_ref_prob", 5))
+emit("DEFAULT_SINGLE_REF_PROB", "u8", table("default_single_ref_prob", 10), 2)
+emit("DEFAULT_MV_SIGN_PROB", "u8", table("default_mv_sign_prob", 2))
+emit("DEFAULT_MV_BITS_PROB", "u8", table("default_mv_bits_prob", 20), 10)
+emit("DEFAULT_MV_CLASS0_BIT_PROB", "u8", table("default_mv_class0_bit_prob", 2))
+emit("DEFAULT_TX_PROBS", "u8", table("default_tx_probs", 4 * 2 * 3), 3)
+emit("DEFAULT_INTER_MODE_PROBS", "u8", table("default_inter_mode_probs", 7 * 3), 3)
+emit("DEFAULT_INTERP_FILTER_PROBS", "u8", table("default_interp_filter_probs", 8), 2)
+emit("DEFAULT_MV_JOINT_PROBS", "u8", table("default_mv_joint_probs", 3))
+emit("DEFAULT_MV_CLASS_PROBS", "u8", table("default_mv_class_probs", 20), 10)
+emit("DEFAULT_MV_CLASS0_FR_PROBS", "u8", table("default_mv_class0_fr_probs", 12), 3)
+emit("DEFAULT_MV_CLASS0_HP_PROB", "u8", table("default_mv_class0_hp_prob", 2))
+emit("DEFAULT_MV_FR_PROBS", "u8", table("default_mv_fr_probs", 6), 3)
+emit("DEFAULT_MV_HP_PROB", "u8", table("default_mv_hp_prob", 2))
+emit("DEFAULT_COEF_PROBS", "u8", table("default_coef_probs", 4 * 2 * 2 * 6 * 6 * 3), 3)
diff --git a/crates/vp9/tools/gen_transforms.py b/crates/vp9/tools/gen_transforms.py
new file mode 100644
index 000000000..2e016d4bc
--- /dev/null
+++ b/crates/vp9/tools/gen_transforms.py
@@ -0,0 +1,249 @@
+#!/usr/bin/env python3
+"""Generate straight-line 1D inverse transforms from the butterfly descriptions of the VP9
+specification (v0.6 section 8.7.1): inverse DCT (8.7.1.2 / 8.7.1.3, n = 2..5) and inverse ADST
+(8.7.1.4 - 8.7.1.8, n = 3, 4). ADST4 and WHT are small enough to be written by hand in
+src/transform.rs.
+
+The generator symbolically executes the ordered steps of the specification on an array T (and the
+higher precision array S of the ADST) and emits one `let` per written element, with the cos64 /
+sin64 constants folded in.
+
+Usage: python3 gen_transforms.py > ../src/transform_gen.rs
+"""
+
+COS64 = [16384, 16364, 16305, 16207, 16069, 15893, 15679, 15426, 15137, 14811, 14449, 14053, 13623,
+         13160, 12665, 12140, 11585, 11003, 10394, 9760, 9102, 8423, 7723, 7005, 6270, 5520, 4756,
+         3981, 3196, 2404, 1606, 804, 0]
+
+
+def cos64(angle):
+    a = angle & 127
+    if a <= 32:
+        return COS64[a]
+    if a <= 64:
+        return -COS64[64 - a]
+    if a <= 96:
+        return -COS64[a - 64]
+    return COS64[128 - a]
+
+
+def sin64(angle):
+    return cos64(angle - 32)
+
+
+def brev(bits, x):
+    t = 0
+    for i in range(bits):
+        t |= ((x >> i) & 1) << (bits - 1 - i)
+    return t
+
+
+class Gen:
+    def __init__(self, n):
+        self.n0 = 1 << n
+        self.T = ["x[%d]" % i for i in range(self.n0)]
+        self.S = [None] * self.n0
+        self.lines = []
+        self.k = 0
+
+    def new(self, expr):
+        name = "v%d" % self.k
+        self.k += 1
+        self.lines.append("    let %s = %s;" % (name, expr))
+        return name
+
+    @staticmethod
+    def lin(terms):
+        # Wrapping arithmetic: conformant streams never overflow (8.7.1.1), damaged ones must not
+        # panic in debug builds.
+        s = None
+        for var, c in terms:
+            if c == 0:
+                continue
+            t = "%s.wrapping_mul(%d)" % (var, c)
+            s = t if s is None else "%s.wrapping_add(%s)" % (s, t)
+        return s if s is not None else "0"
+
+    def B(self, a, b, angle, flip):
+        ta, tb = self.T[a], self.T[b]
+        c, s = cos64(angle), sin64(angle)
+        x = self.new("r14(%s)" % self.lin([(ta, c), (tb, -s)]))
+        y = self.new("r14(%s)" % self.lin([(ta, s), (tb, c)]))
+        self.T[a], self.T[b] = (y, x) if flip else (x, y)
+
+    def H(self, a, b, flip):
+        if flip:
+            a, b = b, a
+        x, y = self.T[a], self.T[b]
+        self.T[a] = self.new("%s.wrapping_add(%s)" % (x, y))
+        self.T[b] = self.new("%s.wrapping_sub(%s)" % (x, y))
+
+    def SB(self, a, b, angle, flip):
+        ta, tb = self.T[a], self.T[b]
+        c, s = cos64(angle), sin64(angle)
+        x = self.new(self.lin([(ta, c), (tb, -s)]))
+        y = self.new(self.lin([(ta, s), (tb, c)]))
+        self.S[a], self.S[b] = (y, x) if flip else (x, y)
+
+    def SH(self, a, b):
+        sa, sb = self.S[a], self.S[b]
+        self.T[a] = self.new("r14(%s.wrapping_add(%s))" % (sa, sb))
+        self.T[b] = self.new("r14(%s.wrapping_sub(%s))" % (sa, sb))
+
+
+def idct_steps(g, n):
+    n0, n1, n2, n3 = 1 << n, 1 << (n - 1), 1 << (n - 2), (1 << (n - 3)) if n >= 3 else 0
+    if n == 2:
+        g.B(0, 1, 16, 1)
+    else:
+        idct_steps(g, n - 1)
+    for i in range(n2):
+        g.B(n1 + i, n0 - 1 - i, 32 - brev(5, n1 + i), 0)
+    if n >= 3:
+        for i in range(n3):
+            for j in range(2):
+                g.H(n1 + 4 * i + 2 * j, n1 + 1 + 4 * i + 2 * j, j)
+    if n == 5:
+        for i in range(2):
+            for j in range(2):
+                g.B(n0 - n + 3 - n2 * j - 4 * i, n1 + n - 4 + n2 * j + 4 * i, 28 - 16 * i + 56 * j, 1)
+        for i in range(2):
+            for j in range(4):
+                g.H(n1 + n3 * j + i, n1 + n2 - 5 + n3 * j - i, j & 1)
+    if n >= 4:
+        for i in range(2 if n == 5 else 1):
+            for j in range(2):
+                g.B(n0 - n + 2 - i - n2 * j, n1 + n - 3 + i + n2 * j, 24 + 48 * j, 1)
+        for i in range(2 * n - 6):
+            for j in range(2):
+                g.H(n1 + n2 * j + i, n1 + n2 - 1 + n2 * j - i, j & 1)
+    if n >= 3:
+        for i in range(n3):
+            g.B(n0 - n3 - 1 - i, n1 + n3 + i, 16, 1)
+    for i in range(n1):
+        g.H(i, n0 - 1 - i, 0)
+
+
+def idct(n):
+    g = Gen(n)
+    n0 = 1 << n
+    g.T = ["x[%d]" % brev(n, i) for i in range(n0)]  # 8.7.1.2 permutation
+    idct_steps(g, n)
+    return g
+
+
+def adst_in_perm(g, n):
+    n0, n1 = 1 << n, 1 << (n - 1)
+    c = list(g.T)
+    for i in range(n1):
+        g.T[2 * i] = c[n0 - 1 - 2 * i]
+        g.T[2 * i + 1] = c[2 * i]
+
+
+def adst_out_perm(g, n):
+    c = list(g.T)
+    if n == 4:
+        for a in range(2):
+            for b in range(2):
+                for cc in range(2):
+                    for d in range(2):
+                        g.T[8 * a + 4 * b + 2 * cc + d] = c[8 * (d ^ cc) + 4 * (cc ^ b) + 2 * (b ^ a) + a]
+    else:
+        for a in range(2):
+            for b in range(2):
+                for cc in range(2):
+                    g.T[4 * a + 2 * b + cc] = c[4 * (cc ^ b) + 2 * (b ^ a) + a]
+
+
+def neg(g, i):
+    g.T[i] = g.new("%s.wrapping_neg()" % g.T[i])
+
+
+def adst8():
+    g = Gen(3)
+    adst_in_perm(g, 3)
+    for i in range(4):
+        g.SB(2 * i, 1 + 2 * i, 30 - 8 * i, 1)
+    for i in range(4):
+        g.SH(i, 4 + i)
+    for i in range(2):
+        g.SB(4 + 3 * i, 5 + i, 24 - 16 * i, 1)
+    for i in range(2):
+        g.SH(4 + i, 6 + i)
+    for i in range(2):
+        g.H(i, 2 + i, 0)
+    for i in range(2):
+        g.B(2 + 4 * i, 3 + 4 * i, 16, 1)
+    adst_out_perm(g, 3)
+    for i in range(4):
+        neg(g, 1 + 2 * i)
+    return g
+
+
+def adst16():
+    g = Gen(4)
+    adst_in_perm(g, 4)
+    for i in range(8):
+        g.SB(2 * i, 1 + 2 * i, 31 - 4 * i, 1)
+    for i in range(8):
+        g.SH(i, 8 + i)
+    for i in range(4):
+        g.SB(8 + 2 * i, 9 + 2 * i, 28 - 16 * i, 1)
+    for i in range(4):
+        g.SH(8 + i, 12 + i)
+    for i in range(4):
+        g.H(i, 4 + i, 0)
+    for i in range(2):
+        for j in range(2):
+            g.SB(4 + 8 * i + 3 * j, 5 + 8 * i + j, 24 - 16 * j, 1)
+    for i in range(2):
+        for j in range(2):
+            g.SH(4 + 8 * j + i, 6 + 8 * j + i)
+    for i in range(2):
+        for j in range(2):
+            g.H(8 * j + i, 2 + 8 * j + i, 0)
+    for i in range(2):
+        for j in range(2):
+            g.B(2 + 4 * j + 8 * i, 3 + 4 * j + 8 * i, 48 + 64 * (i ^ j), 0)
+    adst_out_perm(g, 4)
+    for i in range(2):
+        for j in range(2):
+            neg(g, 1 + 12 * j + 2 * i)
+    return g
+
+
+def emit(name, g):
+    n0 = g.n0
+    print("    #[inline(always)]")
+    print("    pub fn %s(x: [$t; %d]) -> [$t; %d] {" % (name, n0, n0))
+    for l in g.lines:
+        print("    " + l)
+    print("        [%s]" % ", ".join(g.T))
+    print("    }")
+    print()
+
+
+print("// Generated by tools/gen_transforms.py from the butterfly descriptions of the VP9 specification")
+print("// v0.6 section 8.7.1. Do not edit by hand.")
+print()
+print("macro_rules! transforms_1d {")
+print("    ($t:ty) => {")
+print("    #[inline(always)]")
+print("    fn r14(x: $t) -> $t {")
+print("        x.wrapping_add(1 << 13) >> 14")
+print("    }")
+print()
+for n in range(2, 6):
+    emit("idct%d" % (1 << n), idct(n))
+emit("iadst8", adst8())
+emit("iadst16", adst16())
+print("    };")
+print("}")
+print()
+print("pub(crate) mod narrow {")
+print("    transforms_1d!(i32);")
+print("}")
+print()
+print("pub(crate) mod wide {")
+print("    transforms_1d!(i64);")
+print("}")
diff --git a/docs/architecture.md b/docs/architecture.md
index 8bbe22a3e..115ccfb88 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -23,10 +23,10 @@ Design principles:
  L6  apps/filmcraft · apps/filmcraft-cli
  L5  ui-egui · automation
  L4  engine
- L3  render · gpu · export
- L2  edit · codecs · interchange
- L1  frame · media · project · audio-dsp
- L0  foundation: time · geom · color · bitstream
+ L3  render · gpu · export · golden (test-only)
+ L2  edit · codecs · interchange · captions
+ L1  frame · media · project · audio-dsp · text
+ L0  foundation: time · geom · color · bitstream · testkit (dev-dependency only)
      codecs/containers: isobmff · matroska · h264 · h264enc · hevc · prores · aac
 ```
 
@@ -45,15 +45,18 @@ and `filmcraft-cli`.
 | `hevc` | L0 | H.265 Main/Main 10 decoder |
 | `prores` | L0 | ProRes decoder and encoder |
 | `aac` | L0 | AAC-LC decoder and encoder |
+| `testkit` | L0 | test-only helpers, used only as a dev-dependency: ffmpeg/ffprobe discovery, fixture dirs, golden images ([testing.md](testing.md)) |
 | `frame` | L1 | `VideoFrame` (planar YUV / RGBA8 / linear RGBA f32, colour metadata), `AudioBuffer` |
 | `media` | L1 | `MediaSource` trait, probing/openers, frame cache, generators, stills, WAV |
 | `project` | L1 | document model, effect definitions, keyframes |
 | `audio-dsp` | L1 | loudness metering (BS.1770 / R128) and audio effects; no dependencies |
+| `text` | L1 | text engine: font database (bundled OFL fonts + system fonts), shaping (harfrust), bidi, line breaking, paragraph layout, glyph/path rasteriser, strokes ([crates/text/README.md](../crates/text/README.md)) |
 | `edit` | L2 | pure edit algebra (insert, overwrite, razor, ripple, roll, slip, slide, rate stretch…) |
 | `codecs` | L2 | container + codec hub: MP4/MOV and MKV sources, GOP-aware seeking, decoder registry, audio decoding |
 | `interchange` | L2 | EDL, FCP7 XML, FCPXML and OTIO import/export (no file I/O) |
 | `render` | L3 | sequence evaluation, CPU compositor, video effects, transitions, audio mix |
 | `gpu` | L3 | wgpu compositor (WGSL) |
+| `golden` | L3 | test-only: golden-image tests of the CPU renderer and GPU-vs-CPU parity; empty library, dev-dependencies only |
 | `export` | L3 | render → encode → mux pipeline, progress/cancel |
 | `engine` | L4 | `Session`, command registry, undo history, media pool, jobs, interchange glue |
 | `ui-egui` | L5 | the egui frontend: docking, panels, timeline, monitors, playback, control-channel handlers |
@@ -72,7 +75,7 @@ are exempt):
 | Every crate has a layer | A new crate fails the check until it is added to `LAYERS`. |
 | Only downward edges | A crate may not depend on a crate in a higher layer. |
 | Same-layer edges are listed | From L1 up, a same-layer edge must be in `SAME_LAYER`: `media→frame`, `project→media`, `project→frame`, `gpu→render`, `export→render`, `cli→filmcraft`, plus a few reserved for planned crates. |
-| L0 codecs stay standalone | L0 crates other than `time`, `geom`, `color`, `bitstream` may depend on no workspace crate except `filmcraft-bitstream`. External crates such as `thiserror` and `rayon` are allowed. |
+| L0 codecs stay standalone | L0 crates other than `time`, `geom`, `color`, `bitstream`, `testkit` may depend on no workspace crate except `filmcraft-bitstream`. External crates such as `thiserror` and `rayon` are allowed. |
 | No UI/OS crates below L5 | `egui`, `eframe`, `egui-wgpu`, `winit`, `rfd`, `cpal`, `muda` are allowed only in L5 and L6. |
 
 `cargo xtask wasm` runs `cargo check --target wasm32-unknown-unknown` on every L0–L4 crate, so
@@ -103,7 +106,7 @@ the boundary.
 Project
 ├─ root: Bin                         tree of bins
 ├─ items: map ItemId → ProjectItem   flat
-│    kind: Media(MediaClip) | Sequence(Sequence) | Subclip{..} | AdjustmentLayer{..}
+│    kind: Media(MediaClip) | Sequence(Sequence) | Subclip{..} | AdjustmentLayer{..} | Graphic{..}
 └─ next_id
 
 Sequence
@@ -113,7 +116,10 @@ Sequence
 Track
 ├─ locked, sync lock, targeting, mute/solo/visibility
 ├─ items: Vec<TrackItem>             sorted, never overlapping
-└─ transitions: Vec<Transition>
+├─ transitions: Vec<Transition>
+└─ audio: volume_db, pan, effects (mixer inserts), mixer: MixerStrip
+     (automation mode + lanes, sends, output, record arm, solo safe, input map)
+Sequence (audio) ─ submix_tracks: Vec<Track>, master_volume_db / master_effects / master_mixer
 TrackItem (a clip instance)
 ├─ item: ItemId, start (timeline ticks), source_in (media ticks), duration, speed
 ├─ link group, label, enabled
@@ -122,6 +128,8 @@ EffectInstance
 └─ effect id, enabled, params: id → constant value or keyframe track
 ```
 
+- **Graphic clips** ([graphics.md](graphics.md)) reference a `Graphic` canvas item; their text and
+  shape layers are hidden `graphic_text` / `graphic_shape` effect instances on the track item.
 - Everything is plain serde data. `Sequence::check()` validates the invariants (no overlaps, unique
   ids), and the engine runs it after every sequence edit.
 - Timeline positions are sequence ticks; `source_in` and keyframes are in media time, so trims and
@@ -216,8 +224,50 @@ file ──► codecs (MP4/MOV, MKV, audio)        demux + decode, GOP-aware see
   frames: shown when the exact picture was on screen while due, dropped otherwise (including frames
   passed over without a refresh, not while the window is hidden). `cargo xtask bench-playback`
   measures the whole path headlessly ([testing.md](testing.md) §5).
-  Sequence audio is mixed in `render::audio`, and clip audio effects run on `audio-dsp` via
-  `render::audio_fx`.
+  Sequence audio goes through the mixer graph (`render::mixer`, §5.1); clip audio effects run on
+  `audio-dsp` via `render::audio_fx`.
+
+### 5.1 Audio mixer
+
+```text
+clip: gain → clip effects → Volume / Channel Volume / Panner (clip keyframes, media time)
+      → audio transitions → summed per track                           render::audio::track_input
+track / submix strip:  input map, mono fold → pre-fader inserts → pre-fader sends → mute
+      → fader (volume) → meter → post-fader inserts → post-fader sends → pan / balance → output
+Mix:  bus sum → pre-fader inserts → fader → meter → post-fader inserts → out    render::mixer
+```
+
+- **Model** (`project::mixer`). Every audio track, submix and the Mix has a `MixerStrip`. Static
+  values stay in `Track::volume_db`, `pan`, `muted` and the send/effect parameters; automation is
+  keyframes in sequence ticks: lanes `volume`, `pan`, `mute` (hold), `send.<i>.level` in
+  `MixerStrip::lanes`, and insert parameters (`fx.<slot>.<param>`) in the effect's own keyframes.
+  Up to 5 inserts (`EffectInstance::post_fader` picks the side) and 5 sends per strip. Submixes feed
+  the Mix or a submix after them (no feedback). All fields have serde defaults, so older projects
+  load unchanged.
+- **Graph** (`render::mixer::mix_graph`). Lanes are evaluated per sample; effect parameters update
+  on an absolute 64-sample grid, so the output does not depend on how callers cut the timeline into
+  requests (export batches and device callbacks give identical samples). Inserts that report
+  latency delay their strip; each route into a bus gets a compensation delay and the graph is read
+  ahead by its total latency. Graph state (DSP, delay lines) is cached per structure and continued by
+  sequential readers; other requests start fresh with a pre-roll (effect tails, ≤ 3 s). Tracks run
+  in parallel (rayon), buses in order. Mono tracks pan with the −3 dB constant-power law; stereo
+  tracks and sends use balance. Solo keeps soloed and solo-safe strips plus everything feeding them
+  or fed by them. 24 tracks × (EQ + Dynamics + Studio Reverb) + a compressed submix renders at
+  ~6× realtime on one core (release).
+- **Automation modes** (Premiere semantics). Off ignores lanes; Read plays them; Latch records from
+  the first touch and holds the last value until playback stops; Touch records while held and ramps
+  back to the existing automation over the **automatch time** (Preferences ▸ Audio, 1 s); Write
+  records every control from playback start (then switches to Touch unless "Switch to Touch after
+  Write" is off).
+- **Recording** (`engine::mixer`). Playback start runs `mixer.recordStart`, stop runs
+  `mixer.recordStop`. Fader and knob drags send `mixer.touch` (value, playhead) while held and
+  `mixer.release` when let go. Held values go to `render::mixer::LiveMix`, which the playing mix
+  reads, so moves are heard at once. At stop each gesture stream is thinned (linear keyframe
+  thinning, optional minimum time interval) and written over its time range as one undo step,
+  with boundary keyframes that keep the automation outside the range unchanged.
+- **Live state.** `PreviewStore::live` (`LiveMix`) also carries per-strip meter peaks posted by the
+  mix (Track Mixer and Audio Meters read them) and the newest project snapshot, which the audio
+  callback uses, so edits made during playback are heard.
 
 ## 6. Export jobs (`filmcraft-export`)
 
@@ -265,7 +315,7 @@ Protocol reference: [control-protocol.md](control-protocol.md). Agent guide: [ag
 ## 8. Not built yet
 
 The layer table reserves names for crates that don't exist yet: `riff`, `mjpeg`, `dnx`,
-`keyframe`, `effects`, `text`, `audio`, `captions`, `scopes`, `playback`, `format` and `platform`.
+`keyframe`, `effects`, `audio`, `scopes`, `playback`, `format` and `platform`.
 Until they exist, that work lives elsewhere: keyframes and effect definitions in `project`, effects
 and the audio mix in `render`, scopes and playback in `ui-egui`, and OS integration (cpal, rfd,
 native menus) in `apps/filmcraft`. [ROADMAP.md](../ROADMAP.md) has the milestone status.
diff --git a/docs/captions.md b/docs/captions.md
index 0cac44d7a..b8c03f0a4 100644
--- a/docs/captions.md
+++ b/docs/captions.md
@@ -74,6 +74,5 @@ also splits captions.
 
 The Program monitor shows the visible caption tracks. On export, `file.exportMedia`
 `{"burnCaptions": true}` (Export mode: **Burn Captions Into Video**) draws them into every frame.
-Captions are set in Inter SemiBold (OFL, bundled) with our own rasteriser; italics/bold markup is
-not yet drawn differently, and text is not shaped (no kerning or complex scripts) until the M10.1
-text engine lands. Nested sequences do not burn in their own captions.
+Captions are set in Inter SemiBold (OFL, bundled) by the text engine (`crates/text`: shaping,
+kerning, bidi); italics/bold markup is not yet drawn differently. Nested sequences do not burn in their own captions.
diff --git a/docs/contributing.md b/docs/contributing.md
index b8a9868d6..f7abfee38 100644
--- a/docs/contributing.md
+++ b/docs/contributing.md
@@ -8,7 +8,7 @@ of the crate you will change.
 
 | | All platforms |
 |---|---|
-| Rust | stable ≥ 1.90 (edition 2024), via [rustup](https://rustup.rs) |
+| Rust | stable ≥ 1.95 (edition 2024; egui 0.36 requires it), via [rustup](https://rustup.rs) |
 | wasm target | `rustup target add wasm32-unknown-unknown` (for `cargo xtask wasm`) |
 | Components | `rustup component add rustfmt clippy` |
 | ffmpeg + ffprobe (optional) | test oracle and fixture generator only; tests skip without it |
diff --git a/docs/control-protocol.md b/docs/control-protocol.md
index c54101023..15004e6a6 100644
--- a/docs/control-protocol.md
+++ b/docs/control-protocol.md
@@ -33,9 +33,37 @@ Methods (handlers in `crates/ui-egui/src/control.rs`):
 Element ids are stable, e.g. `timeline.clip.<id>`, `timeline.track.V1.lock`, `tools.Razor`,
 `project.item.<id>`, `effects.item.gaussian_blur`, `panel.tab.Timeline`, `program.transport.playback.toggle`.
 
+Audio mixing: `mixer.*` commands (strips `"A1"`, `"S1"`, `"Mix"` or ids; lanes `volume`, `pan`,
+`mute`, `send.<i>.level`, `fx.<slot>.<param>`): `mixer.inspect`, `mixer.setStrip` (volume, pan, mute,
+solo, record arm, solo safe, mode Off/Read/Latch/Touch/Write, output, input map, channels),
+`mixer.setValue`, `mixer.touch` / `mixer.release` (a fader gesture; recorded during an automation pass),
+`mixer.recordStart` / `mixer.recordStop` (playback runs them), `mixer.addSubmix`, `mixer.deleteSubmix`,
+`mixer.addInsert` / `removeInsert` / `setInsert`, `mixer.addSend` / `setSend` / `removeSend`,
+`mixer.setKeyframe` / `deleteKeyframe` / `moveKeyframe` / `clearLane`, `mixer.writeAutomation`;
+`clipMixer.set`; `clip.audioGain {mode: set|adjust|normalizeMax|normalizeAll, db}`, `clip.audioPeak`;
+`effects.setDefaultTransition`. UI ids: `mixer.<A1|S1|Mix>.<fader|value|pan|panValue|mode|mute|solo|
+record|soloSafe|output|input|fx.<n>|send.<n>|meter|name>` (popup entries below them, e.g.
+`mixer.A1.mode.Touch`, `mixer.A1.fx.0.studio_reverb`), `mixer.showEffects`, `mixer.transport.<cmd>`,
+`clipMixer.A1.<fader|pan|mute|solo|keyframe|value>`, `timeline.track.A1.keyframes[.<lane>|.clip]`,
+`timeline.track.A1.lane[.kf.<n>]`, `audioGain.<set|adjust|normalizeMax|normalizeAll|ok|cancel|peak>`.
+
 Project files, auto-save, crash recovery and preferences commands (`file.recover`, `prefs.set`, …) and their
 automation ids are listed in [project-files.md](project-files.md).
 
+**Trim mode** (`crates/engine/src/trim.rs`): `trim.selectEditPoint` / `trim.selectNearest` enter trim
+mode (the Program monitor becomes the Trim Monitor, ids `trimMonitor.*`); `trim.monitor` returns what
+it shows. Dynamic trimming takes an explicit clock (seconds) so it is deterministic: `trim.shuttle
+{direction, slow?, clock}` (J/L), `trim.tick {clock}`, `trim.shuttleStop {clock?}` (K, one undo step),
+`trim.cancelDynamic` (Esc), `trim.playAround {clock, loop?}` (Space / Shift+K).
+
+**Keyboard shortcuts** (`crates/engine/src/shortcuts.rs`): `shortcuts.list {query?, panel?}`,
+`shortcuts.get`, `shortcuts.set {command, keys, panel?, add?, keepConflicts?}`, `shortcuts.clear`,
+`shortcuts.undo` / `shortcuts.redo`, `shortcuts.conflicts {platform?}`, `shortcuts.forKey {key}`,
+`shortcuts.resolve {keys, panel?}`, `shortcuts.presets`, `shortcuts.loadPreset` / `savePreset` /
+`deletePreset {name}`, `shortcuts.export` / `import {path}`, `shortcuts.audit`. Keys use `Cmd` (⌘ /
+Ctrl), `Ctrl` (macOS ⌃), `Alt`, `Shift`. The dialog (Edit ▸ Keyboard Shortcuts…, ⌥⌘K) uses ids
+`shortcuts.*` (`shortcuts.key.K`, `shortcuts.cell.<command>`, `shortcuts.ok`, …).
+
 ## MCP
 `filmcraft-cli mcp` serves MCP on stdio: headless (in-process session; `--demo` / `--project p.fcproj`)
 or `--bridge 127.0.0.1:9876` to drive the running app. Tools: `command_list`, `command_run`,
diff --git a/docs/graphics.md b/docs/graphics.md
new file mode 100644
index 000000000..e0509e127
--- /dev/null
+++ b/docs/graphics.md
@@ -0,0 +1,92 @@
+# Graphics
+
+FilmCraft's graphics work like Premiere's Essential Graphics: a **graphic clip** on a video track
+holds **text** and **shape** layers. Text is set by the text engine in `crates/text`
+([README](../crates/text/README.md)): bundled OFL fonts plus system fonts, OpenType shaping with
+kerning and ligatures, bidi, line breaking, all drawn as vectors in linear light.
+
+## Model
+
+- A graphic clip's project item is an `ItemKind::Graphic { width, height, rate }`: a transparent
+  canvas the size of the sequence frame, with unlimited duration. These items are internal and do
+  not appear in the Project panel.
+- Its **layers** are effect instances `graphic_text` / `graphic_shape` in the clip's effect list,
+  in paint order (first = back). They are hidden from the Effects panel. Because they are effect
+  instances they save with the project, take keyframes on every animatable property (Source Text
+  keyframes hold), appear in Effect Controls and copy with the clip. Standard effects on a graphic
+  clip apply to the composed graphic; Motion and Opacity apply last.
+- `filmcraft_project::graphic::eval_layer` evaluates a layer at a time into a `LayerSpec`.
+- Projects with graphics need no schema migration: everything is additive (new item kind, new
+  effect ids). Builds older than this one refuse such files with a parse error.
+
+### Layer properties
+
+| Group | Properties (parameter ids) |
+|---|---|
+| Text | `text` (Source Text), `font`, `font_style`, `size` (px), `align` (Left/Center/Right/Justify), `tracking` (1/1000 em), `kerning`, `ligatures`, `leading` (px added to the natural line height), `baseline_shift`, `faux_bold`, `faux_italic`, `caps` (Normal/All Caps/Small Caps), `underline`, `box_width` (0 = point text, else area text wrapped at that width) |
+| Shape | `shape` (Rectangle/Ellipse/Polygon/Path), `size` [w, h], `sides`, `corner_radius`, `points` (path vertices relative to the layer origin) |
+| Appearance | `fill`, `fill_color`; `stroke`, `stroke_color`, `stroke_width`, `stroke_type` (Outer/Center/Inner) and the same for `stroke2`; `background`, `background_color`, `background_opacity`, `background_size` (padding), `background_radius`; `shadow`, `shadow_color`, `shadow_opacity`, `shadow_angle` (135° = down-right), `shadow_distance`, `shadow_size`, `shadow_blur` |
+| Transform | `position` (graphic canvas px), `anchor` (layer px), `scale`, `scale_width`, `uniform_scale`, `rotation`, `opacity` |
+
+Point text's origin is its alignment point on the first baseline (the click point of the Type
+tool); a shape's origin is its centre. Colours are `#rrggbb` (sRGB).
+
+## Rendering
+
+`crates/render/src/graphic_clip.rs` rasterises each layer straight to the output transform
+(sequence Motion × layer transform), so text stays sharp at any scale or rotation. Fill coverage
+comes from the text engine; strokes come from a Euclidean distance transform of that coverage
+(outer strokes sit under the fill, centre and inner strokes over it); the shadow is the union of
+all parts, spread by Size, offset and blurred. Each layer's raster is cached while it stays the same.
+The GPU plan receives one tight image per graphic clip and places it with a translation. The
+Timecode and Clip Name effects also draw with the text engine.
+
+## Commands
+
+| Command | Menu / shortcut | Params |
+|---|---|---|
+| `graphics.newText` | Graphics and Titles ▸ New Layer ▸ Text (⌘T) | `text`, `position`, `clip` (add to this graphic), `size`, `font`, `fontStyle`, `seconds` (5), `track`, `time` |
+| `graphics.newShape` | Graphics and Titles ▸ New Layer ▸ Shape | `shape` (rectangle/ellipse/polygon/path), `position`, `size`, `points`, `clip` |
+| `graphics.setText` | typing on the monitor | `clip`, `layer`, `text`, `merge` (coalesce one typing session into one undo step) |
+| `graphics.set` | Properties panel | `clip`, `layer`, `props` {parameter id or camelCase alias: value; choices by index or name}, `time` |
+| `graphics.selectLayer` | layer list / monitor click | `clip`, `layers` |
+| `graphics.deleteLayer`, `graphics.arrangeLayer` | layer list | `clip`, `layer`, `to` (front/back/forward/backward/index) |
+| `graphics.align` | Align and Transform | `align` (left/hcenter/right/top/vcenter/bottom), `to` (frame/selection), `layers` |
+| `graphics.distribute` | Align and Transform | `axis` (horizontal/vertical), `layers` (3+) |
+| `graphics.list` | (query) | `clip` — layers with names, kinds, text, position and on-canvas quads |
+| `fonts.list` | (query) | `system` (scan system font folders, default true) — families and styles |
+
+Without `clip`, commands use the selected graphic clip, else the topmost graphic clip under the
+playhead. Without `layer`, they use the selected layer, else the front one. New graphic clips are
+placed at the playhead on the first video track above the clips there that is free for the
+duration (a track is added if needed).
+
+## Program monitor
+
+| Tool | On the Program monitor |
+|---|---|
+| Type (T) | Click empty picture: new text layer with a caret. Click a text layer: caret there. Type; ←/→ (⌥ word, ⌘ line), ↑/↓, Home/End, Shift to select, ⌘A, ⌘C/⌘X/⌘V, Return = new line, Backspace/Delete, Esc = stop editing. Drag inside the edited text to select. |
+| Selection (V) | Click a layer to select it (box with handles and anchor point); drag to move; drag a corner handle to scale; double-click a text layer to edit it. |
+| Rectangle / Ellipse | Drag to draw a shape layer. |
+| Pen (P) | Click to place points; click the first point (or Return) to close the path; Esc cancels. |
+
+Automation ids: `program.layer.<clip>.<layer>`, `program.layer.<clip>.<layer>.handle.<n>`,
+`program.textEdit` (while editing).
+
+## Properties / Essential Graphics panels
+
+With a graphic clip selected, the Properties panel (and Essential Graphics) shows: **Layers**
+(front first; new text / rectangle / ellipse, bring forward / send backward, delete, visibility),
+**Align and Transform** (six align buttons, two distribute buttons, position, anchor, scale,
+rotation, opacity), **Text** (Source Text field, font family and style, size, paragraph alignment,
+tracking, leading, baseline shift, box width, faux bold / faux italic / all caps / small caps /
+underline, kerning and ligatures), **Shape**, and **Appearance** (fill, two strokes, background,
+shadow). Automation ids: `graphics.layers.<n>`, `graphics.prop.<parameter id>`,
+`graphics.align.<how>`, `graphics.distribute.<axis>`, `graphics.sourceText`, `graphics.NewTextLayer`,
+`graphics.NewRectangle`, `graphics.NewEllipse`, `graphics.deleteLayer`, `graphics.section.<name>`.
+
+## Not yet
+
+Per-character styling inside one text layer, responsive design pins and rolls/crawls (M10.3),
+motion graphics templates, the Browse tab, mask-with-text, gradient fills, per-layer blend modes, and
+Bézier curves in the pen tool (paths are polygons).
diff --git a/docs/project-files.md b/docs/project-files.md
index 91e64a286..9b6dfc6ae 100644
--- a/docs/project-files.md
+++ b/docs/project-files.md
@@ -8,7 +8,7 @@ writing them is `crates/format` (`filmcraft-format`); the engine's `file.*` comm
 ```json
 {
   "format": "filmcraft.project",
-  "schema_version": 2,
+  "schema_version": 3,
   "generator": "FilmCraft 0.1.0",
   "project": { "name": "…", "settings": { … }, "root": { … }, "items": { … }, "next_id": 48 }
 }
@@ -26,6 +26,7 @@ writing them is `crates/format` (`filmcraft-format`); the engine's `file.*` comm
 |---|---|---|
 | 1 | M0 | the bare `Project` object with a `"version": 1` field |
 | 2 | M11.1 | the envelope above; the project's own `version` field is gone |
+| 3 | M10.2 | graphic clips (`ItemKind::Graphic` with text/shape layers); a no-op step for older data |
 
 ### Migrations
 
@@ -40,6 +41,9 @@ document; after the last one the result is deserialized into the current model.
 3. never edit a migration that has shipped.
 
 Fields added with `#[serde(default)]` don't need a migration: missing values take their defaults.
+But when new data would make the file unreadable to an older build (a new enum variant such as
+`ItemKind::Graphic`, a new required shape), bump the schema with a no-op step so older builds refuse
+the file with the message below instead of failing with a parse error.
 
 When you open an older file FilmCraft says so ("Upgraded project from schema v1 to v2"). The file
 on disk is unchanged until you save. The **first save over it** keeps the original next to it as
@@ -49,8 +53,8 @@ on disk is unchanged until you save. The **first save over it** keeps the origin
 
 A file with a `schema_version` newer than the build supports is **refused**, not half-read:
 
-> this project was saved by a newer version of FilmCraft (project schema v3); this build reads up to
-> v2. Update FilmCraft to open it.
+> this project was saved by a newer version of FilmCraft (project schema v4); this build reads up to
+> v3. Update FilmCraft to open it.
 
 Reading it partially and saving it back would silently drop whatever the newer version added.
 
diff --git a/docs/testing.md b/docs/testing.md
index b27527172..3ca5d119a 100644
--- a/docs/testing.md
+++ b/docs/testing.md
@@ -5,6 +5,8 @@ cargo test --workspace                          # everything; oracle tests skip
 cargo test -p filmcraft-h264                    # one crate
 cargo test --release -p filmcraft-hevc          # codec tests are much faster in release
 cargo xtask ci                                  # all gates (fmt, clippy, tests, layers, assets, wasm)
+cargo xtask fixtures                            # pre-generate the ffmpeg fixture matrix
+FILMCRAFT_REQUIRE_ORACLES=1 cargo test --workspace   # CI: missing ffmpeg fails instead of skipping
 ```
 
 ## 1. Kinds of tests
@@ -14,8 +16,11 @@ cargo xtask ci                                  # all gates (fmt, clippy, tests,
 | Unit | `src/` `#[cfg(test)]` modules, `src/tests.rs` | CABAC engines, VLC tables (prefix-freeness, Kraft sums), colour matrices, frame cache |
 | Property (`proptest`) | `time`, `bitstream`, `edit`, `isobmff/tests/roundtrip.rs`, `interchange/tests/*` | tick↔frame round trips for every rate, DF timecode, edit invariants (no overlaps, durations conserved), mux→demux round trips, interchange export→import |
 | Synthetic streams | `h264/src/synth_tests.rs`, `hevc/src/synth_tests.rs` | hand-built bitstreams for features the reference encoders don't emit; expected output known exactly |
+| Scripted UI | `crates/ui-egui/tests/scripted.rs` | headless app (egui_kittest) driven over the control channel: razor/undo, insert, apply effect, playback, click by automation id (§4) |
+| Golden images | `crates/golden/tests/golden.rs` | CPU renders vs committed PNGs; GPU vs CPU on the same scenes (§3) |
 | Engine / command | `crates/engine/src/tests.rs` | run commands on the demo project, assert the sequence, undo/redo, disabled cases |
 | Render | `crates/render/src/tests.rs` | compositing, opacity, Motion, cross dissolve midpoint, ½-res vs full, GPU plan vs reference, audio mix, audio-effect continuity |
+| Mixer | `crates/render/src/mixer_tests.rs`, `crates/engine/src/mixer_tests.rs` | sample-exact fader gain and pan laws, automation at block boundaries (bit-identical however requests are cut), solo/mute/solo-safe, sends and submix routing, latency-compensation alignment, render-vs-playback identity, Touch ramp-back, recorder modes (Latch/Touch/Write), thinning, Audio Gain, transition curves; `perf_24_tracks_3_effects_realtime_factor` prints the realtime factor |
 | Oracle | `crates/*/tests/*oracle*.rs`, `conformance.rs` | compare with ffmpeg/ffprobe (§2) |
 | Robustness / fuzz | `*/tests/robustness.rs`, `*/tests/fuzz.rs` | seeded mutation and truncation of real and synthetic files; nothing may panic |
 | Performance | `*/tests/perf.rs` (`#[ignore]`) | §5 |
@@ -27,10 +32,28 @@ Commit `*.proptest-regressions` files so failing cases are re-run.
 ffmpeg and ffprobe are **external processes** used to generate fixtures and to check results. They
 are never linked or shipped ([AGENTS.md](../AGENTS.md) §2).
 
-- Each crate's `tests/common/mod.rs` finds the tools in `/opt/homebrew/bin`, `/usr/local/bin` or
-  `/usr/bin`. If they are missing, the test prints a message and returns (it passes).
-- Fixtures are generated on first use into `<repo>/target/fixtures/<crate>/` and reused afterwards.
-  Delete that directory to regenerate them. Never commit media.
+- The tools are found by `filmcraft-testkit` (a dev-dependency-only crate, `crates/testkit`), in
+  this order: `FILMCRAFT_FFMPEG` / `FILMCRAFT_FFPROBE` (explicit paths; a wrong path is an error),
+  then every directory on `PATH` (`ffmpeg` and `ffmpeg.exe`), then well-known install directories
+  (`/opt/homebrew/bin`, `/usr/local/bin`, `/usr/bin`, `C:\ffmpeg\bin`, …).
+- If a tool is missing the test prints `SKIPPED (<test>): ffmpeg not found …` and passes. Set
+  **`FILMCRAFT_REQUIRE_ORACLES=1`** (CI) to make every such skip a failure. In new tests use
+  `let ff = filmcraft_testkit::require_ffmpeg!();` (also `require_ffprobe!`, `require_oracles!`).
+- Fixtures are generated on first use into `<workspace>/target/fixtures/<crate>/`
+  (`filmcraft_testkit::fixtures_dir`; independent of `CARGO_TARGET_DIR`, so agents with private
+  target dirs share them; `FILMCRAFT_FIXTURES_DIR` overrides the root) and reused afterwards.
+  Generators write to a per-process/thread temporary name (`testkit::temp_path`) and rename it into
+  place, so concurrent tests never see half-written files. Delete the directory to regenerate.
+  Never commit media.
+- Every crate's `tests/common/mod.rs` delegates discovery and fixture paths to testkit, except
+  `crates/codecs/src/tests.rs`, which still has its own lookup (the crate was being edited
+  concurrently; migrate it when convenient).
+- `cargo xtask fixtures [crate…]` pre-generates the whole fixture matrix up front (useful before a
+  parallel test run or on a fresh machine). It runs each crate's ignored `generate_fixtures` test —
+  the same generators the oracle tests call — for `h264`, `hevc`, `isobmff`, `matroska` and
+  `prores`, and prints one `made` / `cached` / `skipped` line per fixture plus a summary. The
+  `aac`, `opus` and `h264enc` oracles generate small per-test signals on demand and are not part of
+  the matrix.
 - Fixture sources are synthetic: `testsrc2`, `mandelbrot`, SMPTE bars, noise and fades, sine tones.
   H.264 and HEVC fixtures need ffmpeg built with libx264 and libx265. VideoToolbox fixtures are
   generated only on macOS.
@@ -48,6 +71,7 @@ are never linked or shipped ([AGENTS.md](../AGENTS.md) §2).
 | `aac` encode | ffmpeg decodes our stream | no errors, no clipping, CBR within ±5% of target; SNR reported |
 | `isobmff` | `ffprobe -show_packets` on ffmpeg-made MP4/MOV | packet offsets, sizes, pts/dts, durations, key flags and stream parameters equal; remuxed files decode with `ffmpeg -v error` silent |
 | `matroska` | `ffprobe -show_packets` | every packet (stream, size, key flag, pts, duration) equal; seeks land on the latest keyframe ≤ target |
+| `audio-dsp` loudness | `tests/loudness_oracle.rs`: signals generated in Rust (997 Hz sine, pink noise at 48/96 kHz, speech-like bursts at 48/44.1 kHz, stereo with silence and sub-gate passages, an fs/4 inter-sample-peak tone) written as float WAV and measured with `ffmpeg -af ebur128=peak=true:metadata=1` | momentary and short-term every 100 ms **±0.1 LU**, integrated **±0.1 LU**, LRA **±0.5 LU**, true peak **±0.2 dB** (against the analytic value when one exists). Measured: ΔM/ΔS ≤ 0.0005 LU, ΔI ≤ 0.007 LU, ΔLRA ≤ 0.04 LU, ΔTP ≤ 0.045 dB against ffmpeg. On the fs/4 tone ffmpeg's own true peak is +0.6 dB high (−0.32 vs the analytic −0.92 dBTP); ours is −0.05 dB |
 | `export` | our own demuxer/decoder reads the file back; ffprobe counts frames when present | expected size, duration, colour, audio level; exact frame count |
 
 Each codec README has the full fixture matrix and the measured results.
@@ -62,13 +86,62 @@ Each codec README has the full fixture matrix and the measured results.
   difference of ≤ 6 and a mean of < 1.5 (8-bit levels). It skips when no GPU adapter is available.
 - Effects implemented only on the CPU need no GPU test: the plan pre-renders those layers on the
   CPU.
-- Golden-image files (rendered PNGs compared against committed references) are not used yet. If you
-  add them, generate the references from FilmCraft itself, give each one an attribution sidecar,
-  and document the tolerance (PSNR in dB, or max/percentile error).
+- **Golden images** (`crates/golden`, a test-only crate): `tests/golden.rs` builds small procedural
+  projects (demo-generator footage, bars, no media files) at 320×180 and renders one frame of each
+  through the CPU compositor: Motion transform + opacity, four blend modes (Multiply, Screen,
+  Overlay, Difference), Gaussian Blur, Lumetri basic correction, Crop, Cross Dissolve at 50 %, Dip
+  to Black at 25 %, Wipe at 50 %, and Timecode / Clip Name burn-in text. Each frame is compared
+  with `crates/golden/goldens/<scene>.png` by `filmcraft_testkit::golden`:
+  **PSNR ≥ 45 dB, max abs ≤ 12, 99th-percentile per-pixel max channel difference ≤ 2** (8-bit
+  sRGB levels; `Tolerance::RENDER`). On failure the actual frame and a ×8 difference image go to
+  `<workspace>/target/golden-failures/`. `scenes_are_distinct` guards against blank or duplicate
+  scenes.
+- **Blessing:** `FILMCRAFT_BLESS=1 cargo test -p filmcraft-golden` rewrites the references (and
+  writes a `.attribution` sidecar for any new one; it prints the `ATTRIBUTION.md` row to add).
+  References are original work rendered by FilmCraft, must stay under 50 KB (enforced on bless),
+  and every one needs its sidecar and index row (`cargo xtask assets`). Look at a re-blessed PNG
+  before committing it.
+- The same scenes run through `plan_frame` + `GpuCompositor` when a GPU adapter exists
+  (`gpu_matches_cpu_on_golden_scenes`, same p99 ≤ 6 / mean < 1.5 criterion; skipped otherwise).
+  This found a real bug: the GPU upload cache was keyed by pixel-buffer address without keeping
+  the buffer alive, so a new frame allocated at a freed frame's address was drawn with the stale
+  texture (fixed; regression test `upload_cache_keeps_buffers_alive`).
 
 ## 4. UI: control channel and screenshots
 
-There is no automated UI test suite yet. UI work is checked by driving the real app:
+### Scripted UI tests (headless)
+
+`crates/ui-egui/tests/scripted.rs` runs the real `FilmcraftApp` under
+[`egui_kittest`](https://docs.rs/egui_kittest) (`build_eframe`): no window, no GPU, no OS event loop.
+A small `Driver` opens the demo project, sends requests through the same control channel agents use
+(`ControlRequest` → `control::handle`, exactly as the TCP server does) and steps egui frames until
+each reply arrives. Synthetic input queued by `ui.click` / `ui.drag` / `ui.key` is moved into the
+next frame by the app's own `raw_input_hook`, so clicks by automation id work headless. Covered:
+
+| Test | Asserts |
+|---|---|
+| `demo_project_opens_headless_and_registers_widgets` | active sequence, > 50 registered widgets, panel and tool ids, 6 clips on V1 (`sequence.inspect`) |
+| `razor_then_undo_through_the_control_channel` | `timeline.razor` adds a clip, the timeline can locate it on screen, `edit.undo` via `ui.menu.invoke`, redo |
+| `insert_from_source_ripples_the_sequence` | `source.open` + marks + `source.insert` lengthens the sequence |
+| `apply_effect_appears_in_effect_controls` | `effects.apply` adds Gaussian Blur in the model and `effectControls.effect.gaussian_blur` appears in the panel; undo removes it |
+| `playback_toggle_and_stop` | `playback.toggle` / `ui.playback stop` and `ui.inspect` playback state |
+| `clicking_a_tool_button_by_automation_id` | `ui.click {id: "tools.Razor"}` changes the tool (real egui input path) |
+| `unknown_methods_and_commands_fail_cleanly` | errors come back as `{"ok": false}` |
+
+`crates/ui-egui/tests/mixer_ui.rs` drives the Audio Track Mixer, Audio Clip Mixer, timeline track
+keyframes and the Audio Gain dialog by automation id and with multi-frame pointer drags (press, move
+over several frames, release). With `FILMCRAFT_UI_SNAPSHOT_DIR=<dir>` it also renders the window
+offscreen through wgpu (`Harness::render`) and writes `mixer-*.png`; this works without a visible
+window (for example on a locked screen, where `ui.screenshot` cannot capture).
+
+Not covered headless: `ui.screenshot` (needs a real viewport), the wgpu monitor path (the harness
+runs the CPU texture path), audio output, and wall-clock playback advance (kittest frames do not
+advance real time). Use `Driver` for new UI regressions: `d.exec(command, params)`,
+`d.ok(method, params)`, `d.frames(n)`.
+
+### Interactive checks
+
+For visual work, drive the real app:
 
 ```sh
 cargo run --release -p filmcraft -- --control 9876
diff --git a/xtask/Cargo.toml b/xtask/Cargo.toml
index df7dfa877..78230cad7 100644
--- a/xtask/Cargo.toml
+++ b/xtask/Cargo.toml
@@ -7,3 +7,4 @@ publish = false
 
 [dependencies]
 serde_json = { workspace = true }
+filmcraft-testkit = { workspace = true }
diff --git a/xtask/src/main.rs b/xtask/src/main.rs
index 2ebde188d..b5094c775 100644
--- a/xtask/src/main.rs
+++ b/xtask/src/main.rs
@@ -5,6 +5,9 @@
 //! - `wasm`: `cargo check --target wasm32-unknown-unknown` for every crate in L0–L4.
 //! - `assets`: every asset file (image, icon, font, LUT, audio, video…) has a complete
 //!   `<file>.attribution` sidecar and an entry in `ATTRIBUTION.md` (AGENTS.md §1).
+//! - `fixtures [crate…]`: pre-generate the ffmpeg fixture matrix of the oracle tests (runs each
+//!   crate's ignored `generate_fixtures` test, i.e. the same generators the tests use) and print
+//!   what was made, reused or skipped.
 //! - `ci`: fmt check, clippy -D warnings, tests, layers, assets, wasm.
 
 use std::process::{Command, ExitCode};
@@ -13,6 +16,7 @@ use serde_json::Value;
 
 /// (crate name without the `filmcraft-` prefix, layer).
 const LAYERS: &[(&str, u8)] = &[
+    ("testkit", 0),
     ("time", 0),
     ("geom", 0),
     ("color", 0),
@@ -23,6 +27,7 @@ const LAYERS: &[(&str, u8)] = &[
     ("h264", 0),
     ("h264enc", 0),
     ("hevc", 0),
+    ("vp9", 0),
     ("prores", 0),
     ("mjpeg", 0),
     ("dnx", 0),
@@ -32,16 +37,17 @@ const LAYERS: &[(&str, u8)] = &[
     ("media", 1),
     ("project", 1),
     ("audio-dsp", 1),
+    ("text", 1),
     ("edit", 2),
     ("codecs", 2),
     ("keyframe", 2),
     ("effects", 2),
-    ("text", 2),
     ("audio", 2),
     ("captions", 2),
     ("interchange", 2),
     ("render", 3),
     ("gpu", 3),
+    ("golden", 3),
     ("scopes", 3),
     ("playback", 3),
     ("export", 3),
@@ -55,7 +61,7 @@ const LAYERS: &[(&str, u8)] = &[
 ];
 
 /// L0 crates that are not codecs/containers (no `bitstream`-only restriction).
-const L0_FOUNDATION: &[&str] = &["time", "geom", "color", "bitstream"];
+const L0_FOUNDATION: &[&str] = &["time", "geom", "color", "bitstream", "testkit"];
 
 /// Allowed same-layer edges (from, to).
 const SAME_LAYER: &[(&str, &str)] = &[
@@ -236,6 +242,47 @@ fn wasm() -> Result<(), String> {
     Ok(())
 }
 
+/// (crate, test target) whose ignored `generate_fixtures` test builds that crate's fixture matrix.
+const FIXTURE_GENERATORS: &[(&str, &str)] =
+    &[("h264", "conformance"), ("hevc", "conformance"), ("isobmff", "oracle_demux"), ("matroska", "oracle"), ("prores", "oracle_decode")];
+
+fn fixtures(only: &[String]) -> Result<(), String> {
+    let unknown: Vec<&String> = only.iter().filter(|o| !FIXTURE_GENERATORS.iter().any(|(c, _)| *c == short(o))).collect();
+    if !unknown.is_empty() {
+        let known: Vec<&str> = FIXTURE_GENERATORS.iter().map(|(c, _)| *c).collect();
+        return Err(format!("no fixture generator for {unknown:?} (known: {})", known.join(", ")));
+    }
+    let Some(ff) = filmcraft_testkit::ffmpeg() else {
+        return Err("ffmpeg not found: set FILMCRAFT_FFMPEG=/path/to/ffmpeg or put ffmpeg on PATH".into());
+    };
+    println!("ffmpeg:   {}", ff.display());
+    println!("fixtures: {}", filmcraft_testkit::fixtures::fixtures_root().display());
+    let (mut made, mut cached, mut skipped) = (0, 0, 0);
+    let mut failed = Vec::new();
+    for (krate, target) in FIXTURE_GENERATORS.iter().filter(|(c, _)| only.is_empty() || only.iter().any(|o| short(o) == *c)) {
+        let pkg = format!("filmcraft-{krate}");
+        println!("\n== {pkg} ({target})");
+        let mut cmd = Command::new(env!("CARGO"));
+        cmd.args(["test", "--release", "-p", &pkg, "--test", target, "--", "--ignored", "--exact", "generate_fixtures", "--nocapture"]);
+        cmd.stderr(std::process::Stdio::inherit());
+        let out = cmd.output().map_err(|e| e.to_string())?;
+        for line in String::from_utf8_lossy(&out.stdout).lines() {
+            let Some(rest) = line.strip_prefix("FIXTURE ") else { continue };
+            match rest.split_whitespace().next() {
+                Some("made") => made += 1,
+                Some("cached") => cached += 1,
+                _ => skipped += 1,
+            }
+            println!("  {rest}");
+        }
+        if !out.status.success() {
+            failed.push(pkg);
+        }
+    }
+    println!("\nfixtures: {made} made, {cached} already present, {skipped} skipped");
+    if failed.is_empty() { Ok(()) } else { Err(format!("fixture generation failed in {}", failed.join(", "))) }
+}
+
 fn ci() -> Result<(), String> {
     let cargo = env!("CARGO");
     run(Command::new(cargo).args(["fmt", "--check"]))?;
@@ -259,9 +306,10 @@ fn main() -> ExitCode {
         "layers" => layers(),
         "wasm" => wasm(),
         "assets" => assets(),
+        "fixtures" => fixtures(&std::env::args().skip(2).collect::<Vec<_>>()),
         "ci" => ci(),
         "bench-playback" => bench_playback(),
-        _ => Err("usage: cargo xtask <layers|assets|wasm|ci|bench-playback [args]>".into()),
+        _ => Err("usage: cargo xtask <layers|assets|wasm|fixtures [crate…]|ci|bench-playback [args]>".into()),
     };
     match r {
         Ok(()) => ExitCode::SUCCESS,